libamxc  1.10.3
C Generic Data Containers
test_amxc_set.c
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** SPDX-License-Identifier: BSD-2-Clause-Patent
4 **
5 ** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome
6 **
7 ** Redistribution and use in source and binary forms, with or without modification,
8 ** are permitted provided that the following conditions are met:
9 **
10 ** 1. Redistributions of source code must retain the above copyright notice,
11 ** this list of conditions and the following disclaimer.
12 **
13 ** 2. Redistributions in binary form must reproduce the above copyright notice,
14 ** this list of conditions and the following disclaimer in the documentation
15 ** and/or other materials provided with the distribution.
16 **
17 ** Subject to the terms and conditions of this license, each copyright holder
18 ** and contributor hereby grants to those receiving rights under this license
19 ** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
20 ** (except for failure to satisfy the conditions of this license) patent license
21 ** to make, have made, use, offer to sell, sell, import, and otherwise transfer
22 ** this software, where such license applies only to those patent claims, already
23 ** acquired or hereafter acquired, licensable by such copyright holder or contributor
24 ** that are necessarily infringed by:
25 **
26 ** (a) their Contribution(s) (the licensed copyrights of copyright holders and
27 ** non-copyrightable additions of contributors, in source or binary form) alone;
28 ** or
29 **
30 ** (b) combination of their Contribution(s) with the work of authorship to which
31 ** such Contribution(s) was added by such copyright holder or contributor, if,
32 ** at the time the Contribution is added, such addition causes such combination
33 ** to be necessarily infringed. The patent license shall not apply to any other
34 ** combinations which include the Contribution.
35 **
36 ** Except as expressly stated above, no rights or licenses from any copyright
37 ** holder or contributor is granted under this license, whether expressly, by
38 ** implication, estoppel or otherwise.
39 **
40 ** DISCLAIMER
41 **
42 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
43 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
46 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
48 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
49 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50 ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
51 ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
52 **
53 ****************************************************************************/
54 
55 #include <stdlib.h>
56 #include <stdio.h>
57 #include <stdarg.h>
58 #include <stddef.h>
59 #include <ctype.h>
60 #include <string.h>
61 #include <setjmp.h>
62 #include <cmocka.h>
63 
64 #include <amxc/amxc_set.h>
65 
66 #include "test_amxc_set.h"
67 
68 #include <amxc/amxc_macros.h>
69 
70 void test_amxc_set_new_delete_null(UNUSED void** state) {
71  // passing NULL pointers should not lead to segfault
72  assert_int_not_equal(amxc_set_new(NULL, 0), 0);
73  amxc_set_delete(NULL);
74 }
75 
76 void test_amxc_set_init_reset_clean_null(UNUSED void** state) {
77  // passing NULL pointers should not lead to segfault
78  assert_int_equal(amxc_set_init(NULL, 0), -1);
79  amxc_set_clean(NULL);
80  amxc_set_reset(NULL);
81 }
82 
83 void test_amxc_set_new_delete(UNUSED void** state) {
84  amxc_set_t* set = NULL;
85 
86  assert_int_equal(amxc_set_new(&set, false), 0);
87  assert_non_null(set);
88  assert_true(amxc_llist_is_empty(&set->list));
89  assert_false(set->counted);
90  assert_int_equal(set->count, 0);
91  assert_null(set->alert_handler);
92  assert_null(set->priv);
93  amxc_set_delete(&set);
94  assert_null(set);
95 
96  assert_int_equal(amxc_set_new(&set, true), 0);
97  assert_non_null(set);
98  assert_true(amxc_llist_is_empty(&set->list));
99  assert_true(set->counted);
100  assert_int_equal(set->count, 0);
101  assert_null(set->alert_handler);
102  assert_null(set->priv);
103  amxc_set_delete(&set);
104  assert_null(set);
105 }
106 
107 void test_amxc_set_init_reset_clean(UNUSED void** state) {
108  amxc_set_t set;
109 
110  assert_int_equal(amxc_set_init(&set, false), 0);
111  assert_true(amxc_llist_is_empty(&set.list));
112  assert_false(set.counted);
113  assert_int_equal(set.count, 0);
114  assert_null(set.alert_handler);
115  assert_null(set.priv);
116  amxc_set_clean(&set);
117 
118  assert_int_equal(amxc_set_init(&set, true), 0);
119  assert_true(amxc_llist_is_empty(&set.list));
120  assert_true(set.counted);
121  assert_int_equal(set.count, 0);
122  assert_null(set.alert_handler);
123  assert_null(set.priv);
124  amxc_set_clean(&set);
125 }
126 
127 void test_amxc_can_add_remove_flags(UNUSED void** state) {
128  amxc_set_t set;
129 
130  assert_int_equal(amxc_set_init(&set, false), 0);
131  assert_true(amxc_llist_is_empty(&set.list));
132 
133  amxc_set_add_flag(&set, "flag1");
134  assert_int_equal(amxc_llist_size(&set.list), 1);
135  amxc_set_add_flag(&set, "flag1");
136  assert_int_equal(amxc_llist_size(&set.list), 1);
137  assert_int_equal(amxc_set_get_count(&set, "flag1"), 1);
138  assert_int_equal(amxc_set_get_count(&set, NULL), 1);
139 
140  amxc_set_add_flag(&set, "flag2");
141  assert_int_equal(amxc_llist_size(&set.list), 2);
142 
143  amxc_set_add_flag(&set, "flag3");
144  assert_int_equal(amxc_llist_size(&set.list), 3);
145  assert_int_equal(amxc_set_get_count(&set, NULL), 3);
146 
147  amxc_set_remove_flag(&set, "flag2");
148  assert_int_equal(amxc_llist_size(&set.list), 2);
149  assert_int_equal(amxc_set_get_count(&set, NULL), 2);
150 
151  assert_true(amxc_set_has_flag(&set, "flag1"));
152  assert_true(amxc_set_has_flag(&set, "flag3"));
153 
154  amxc_set_clean(&set);
155 }
156 
157 void test_amxc_can_add_remove_counted_flags(UNUSED void** state) {
158  amxc_set_t set;
159 
160  assert_int_equal(amxc_set_init(&set, true), 0);
161  assert_true(amxc_llist_is_empty(&set.list));
162 
163  amxc_set_add_flag(&set, "flag1");
164  assert_int_equal(amxc_llist_size(&set.list), 1);
165  amxc_set_add_flag(&set, "flag1");
166  assert_int_equal(amxc_llist_size(&set.list), 1);
167  assert_int_equal(amxc_set_get_count(&set, "flag1"), 2);
168  assert_int_equal(amxc_set_get_count(&set, NULL), 2);
169 
170  amxc_set_add_flag(&set, "flag2");
171  assert_int_equal(amxc_llist_size(&set.list), 2);
172  assert_int_equal(amxc_set_get_count(&set, NULL), 3);
173 
174  amxc_set_add_flag(&set, "flag3");
175  assert_int_equal(amxc_llist_size(&set.list), 3);
176  assert_int_equal(amxc_set_get_count(&set, NULL), 4);
177  amxc_set_add_flag(&set, "flag3");
178  amxc_set_add_flag(&set, "flag3");
179  assert_int_equal(amxc_set_get_count(&set, "flag3"), 3);
180  assert_int_equal(amxc_set_get_count(&set, NULL), 6);
181 
182  amxc_set_add_flag(&set, "");
183  assert_int_equal(amxc_set_get_count(&set, NULL), 6);
184 
185  amxc_set_add_flag(&set, NULL);
186  assert_int_equal(amxc_set_get_count(&set, NULL), 6);
187 
188  amxc_set_remove_flag(&set, "flag2");
189  assert_int_equal(amxc_llist_size(&set.list), 2);
190  assert_int_equal(amxc_set_get_count(&set, NULL), 5);
191  assert_true(amxc_set_has_flag(&set, "flag1"));
192  assert_true(amxc_set_has_flag(&set, "flag3"));
193 
194  amxc_set_remove_flag(&set, "flag1");
195  assert_true(amxc_set_has_flag(&set, "flag1"));
196  assert_int_equal(amxc_set_get_count(&set, "flag1"), 1);
197  assert_int_equal(amxc_set_get_count(&set, NULL), 4);
198  amxc_set_remove_flag(&set, "flag1");
199  assert_false(amxc_set_has_flag(&set, "flag1"));
200  assert_int_equal(amxc_set_get_count(&set, "flag1"), 0);
201  assert_int_equal(amxc_set_get_count(&set, NULL), 3);
202  amxc_set_remove_flag(&set, "flag1");
203  assert_false(amxc_set_has_flag(&set, "flag1"));
204  assert_int_equal(amxc_set_get_count(&set, "flag1"), 0);
205  assert_int_equal(amxc_set_get_count(&set, NULL), 3);
206 
207  amxc_set_remove_flag(&set, "");
208  assert_int_equal(amxc_set_get_count(&set, NULL), 3);
209 
210  amxc_set_remove_flag(&set, NULL);
211  assert_int_equal(amxc_set_get_count(&set, NULL), 3);
212 
213  amxc_set_clean(&set);
214 }
215 
216 void test_amxc_can_subtract_set(UNUSED void** state) {
217  amxc_set_t set1;
218  amxc_set_t set2;
219 
220  assert_int_equal(amxc_set_init(&set1, false), 0);
221  assert_int_equal(amxc_set_init(&set2, false), 0);
222 
223  amxc_set_add_flag(&set1, "flag1");
224  amxc_set_add_flag(&set1, "flag2");
225  amxc_set_add_flag(&set1, "flag3");
226  amxc_set_add_flag(&set1, "flag4");
227  amxc_set_add_flag(&set1, "flag5");
228 
229  amxc_set_add_flag(&set2, "flag2");
230  amxc_set_add_flag(&set2, "flag4");
231 
232  amxc_set_subtract(&set1, &set2);
233  assert_int_equal(amxc_set_get_count(&set1, NULL), 3);
234  assert_int_equal(amxc_set_get_count(&set2, NULL), 2);
235 
236  assert_false(amxc_set_has_flag(&set1, "flag2"));
237  assert_false(amxc_set_has_flag(&set1, "flag4"));
238  assert_true(amxc_set_has_flag(&set1, "flag1"));
239  assert_true(amxc_set_has_flag(&set1, "flag3"));
240  assert_true(amxc_set_has_flag(&set1, "flag5"));
241 
242  amxc_set_clean(&set1);
243  amxc_set_clean(&set2);
244 }
245 
246 void test_amxc_can_check_sets_are_equal(UNUSED void** state) {
247  amxc_set_t set1;
248  amxc_set_t set2;
249 
250  assert_int_equal(amxc_set_init(&set1, false), 0);
251  assert_int_equal(amxc_set_init(&set2, false), 0);
252 
253  amxc_set_add_flag(&set1, "flag1");
254  amxc_set_add_flag(&set1, "flag2");
255  amxc_set_add_flag(&set1, "flag3");
256  amxc_set_add_flag(&set1, "flag4");
257 
258  amxc_set_add_flag(&set2, "flag2");
259  amxc_set_add_flag(&set2, "flag4");
260  amxc_set_add_flag(&set2, "flag3");
261  amxc_set_add_flag(&set2, "flag1");
262 
263  assert_true(amxc_set_is_equal(&set1, &set2));
264  assert_true(amxc_set_is_equal(&set2, &set1));
265  amxc_set_remove_flag(&set2, "flag4");
266  assert_false(amxc_set_is_equal(&set1, &set2));
267  assert_false(amxc_set_is_equal(&set2, &set1));
268 
269  amxc_set_clean(&set1);
270  amxc_set_clean(&set2);
271 }
272 
273 void test_amxc_set_parse(UNUSED void** state) {
274  amxc_set_t set;
275 
276  assert_int_equal(amxc_set_init(&set, false), 0);
277  assert_true(amxc_llist_is_empty(&set.list));
278 
279  assert_int_equal(amxc_set_parse(&set, "flag1 flag2 flag3"), 0);
280  assert_false(amxc_llist_is_empty(&set.list));
281  assert_int_equal(amxc_llist_size(&set.list), 3);
282  assert_true(amxc_set_has_flag(&set, "flag1"));
283  assert_true(amxc_set_has_flag(&set, "flag3"));
284  assert_false(amxc_set_has_flag(&set, "flag5"));
285 
286  amxc_set_reset(&set);
287  assert_true(amxc_llist_is_empty(&set.list));
288 
289  assert_int_equal(amxc_set_parse(&set, "flag1 flag2 flag3"), 0);
290  assert_false(amxc_llist_is_empty(&set.list));
291  assert_int_equal(amxc_llist_size(&set.list), 3);
292  assert_int_equal(amxc_set_parse(&set, "flag1 flag4 flag5 flag6 flag1"), 0);
293  assert_false(amxc_llist_is_empty(&set.list));
294  assert_int_equal(amxc_llist_size(&set.list), 4);
295  assert_true(amxc_set_has_flag(&set, "flag1"));
296  assert_false(amxc_set_has_flag(&set, "flag3"));
297  assert_true(amxc_set_has_flag(&set, "flag5"));
298 
299  amxc_set_clean(&set);
300  assert_true(amxc_llist_is_empty(&set.list));
301 }
302 
303 void test_amxc_set_parse_with_count(UNUSED void** state) {
304  amxc_set_t set;
305 
306  assert_int_equal(amxc_set_init(&set, true), 0);
307  assert_true(amxc_llist_is_empty(&set.list));
308 
309  assert_int_equal(amxc_set_parse(&set, "flag1 flag2:10 flag3:5"), 0);
310  assert_false(amxc_llist_is_empty(&set.list));
311  assert_int_equal(amxc_llist_size(&set.list), 3);
312  assert_true(amxc_set_has_flag(&set, "flag1"));
313  assert_true(amxc_set_has_flag(&set, "flag3"));
314  assert_false(amxc_set_has_flag(&set, "flag5"));
315  assert_int_equal(amxc_set_get_count(&set, "flag1"), 1);
316  assert_int_equal(amxc_set_get_count(&set, "flag3"), 5);
317  assert_int_equal(amxc_set_get_count(&set, "flag5"), 0);
318  assert_int_equal(amxc_set_get_count(&set, NULL), 16);
319 
320  amxc_set_reset(&set);
321  assert_true(amxc_llist_is_empty(&set.list));
322 
323  assert_int_equal(amxc_set_parse(&set, "flag1:0 flag2:3 flag3:10"), 0);
324  assert_false(amxc_llist_is_empty(&set.list));
325  assert_int_equal(amxc_llist_size(&set.list), 2);
326  assert_false(amxc_set_has_flag(&set, "flag1"));
327  assert_true(amxc_set_has_flag(&set, "flag3"));
328  assert_false(amxc_set_has_flag(&set, "flag5"));
329  assert_int_equal(amxc_set_get_count(&set, "flag1"), 0);
330  assert_int_equal(amxc_set_get_count(&set, "flag3"), 10);
331  assert_int_equal(amxc_set_get_count(&set, "flag5"), 0);
332  assert_int_equal(amxc_set_get_count(&set, NULL), 13);
333 
334  assert_int_equal(amxc_set_parse(&set, "flag1 flag4:2 flag5 flag6:8 flag1:4"), 0);
335  assert_false(amxc_llist_is_empty(&set.list));
336  assert_int_equal(amxc_llist_size(&set.list), 4);
337  assert_int_equal(amxc_set_get_count(&set, NULL), 16);
338  assert_int_equal(amxc_set_get_count(&set, "flag1"), 5);
339 
340  assert_int_equal(amxc_set_parse(&set, ""), 0);
341  assert_true(amxc_llist_is_empty(&set.list));
342  assert_int_equal(amxc_set_parse(&set, NULL), 0);
343  assert_true(amxc_llist_is_empty(&set.list));
344 
345  amxc_set_clean(&set);
346  assert_true(amxc_llist_is_empty(&set.list));
347 
348  assert_int_equal(amxc_set_parse(&set, "flag1:8"), 0);
349  assert_false(amxc_llist_is_empty(&set.list));
350  assert_int_equal(amxc_llist_size(&set.list), 1);
351  assert_int_equal(amxc_set_get_count(&set, "flag1"), 8);
352  assert_int_equal(amxc_set_get_count(&set, NULL), 8);
353 
354  assert_int_equal(amxc_set_parse(&set, "flag1:3 flag1:4"), 0);
355  assert_false(amxc_llist_is_empty(&set.list));
356  assert_int_equal(amxc_llist_size(&set.list), 1);
357  assert_int_equal(amxc_set_get_count(&set, "flag1"), 7);
358  assert_int_equal(amxc_set_get_count(&set, NULL), 7);
359 
360  amxc_set_clean(&set);
361  assert_true(amxc_llist_is_empty(&set.list));
362 }
363 
364 void test_amxc_set_parse_invalid_input(UNUSED void** state) {
365  amxc_set_t set;
366 
367  assert_int_equal(amxc_set_init(&set, true), 0);
368  assert_true(amxc_llist_is_empty(&set.list));
369 
370  assert_int_not_equal(amxc_set_parse(NULL, "flag1 flag2:10 flag3:5"), 0);
371  assert_int_not_equal(amxc_set_parse(&set, "flag1:flag2:5 flag3"), 0);
372  assert_true(amxc_llist_is_empty(&set.list));
373 
374  amxc_set_clean(&set);
375 }
376 
377 void test_amxc_set_to_string_counted(UNUSED void** state) {
378  amxc_set_t set;
379  char* set_str = NULL;
380 
381  assert_int_equal(amxc_set_init(&set, true), 0);
382  assert_true(amxc_llist_is_empty(&set.list));
383 
384  assert_int_equal(amxc_set_parse(&set, "flag1 flag2:10 flag3:5"), 0);
385  set_str = amxc_set_to_string(&set);
386 
387  assert_string_equal(set_str, "flag1 flag2:10 flag3:5");
388 
389  free(set_str);
390  amxc_set_clean(&set);
391 }
392 
393 void test_amxc_set_to_string(UNUSED void** state) {
394  amxc_set_t set;
395  char* set_str = NULL;
396 
397  assert_int_equal(amxc_set_init(&set, false), 0);
398  assert_true(amxc_llist_is_empty(&set.list));
399 
400  assert_int_equal(amxc_set_parse(&set, "flag1 flag2:10 flag3:5"), 0);
401  set_str = amxc_set_to_string(&set);
402 
403  assert_string_equal(set_str, "flag1 flag2 flag3");
404 
405  free(set_str);
406  amxc_set_clean(&set);
407 }
408 
409 void test_amxc_set_to_string_sep(UNUSED void** state) {
410  amxc_set_t set;
411  char* set_str = NULL;
412 
413  assert_int_equal(amxc_set_init(&set, false), 0);
414  assert_true(amxc_llist_is_empty(&set.list));
415 
416  assert_int_equal(amxc_set_parse(&set, "flag1 flag2:10 flag3:5"), 0);
417  set_str = amxc_set_to_string_sep(&set, ",");
418 
419  assert_string_equal(set_str, "flag1,flag2,flag3");
420 
421  free(set_str);
422  amxc_set_clean(&set);
423 }
424 
425 void test_amxc_set_copy(UNUSED void** state) {
426  amxc_set_t* set = NULL;
427  amxc_set_t* copy = NULL;
428 
429  assert_null(amxc_set_copy(NULL));
430 
431  assert_int_equal(amxc_set_new(&set, false), 0);
432  assert_non_null(set);
433 
434  copy = amxc_set_copy(set);
435  assert_non_null(copy);
436  assert_true(amxc_set_is_equal(set, copy));
437  assert_null(copy->alert_handler);
438  assert_null(copy->priv);
439  amxc_set_delete(&copy);
440  assert_null(copy);
441 
442  assert_int_equal(amxc_set_parse(set, "flag1 flag2 flag3"), 0);
443 
444  copy = amxc_set_copy(set);
445  assert_non_null(copy);
446  assert_true(amxc_set_is_equal(set, copy));
447  assert_null(copy->alert_handler);
448  assert_null(copy->priv);
449  amxc_set_delete(&copy);
450  assert_null(copy);
451 
452  amxc_set_delete(&set);
453  assert_null(set);
454 
455  assert_int_equal(amxc_set_new(&set, true), 0);
456  assert_non_null(set);
457 
458  copy = amxc_set_copy(set);
459  assert_non_null(copy);
460  assert_true(amxc_set_is_equal(set, copy));
461  assert_null(copy->alert_handler);
462  assert_null(copy->priv);
463  amxc_set_delete(&copy);
464  assert_null(copy);
465 
466  assert_int_equal(amxc_set_parse(set, "flag1:3 flag2:5 flag3:23"), 0);
467 
468  copy = amxc_set_copy(set);
469  assert_non_null(copy);
470  assert_true(amxc_set_is_equal(set, copy));
471  assert_null(copy->alert_handler);
472  assert_null(copy->priv);
473  amxc_set_delete(&copy);
474  assert_null(copy);
475 
476  amxc_set_delete(&set);
477  assert_null(set);
478 }
479 
480 void test_amxc_set_symmetric_difference(UNUSED void** state) {
481  amxc_set_t set1;
482  amxc_set_t set2;
483  amxc_set_t cmp;
484 
485  assert_int_equal(amxc_set_init(&set1, false), 0);
486  assert_int_equal(amxc_set_init(&set2, false), 0);
487  assert_int_equal(amxc_set_init(&cmp, false), 0);
488 
489  amxc_set_symmetric_difference(NULL, NULL);
490 
491  assert_int_equal(amxc_set_parse(&set1, "flag1 flag2 flag3"), 0);
492  assert_int_equal(amxc_set_parse(&set2, "flag1 flag4 flag5"), 0);
493  assert_int_equal(amxc_set_parse(&cmp, "flag1 flag2 flag3"), 0);
494 
495  amxc_set_symmetric_difference(&set1, NULL);
496  assert_true(amxc_set_is_equal(&set1, &cmp));
497 
498  amxc_set_reset(&cmp);
499  assert_int_equal(amxc_set_parse(&cmp, "flag2 flag3 flag4 flag5"), 0);
500  amxc_set_symmetric_difference(&set1, &set2);
501  assert_true(amxc_set_is_equal(&set1, &cmp));
502 
503  amxc_set_clean(&set1);
504  amxc_set_clean(&set2);
505  amxc_set_clean(&cmp);
506  assert_int_equal(amxc_set_init(&set1, true), 0);
507  assert_int_equal(amxc_set_init(&set2, true), 0);
508  assert_int_equal(amxc_set_init(&cmp, true), 0);
509 
510  assert_int_equal(amxc_set_parse(&set1, "flag1:3 flag2:2 flag3:6"), 0);
511  assert_int_equal(amxc_set_parse(&set2, "flag1:2 flag4:8 flag5:9"), 0);
512  assert_int_equal(amxc_set_parse(&cmp, "flag1:3 flag2:2 flag3:6"), 0);
513 
514  amxc_set_symmetric_difference(&set1, NULL);
515  assert_true(amxc_set_is_equal(&set1, &cmp));
516 
517  amxc_set_reset(&cmp);
518  assert_int_equal(amxc_set_parse(&cmp, "flag1:1 flag2:2 flag3:6 flag4:8 flag5:9"), 0);
519  amxc_set_symmetric_difference(&set1, &set2);
520  assert_true(amxc_set_is_equal(&set1, &cmp));
521 
522  amxc_set_clean(&set1);
523  amxc_set_clean(&set2);
524  amxc_set_clean(&cmp);
525 }
amxc_macros.h
UNUSED
#define UNUSED
Definition: amxc_macros.h:70
amxc_set.h
Ambiorix set API header file.
amxc_llist_size
size_t amxc_llist_size(const amxc_llist_t *const llist)
Calculates the size of the linked list.
Definition: amxc_llist.c:151
amxc_llist_is_empty
bool amxc_llist_is_empty(const amxc_llist_t *const llist)
Checks that the linked list is empty.
Definition: amxc_llist.c:165
amxc_set_remove_flag
void amxc_set_remove_flag(amxc_set_t *set, const char *flag)
Removes a flag from a set or decreases the flag counter.
Definition: amxc_set.c:315
amxc_set_to_string_sep
char * amxc_set_to_string_sep(const amxc_set_t *const set, const char *sep)
Converts a set to a separated string of flags.
Definition: amxc_set.c:264
amxc_set_new
int amxc_set_new(amxc_set_t **set, bool counted)
Allocates a set.
Definition: amxc_set.c:138
amxc_set_reset
void amxc_set_reset(amxc_set_t *set)
Reset or empty a set, i.e. clear all flags.
Definition: amxc_set.c:199
amxc_set_copy
amxc_set_t * amxc_set_copy(const amxc_set_t *const set)
Copies a set.
Definition: amxc_set.c:187
amxc_set_is_equal
bool amxc_set_is_equal(const amxc_set_t *const set1, const amxc_set_t *const set2)
Compare two sets.
Definition: amxc_set.c:430
amxc_set_add_flag
void amxc_set_add_flag(amxc_set_t *set, const char *flag)
Adds a flag to a set, or increases the flag counter.
Definition: amxc_set.c:305
amxc_set_delete
void amxc_set_delete(amxc_set_t **set)
Frees a set.
Definition: amxc_set.c:151
amxc_set_symmetric_difference
void amxc_set_symmetric_difference(amxc_set_t *const set, const amxc_set_t *const operand)
Calculates the symmetric difference of two sets.
Definition: amxc_set.c:463
amxc_set_init
int amxc_set_init(amxc_set_t *const set, bool counted)
Initializes a set.
Definition: amxc_set.c:162
amxc_set_to_string
char * amxc_set_to_string(const amxc_set_t *const set)
Converts a set to a space-separated string of flags.
Definition: amxc_set.c:301
amxc_set_get_count
uint32_t amxc_set_get_count(const amxc_set_t *const set, const char *flag)
Get a flag counter.
Definition: amxc_set.c:349
amxc_set_parse
int amxc_set_parse(amxc_set_t *set, const char *str)
Parses a space-separated string of flags and adds them to the set.
Definition: amxc_set.c:210
amxc_set_clean
void amxc_set_clean(amxc_set_t *const set)
Cleans a set.
Definition: amxc_set.c:177
amxc_set_has_flag
bool amxc_set_has_flag(const amxc_set_t *const set, const char *flag)
Check if a set contains a flag.
Definition: amxc_set.c:337
amxc_set_subtract
void amxc_set_subtract(amxc_set_t *const set, const amxc_set_t *const operand)
Subtract a set from another set.
Definition: amxc_set.c:408
_set
The set structure.
Definition: amxc_set.h:129
_set::counted
bool counted
Definition: amxc_set.h:134
_set::alert_handler
amxc_set_alert_t alert_handler
Definition: amxc_set.h:131
_set::count
int count
Definition: amxc_set.h:135
_set::list
amxc_llist_t list
Definition: amxc_set.h:130
_set::priv
void * priv
Definition: amxc_set.h:133
test_amxc_set_to_string_sep
void test_amxc_set_to_string_sep(UNUSED void **state)
Definition: test_amxc_set.c:409
test_amxc_set_parse_invalid_input
void test_amxc_set_parse_invalid_input(UNUSED void **state)
Definition: test_amxc_set.c:364
test_amxc_can_add_remove_counted_flags
void test_amxc_can_add_remove_counted_flags(UNUSED void **state)
Definition: test_amxc_set.c:157
test_amxc_set_new_delete_null
void test_amxc_set_new_delete_null(UNUSED void **state)
Definition: test_amxc_set.c:70
test_amxc_can_add_remove_flags
void test_amxc_can_add_remove_flags(UNUSED void **state)
Definition: test_amxc_set.c:127
test_amxc_set_parse
void test_amxc_set_parse(UNUSED void **state)
Definition: test_amxc_set.c:273
test_amxc_set_to_string_counted
void test_amxc_set_to_string_counted(UNUSED void **state)
Definition: test_amxc_set.c:377
test_amxc_set_copy
void test_amxc_set_copy(UNUSED void **state)
Definition: test_amxc_set.c:425
test_amxc_set_symmetric_difference
void test_amxc_set_symmetric_difference(UNUSED void **state)
Definition: test_amxc_set.c:480
test_amxc_set_new_delete
void test_amxc_set_new_delete(UNUSED void **state)
Definition: test_amxc_set.c:83
test_amxc_set_init_reset_clean_null
void test_amxc_set_init_reset_clean_null(UNUSED void **state)
Definition: test_amxc_set.c:76
test_amxc_can_check_sets_are_equal
void test_amxc_can_check_sets_are_equal(UNUSED void **state)
Definition: test_amxc_set.c:246
test_amxc_set_to_string
void test_amxc_set_to_string(UNUSED void **state)
Definition: test_amxc_set.c:393
test_amxc_set_parse_with_count
void test_amxc_set_parse_with_count(UNUSED void **state)
Definition: test_amxc_set.c:303
test_amxc_can_subtract_set
void test_amxc_can_subtract_set(UNUSED void **state)
Definition: test_amxc_set.c:216
test_amxc_set_init_reset_clean
void test_amxc_set_init_reset_clean(UNUSED void **state)
Definition: test_amxc_set.c:107
test_amxc_set.h