libamxc  1.10.3
C Generic Data Containers
Functions
test_amxc_set.c File Reference
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <ctype.h>
#include <string.h>
#include <setjmp.h>
#include <cmocka.h>
#include <amxc/amxc_set.h>
#include "test_amxc_set.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

void test_amxc_set_new_delete_null (UNUSED void **state)
 
void test_amxc_set_init_reset_clean_null (UNUSED void **state)
 
void test_amxc_set_new_delete (UNUSED void **state)
 
void test_amxc_set_init_reset_clean (UNUSED void **state)
 
void test_amxc_can_add_remove_flags (UNUSED void **state)
 
void test_amxc_can_add_remove_counted_flags (UNUSED void **state)
 
void test_amxc_can_subtract_set (UNUSED void **state)
 
void test_amxc_can_check_sets_are_equal (UNUSED void **state)
 
void test_amxc_set_parse (UNUSED void **state)
 
void test_amxc_set_parse_with_count (UNUSED void **state)
 
void test_amxc_set_parse_invalid_input (UNUSED void **state)
 
void test_amxc_set_to_string_counted (UNUSED void **state)
 
void test_amxc_set_to_string (UNUSED void **state)
 
void test_amxc_set_to_string_sep (UNUSED void **state)
 
void test_amxc_set_copy (UNUSED void **state)
 
void test_amxc_set_symmetric_difference (UNUSED void **state)
 

Function Documentation

◆ test_amxc_can_add_remove_counted_flags()

void test_amxc_can_add_remove_counted_flags ( UNUSED void **  state)

Definition at line 157 of file test_amxc_set.c.

157  {
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 }
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_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_init
int amxc_set_init(amxc_set_t *const set, bool counted)
Initializes a set.
Definition: amxc_set.c:162
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_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
_set
The set structure.
Definition: amxc_set.h:129
_set::list
amxc_llist_t list
Definition: amxc_set.h:130

◆ test_amxc_can_add_remove_flags()

void test_amxc_can_add_remove_flags ( UNUSED void **  state)

Definition at line 127 of file test_amxc_set.c.

127  {
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 }

◆ test_amxc_can_check_sets_are_equal()

void test_amxc_can_check_sets_are_equal ( UNUSED void **  state)

Definition at line 246 of file test_amxc_set.c.

246  {
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 }
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

◆ test_amxc_can_subtract_set()

void test_amxc_can_subtract_set ( UNUSED void **  state)

Definition at line 216 of file test_amxc_set.c.

216  {
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 }
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

◆ test_amxc_set_copy()

void test_amxc_set_copy ( UNUSED void **  state)

Definition at line 425 of file test_amxc_set.c.

425  {
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 }
amxc_set_new
int amxc_set_new(amxc_set_t **set, bool counted)
Allocates a set.
Definition: amxc_set.c:138
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_delete
void amxc_set_delete(amxc_set_t **set)
Frees a set.
Definition: amxc_set.c:151
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
_set::alert_handler
amxc_set_alert_t alert_handler
Definition: amxc_set.h:131
_set::priv
void * priv
Definition: amxc_set.h:133

◆ test_amxc_set_init_reset_clean()

void test_amxc_set_init_reset_clean ( UNUSED void **  state)

Definition at line 107 of file test_amxc_set.c.

107  {
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 }
_set::counted
bool counted
Definition: amxc_set.h:134
_set::count
int count
Definition: amxc_set.h:135

◆ test_amxc_set_init_reset_clean_null()

void test_amxc_set_init_reset_clean_null ( UNUSED void **  state)

Definition at line 76 of file test_amxc_set.c.

76  {
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 }
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

◆ test_amxc_set_new_delete()

void test_amxc_set_new_delete ( UNUSED void **  state)

Definition at line 83 of file test_amxc_set.c.

83  {
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 }

◆ test_amxc_set_new_delete_null()

void test_amxc_set_new_delete_null ( UNUSED void **  state)

Definition at line 70 of file test_amxc_set.c.

70  {
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 }

◆ test_amxc_set_parse()

void test_amxc_set_parse ( UNUSED void **  state)

Definition at line 273 of file test_amxc_set.c.

273  {
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 }

◆ test_amxc_set_parse_invalid_input()

void test_amxc_set_parse_invalid_input ( UNUSED void **  state)

Definition at line 364 of file test_amxc_set.c.

364  {
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 }

◆ test_amxc_set_parse_with_count()

void test_amxc_set_parse_with_count ( UNUSED void **  state)

Definition at line 303 of file test_amxc_set.c.

303  {
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 }

◆ test_amxc_set_symmetric_difference()

void test_amxc_set_symmetric_difference ( UNUSED void **  state)

Definition at line 480 of file test_amxc_set.c.

480  {
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_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

◆ test_amxc_set_to_string()

void test_amxc_set_to_string ( UNUSED void **  state)

Definition at line 393 of file test_amxc_set.c.

393  {
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 }
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

◆ test_amxc_set_to_string_counted()

void test_amxc_set_to_string_counted ( UNUSED void **  state)

Definition at line 377 of file test_amxc_set.c.

377  {
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 }

◆ test_amxc_set_to_string_sep()

void test_amxc_set_to_string_sep ( UNUSED void **  state)

Definition at line 409 of file test_amxc_set.c.

409  {
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 }
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