libamxc  1.10.3
C Generic Data Containers
test_variant_list.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 <sys/time.h>
56 #include <sys/resource.h>
57 
58 #include <string.h>
59 #include <stdlib.h>
60 #include <stdio.h>
61 #include <stdarg.h>
62 #include <stddef.h>
63 #include <setjmp.h>
64 #include <inttypes.h>
65 #include <limits.h>
66 #include <unistd.h>
67 #include <fcntl.h>
68 #include <cmocka.h>
69 
70 #include <amxc/amxc_variant.h>
71 #include <amxc_variant_priv.h>
72 
73 #include "test_variant_list.h"
74 
75 #include <amxc/amxc_macros.h>
76 void test_variant_list_copy(UNUSED void** state) {
77  amxc_var_t string;
78  amxc_var_t var;
79  amxc_var_t copy_var;
80  amxc_llist_t* list = NULL;
81 
82  assert_int_equal(amxc_var_init(&string), 0);
83  assert_int_equal(amxc_var_init(&var), 0);
84  assert_int_equal(amxc_var_init(&copy_var), 0);
85  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
86  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
87  string.data.s = strdup("");
88 
89  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
90  assert_int_equal(amxc_llist_size(&var.data.vl), 0);
91  free(string.data.s);
92 
93  assert_int_equal(string.type_id, AMXC_VAR_ID_CSTRING);
94  string.data.s = strdup("Hello,world,and,anyone,else,in,the,universe");
95  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
96  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
97 
98  assert_int_equal(amxc_var_copy(&copy_var, &var), 0);
99  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
100  free(string.data.s);
101 
102  list = &copy_var.data.vl;
103  amxc_llist_for_each(it, list) {
104  amxc_var_t* item = amxc_var_from_llist_it(it);
105  assert_int_equal(item->type_id, AMXC_VAR_ID_CSTRING);
106  }
107 
108  amxc_var_clean(&var);
109  amxc_var_clean(&copy_var);
110 }
111 
112 void test_variant_list_move(UNUSED void** state) {
113  amxc_var_t src;
114  amxc_var_t dst;
115 
116  assert_int_equal(amxc_var_init(&src), 0);
117  assert_int_equal(amxc_var_init(&dst), 0);
118  amxc_var_set_type(&src, AMXC_VAR_ID_LIST);
119 
120  amxc_var_add(cstring_t, &src, "item1");
121  amxc_var_add(cstring_t, &src, "item2");
122  amxc_var_add(cstring_t, &src, "item3");
123  amxc_var_add(cstring_t, &src, "item4");
124 
125  assert_int_equal(amxc_llist_size(amxc_var_constcast(amxc_llist_t, &src)), 4);
126  assert_int_equal(amxc_var_move(&dst, &src), 0);
127  assert_true(amxc_var_is_null(&src));
128  assert_int_equal(amxc_var_type_of(&dst), AMXC_VAR_ID_LIST);
129  assert_int_equal(amxc_llist_size(amxc_var_constcast(amxc_llist_t, &dst)), 4);
130 
131  amxc_var_clean(&dst);
132  amxc_var_clean(&src);
133 }
134 
135 void test_variant_list_convert_to_bool(UNUSED void** state) {
136  amxc_var_t string;
137  amxc_var_t var;
138  amxc_var_t copy_var;
139 
140 
141  assert_int_equal(amxc_var_init(&string), 0);
142  assert_int_equal(amxc_var_init(&var), 0);
143  assert_int_equal(amxc_var_init(&copy_var), 0);
144  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
145  assert_int_equal(amxc_var_set_type(&copy_var, AMXC_VAR_ID_LIST), 0);
146  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_LIST);
147 
148  assert_true(amxc_llist_is_empty(&copy_var.data.vl));
149  assert_int_equal(amxc_var_convert(&var, &copy_var, AMXC_VAR_ID_BOOL), 0);
150  assert_false(var.data.b);
151 
152  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
153  assert_int_equal(string.type_id, AMXC_VAR_ID_CSTRING);
154  string.data.s = strdup("Hello,world,and,anyone,else,in,the,universe");
155 
156  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
157  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
158  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
159  assert_true(copy_var.data.b);
160 
161  free(string.data.s);
162  amxc_var_clean(&var);
163  amxc_var_clean(&copy_var);
164 }
165 
166 void test_variant_list_convert_to_integer(UNUSED void** state) {
167  amxc_var_t string;
168  amxc_var_t var;
169  amxc_var_t copy_var;
170 
171  assert_int_equal(amxc_var_init(&string), 0);
172  assert_int_equal(amxc_var_init(&var), 0);
173  assert_int_equal(amxc_var_init(&copy_var), 0);
174  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
175  assert_int_equal(amxc_var_set_type(&copy_var, AMXC_VAR_ID_LIST), 0);
176  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_LIST);
177 
178  assert_true(amxc_llist_is_empty(&copy_var.data.vl));
179  assert_int_equal(amxc_var_convert(&var, &copy_var, AMXC_VAR_ID_UINT64), 0);
180  assert_int_equal(var.data.ui64, 0);
181 
182  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
183  assert_int_equal(string.type_id, AMXC_VAR_ID_CSTRING);
184  string.data.s = strdup("Hello,world,and,anyone,else,in,the,universe");
185 
186  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
187  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
188  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
189  assert_int_equal(copy_var.data.ui64, 8);
190 
191  free(string.data.s);
192  amxc_var_clean(&var);
193  amxc_var_clean(&copy_var);
194 }
195 
196 void test_variant_list_convert_to_htable(UNUSED void** state) {
197  amxc_var_t string;
198  amxc_var_t var;
199  amxc_var_t copy_var;
200 
201  assert_int_equal(amxc_var_init(&string), 0);
202  assert_int_equal(amxc_var_init(&var), 0);
203  assert_int_equal(amxc_var_init(&copy_var), 0);
204  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
205  assert_int_equal(amxc_var_set_type(&copy_var, AMXC_VAR_ID_LIST), 0);
206  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_LIST);
207 
208  assert_true(amxc_llist_is_empty(&copy_var.data.vl));
209  assert_int_equal(amxc_var_convert(&var, &copy_var, AMXC_VAR_ID_HTABLE), 0);
210  assert_int_equal(amxc_htable_size(&var.data.vm), 0);
211  assert_true(amxc_htable_is_empty(&var.data.vm));
212 
213  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
214  assert_int_equal(string.type_id, AMXC_VAR_ID_CSTRING);
215  string.data.s = strdup("Hello,world,and,anyone,else,in,the,universe");
216 
217  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
218  assert_int_equal(var.type_id, AMXC_VAR_ID_LIST);
219  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
220  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_HTABLE), 0);
221  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_HTABLE);
222  assert_false(amxc_htable_is_empty(&copy_var.data.vm));
223 
224  free(string.data.s);
225  amxc_var_clean(&var);
226  amxc_var_clean(&copy_var);
227 }
228 
229 void test_variant_list_convert_to_string(UNUSED void** state) {
230  amxc_var_t string;
231  amxc_var_t var;
232  amxc_var_t copy_var;
233 
234  assert_int_equal(amxc_var_init(&string), 0);
235  assert_int_equal(amxc_var_init(&var), 0);
236  assert_int_equal(amxc_var_init(&copy_var), 0);
237  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
238  assert_int_equal(amxc_var_set_type(&copy_var, AMXC_VAR_ID_LIST), 0);
239  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_LIST);
240 
241  assert_true(amxc_llist_is_empty(&copy_var.data.vl));
242  assert_int_equal(amxc_var_convert(&var, &copy_var, AMXC_VAR_ID_CSTRING), 0);
243  assert_ptr_equal(var.data.s, NULL);
244 
245  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
246  assert_int_equal(string.type_id, AMXC_VAR_ID_CSTRING);
247  string.data.s = strdup("Hello,world,and,anyone,else,in,the,universe");
248 
249  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
250  assert_int_equal(var.type_id, AMXC_VAR_ID_LIST);
251  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
252  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CSTRING), 0);
253  assert_string_equal(copy_var.data.s, "Hello,world,and,anyone,else,in,the,universe");
254 
255  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
256  assert_int_equal(var.type_id, AMXC_VAR_ID_LIST);
257  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
258  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CSV_STRING), 0);
259  assert_string_equal(copy_var.data.s, "Hello,world,and,anyone,else,in,the,universe");
260 
261  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
262  assert_int_equal(var.type_id, AMXC_VAR_ID_LIST);
263  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
264  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_SSV_STRING), 0);
265  assert_string_equal(copy_var.data.s, "Hello world and anyone else in the universe");
266 
267  free(string.data.s);
268  amxc_var_clean(&var);
269  amxc_var_clean(&copy_var);
270 }
271 
272 void test_variant_llist_set_get(UNUSED void** state) {
273  amxc_var_t var;
274  amxc_var_t string;
275  amxc_llist_t* list = NULL;
276  const amxc_llist_t* constlist = NULL;
277 
278  assert_int_equal(amxc_var_init(&string), 0);
279  assert_int_equal(amxc_var_init(&var), 0);
280 
281  list = amxc_var_dyncast(amxc_llist_t, NULL);
282  assert_ptr_equal(list, NULL);
283 
284  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE), 0);
285  list = amxc_var_dyncast(amxc_llist_t, &var);
286  assert_ptr_equal(list, NULL);
287  constlist = amxc_var_constcast(amxc_llist_t, &var);
288  assert_ptr_equal(constlist, NULL);
289 
290  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
291  string.data.s = strdup("Hello,world,and,anyone,else,in,the,universe");
292  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
293 
294  list = amxc_var_dyncast(amxc_llist_t, &var);
295  assert_ptr_not_equal(list, NULL);
296  amxc_llist_delete(&list, variant_list_it_free);
297  constlist = amxc_var_constcast(amxc_llist_t, &var);
298  assert_ptr_not_equal(constlist, NULL);
299 
300  free(string.data.s);
301  amxc_var_clean(&var);
302 }
303 
304 void test_variant_llist_compare(UNUSED void** state) {
305  amxc_var_t var1;
306  amxc_var_t var2;
307  amxc_var_t* list1;
308  amxc_var_t* list2;
309  int result = 0;
310 
311  assert_int_equal(amxc_var_init(&var1), 0);
312  assert_int_equal(amxc_var_init(&var2), 0);
313  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_LIST), 0);
314  assert_int_equal(var1.type_id, AMXC_VAR_ID_LIST);
315  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_LIST), 0);
316  assert_int_equal(var2.type_id, AMXC_VAR_ID_LIST);
317 
318  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
319  assert_true(result == 0);
320 
321  assert_non_null(amxc_var_add(cstring_t, &var1, "my_value"));
322  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
323  assert_true(result > 0);
324  assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);
325  assert_true(result < 0);
326 
327  assert_non_null(amxc_var_add(cstring_t, &var2, "my_value"));
328  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
329  assert_true(result == 0);
330 
331  assert_non_null(amxc_var_add(uint32_t, &var1, 1));
332  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
333  assert_true(result > 0);
334 
335  assert_non_null(amxc_var_add(uint32_t, &var2, 2));
336  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
337  assert_true(result < 0);
338 
339  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_LIST), 0);
340  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_LIST), 0);
341  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
342  assert_true(result == 0);
343 
344  assert_non_null(amxc_var_add(cstring_t, &var1, "my_value"));
345  assert_non_null(amxc_var_add(uint32_t, &var1, 1));
346  assert_non_null(amxc_var_add(uint32_t, &var2, 1));
347  assert_non_null(amxc_var_add(cstring_t, &var2, "my_value"));
348  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
349  assert_true(result != 0);
350 
351  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_LIST), 0);
352  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_LIST), 0);
353  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
354  assert_true(result == 0);
355 
356  list1 = amxc_var_add(amxc_llist_t, &var1, NULL);
357  assert_non_null(list1);
358  list2 = amxc_var_add(amxc_llist_t, &var2, NULL);
359  assert_non_null(list2);
360  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
361  assert_true(result == 0);
362 
363  assert_non_null(amxc_var_add(cstring_t, list1, "my_value"));
364  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
365  assert_true(result > 0);
366 
367  assert_non_null(amxc_var_add(cstring_t, list2, "my_value"));
368  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
369  assert_true(result == 0);
370 
371  amxc_var_clean(&var1);
372  amxc_var_clean(&var2);
373 }
374 
375 void test_variant_llist_add_new(UNUSED void** state) {
376  amxc_var_t var;
377  amxc_var_t* item = NULL;
378  const amxc_llist_t* constlist = NULL;
379  amxc_llist_t alist;
380 
381  assert_int_equal(amxc_llist_init(&alist), 0);
382 
383  assert_int_equal(amxc_var_init(&var), 0);
384  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_LIST), 0);
385 
386  item = amxc_var_add(amxc_llist_t, &var, NULL);
387  assert_ptr_not_equal(item, NULL);
388  assert_int_equal(amxc_var_type_of(item), AMXC_VAR_ID_LIST);
389  constlist = amxc_var_constcast(amxc_llist_t, item);
390  assert_int_equal(amxc_llist_size(constlist), 0);
391 
392  item = amxc_var_add(amxc_llist_t, &var, &alist);
393  assert_ptr_not_equal(item, NULL);
394  assert_int_equal(amxc_var_type_of(item), AMXC_VAR_ID_LIST);
395  constlist = amxc_var_constcast(amxc_llist_t, item);
396  assert_int_equal(amxc_llist_size(constlist), 0);
397 
398  item = amxc_var_add(amxc_llist_t, NULL, NULL);
399  assert_ptr_equal(item, NULL);
400 
401  constlist = amxc_var_constcast(amxc_llist_t, &var);
402  assert_ptr_not_equal(constlist, NULL);
403  assert_int_equal(amxc_llist_size(constlist), 2);
404 
405  amxc_llist_clean(&alist, NULL);
406  amxc_var_clean(&var);
407 }
408 
409 void test_variant_llist_add_new_key(UNUSED void** state) {
410  amxc_var_t var;
411  amxc_var_t* item = NULL;
412  const amxc_llist_t* constlist = NULL;
413  const amxc_htable_t* consttable = NULL;
414  amxc_llist_t alist;
415 
416  assert_int_equal(amxc_llist_init(&alist), 0);
417 
418  assert_int_equal(amxc_var_init(&var), 0);
419  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_LIST), 0);
420 
421  item = amxc_var_add_key(amxc_htable_t, &var, "1", NULL);
422  assert_ptr_not_equal(item, NULL);
423  assert_int_equal(amxc_var_type_of(item), AMXC_VAR_ID_HTABLE);
424  consttable = amxc_var_constcast(amxc_htable_t, item);
425  assert_int_equal(amxc_htable_size(consttable), 0);
426 
427  item = amxc_var_add_key(amxc_llist_t, &var, "2", &alist);
428  assert_ptr_not_equal(item, NULL);
429  assert_int_equal(amxc_var_type_of(item), AMXC_VAR_ID_LIST);
430  constlist = amxc_var_constcast(amxc_llist_t, item);
431  assert_int_equal(amxc_llist_size(constlist), 0);
432 
433  item = amxc_var_add_key(cstring_t, NULL, "3", NULL);
434  assert_ptr_equal(item, NULL);
435 
436  constlist = amxc_var_constcast(amxc_llist_t, &var);
437  assert_ptr_not_equal(constlist, NULL);
438  assert_int_equal(amxc_llist_size(constlist), 2);
439 
440  amxc_llist_clean(&alist, NULL);
441  amxc_var_clean(&var);
442 }
443 
444 void test_variant_llist_get_path(UNUSED void** state) {
445  amxc_var_t var;
446  amxc_var_t* item = NULL;
447 
448  assert_int_equal(amxc_var_init(&var), 0);
449  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_LIST), 0);
450 
451  assert_ptr_not_equal(amxc_var_add(uint32_t, &var, 123), NULL);
452  assert_ptr_not_equal(amxc_var_add(cstring_t, &var, "acracadabra"), NULL);
453  assert_ptr_not_equal(amxc_var_add(bool, &var, "true"), NULL);
454 
455  item = amxc_var_get_path(&var, "0", AMXC_VAR_FLAG_DEFAULT);
456  assert_ptr_not_equal(item, NULL);
457  assert_int_equal(amxc_var_type_of(item), AMXC_VAR_ID_UINT32);
458 
459  item = amxc_var_get_path(&var, "Test", AMXC_VAR_FLAG_DEFAULT);
460  assert_true(amxc_var_is_null(item));
461 
462  amxc_var_clean(&var);
463 }
amxc_macros.h
UNUSED
#define UNUSED
Definition: amxc_macros.h:70
amxc_variant.h
Ambiorix variant API header file.
cstring_t
#define cstring_t
Convenience macro.
Definition: amxc_variant.h:584
amxc_var_from_llist_it
#define amxc_var_from_llist_it(ll_it)
Get the variant pointer from an amxc linked list iterator.
Definition: amxc_variant.h:799
amxc_variant_priv.h
amxc_htable_size
AMXC_INLINE size_t amxc_htable_size(const amxc_htable_t *const htable)
Calculates the size of the hash table.
Definition: amxc_htable.h:334
amxc_htable_is_empty
AMXC_INLINE bool amxc_htable_is_empty(const amxc_htable_t *const htable)
Checks that the hash table is empty.
Definition: amxc_htable.h:311
amxc_llist_delete
void amxc_llist_delete(amxc_llist_t **llist, amxc_llist_it_delete_t func)
Frees the previously allocated linked list.
Definition: amxc_llist.c:101
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_init
int amxc_llist_init(amxc_llist_t *const llist)
Initializes a linked list.
Definition: amxc_llist.c:111
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_llist_clean
void amxc_llist_clean(amxc_llist_t *const llist, amxc_llist_it_delete_t func)
Removes all items from the linked list.
Definition: amxc_llist.c:124
amxc_llist_for_each
#define amxc_llist_for_each(it, list)
Loops over the list from head to tail.
Definition: amxc_llist.h:253
AMXC_VAR_FLAG_DEFAULT
#define AMXC_VAR_FLAG_DEFAULT
The default flag, do not copy, use variant as is.
Definition: amxc_variant.h:392
variant_list_it_free
void variant_list_it_free(amxc_llist_it_t *it)
Helper functions, can be used as delete function for linked lists.
Definition: variant_list.c:66
AMXC_VAR_ID_UINT32
#define AMXC_VAR_ID_UINT32
Unsigned 32 bit integer variant id.
Definition: amxc_variant.h:176
AMXC_VAR_ID_CUSTOM_BASE
#define AMXC_VAR_ID_CUSTOM_BASE
Base variant id for custom variants.
Definition: amxc_variant.h:257
AMXC_VAR_ID_NULL
#define AMXC_VAR_ID_NULL
Null variant type id (aka void)
Definition: amxc_variant.h:128
AMXC_VAR_ID_CSTRING
#define AMXC_VAR_ID_CSTRING
C-string variant id (aka char *), null terminated string.
Definition: amxc_variant.h:134
AMXC_VAR_ID_UINT64
#define AMXC_VAR_ID_UINT64
Unsigned 64 bit integer variant id.
Definition: amxc_variant.h:182
AMXC_VAR_ID_SSV_STRING
#define AMXC_VAR_ID_SSV_STRING
Space Separated Values string variant id.
Definition: amxc_variant.h:236
AMXC_VAR_ID_BOOL
#define AMXC_VAR_ID_BOOL
Boolean variant id.
Definition: amxc_variant.h:200
AMXC_VAR_ID_CSV_STRING
#define AMXC_VAR_ID_CSV_STRING
Comma Separated Values string variant id.
Definition: amxc_variant.h:230
AMXC_VAR_ID_LIST
#define AMXC_VAR_ID_LIST
Ambiorix Linked List variant id.
Definition: amxc_variant.h:206
AMXC_VAR_ID_HTABLE
#define AMXC_VAR_ID_HTABLE
Ambiorix Hash Table variant id.
Definition: amxc_variant.h:212
amxc_var_move
int amxc_var_move(amxc_var_t *const dest, amxc_var_t *const src)
Moves the type and data from one variant (source) in another variant (destination).
Definition: amxc_variant.c:308
amxc_var_type_of
uint32_t amxc_var_type_of(const amxc_var_t *const var)
Gets the variant type id of a variant.
Definition: amxc_variant.c:668
amxc_var_add_key
#define amxc_var_add_key(type, var, key, data)
Convenience macro for adding a variant to composite variant type.
Definition: amxc_variant.h:627
amxc_var_add
#define amxc_var_add(type, var, data)
Convenience macro for adding a variant to composite variant type.
Definition: amxc_variant.h:618
amxc_var_is_null
AMXC_INLINE bool amxc_var_is_null(const amxc_var_t *const var)
Checks if the given variant is of the "null" type.
Definition: amxc_variant.h:1594
amxc_var_set_type
int amxc_var_set_type(amxc_var_t *const var, const uint32_t type)
Change the variant data type.
Definition: amxc_variant.c:261
amxc_var_get_path
amxc_var_t * amxc_var_get_path(const amxc_var_t *const var, const char *const path, const int flags)
Retrieves the variant at the given path of a composite variant.
Definition: amxc_variant.c:573
amxc_var_dyncast
#define amxc_var_dyncast(type, var)
Dynamic cast a variant to a certain type.
Definition: amxc_variant.h:678
amxc_var_init
int amxc_var_init(amxc_var_t *const var)
Initializes a variant.
Definition: amxc_variant.c:223
amxc_var_copy
int amxc_var_copy(amxc_var_t *const dest, const amxc_var_t *const src)
Copy the type and data from one variant (source) in another variant (destination).
Definition: amxc_variant.c:285
amxc_var_clean
void amxc_var_clean(amxc_var_t *const var)
Clean-up and reset variant.
Definition: amxc_variant.c:237
amxc_var_convert
int amxc_var_convert(amxc_var_t *const dest, const amxc_var_t *src, const uint32_t type_id)
Converts one variant (source) to another variant(destination) using the specified variant type id.
Definition: amxc_variant.c:333
amxc_var_compare
int amxc_var_compare(const amxc_var_t *const var1, const amxc_var_t *const var2, int *const result)
Compares two variants.
Definition: amxc_variant.c:397
amxc_var_constcast
#define amxc_var_constcast(type, var)
Takes the content from a variant.
Definition: amxc_variant.h:722
_amxc_htable
The hash table structure.
Definition: amxc_htable.h:175
_amxc_llist
The linked list structure.
Definition: amxc_llist.h:228
_amxc_var
The variant struct definition.
Definition: amxc_variant.h:861
_amxc_var::data
void * data
Definition: amxc_variant.h:883
_amxc_var::type_id
uint32_t type_id
Definition: amxc_variant.h:864
data
char data[]
Definition: test_amxc_array.c:69
it
static amxc_htable_it_t it[2000]
Definition: test_amxc_htable.c:69
var
static amxc_var_t * var
Definition: test_issue_58.c:77
test_variant_list_convert_to_htable
void test_variant_list_convert_to_htable(UNUSED void **state)
Definition: test_variant_list.c:196
test_variant_llist_get_path
void test_variant_llist_get_path(UNUSED void **state)
Definition: test_variant_list.c:444
test_variant_list_copy
void test_variant_list_copy(UNUSED void **state)
Definition: test_variant_list.c:76
test_variant_list_convert_to_integer
void test_variant_list_convert_to_integer(UNUSED void **state)
Definition: test_variant_list.c:166
test_variant_llist_add_new
void test_variant_llist_add_new(UNUSED void **state)
Definition: test_variant_list.c:375
test_variant_llist_set_get
void test_variant_llist_set_get(UNUSED void **state)
Definition: test_variant_list.c:272
test_variant_list_convert_to_string
void test_variant_list_convert_to_string(UNUSED void **state)
Definition: test_variant_list.c:229
test_variant_llist_add_new_key
void test_variant_llist_add_new_key(UNUSED void **state)
Definition: test_variant_list.c:409
test_variant_list_convert_to_bool
void test_variant_list_convert_to_bool(UNUSED void **state)
Definition: test_variant_list.c:135
test_variant_llist_compare
void test_variant_llist_compare(UNUSED void **state)
Definition: test_variant_list.c:304
test_variant_list_move
void test_variant_list_move(UNUSED void **state)
Definition: test_variant_list.c:112
test_variant_list.h