libamxc  1.10.3
C Generic Data Containers
test_variant_htable.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_htable.h"
74 
75 #include <amxc/amxc_macros.h>
76 void test_variant_htable_init(UNUSED void** state) {
77  amxc_var_t var;
78  amxc_var_t string;
79 
80  amxc_var_init(&var);
81  amxc_var_init(&string);
82 
83  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_HTABLE), 0);
84  amxc_var_clean(&var);
85 
86  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
87  assert_int_equal(amxc_var_set_cstring_t(&string, "key:value"), 0);
88  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_HTABLE), 0);
89 
90  amxc_var_clean(&string);
91  amxc_var_clean(&var);
92 }
93 
94 void test_variant_htable_copy(UNUSED void** state) {
95  amxc_var_t string;
96  amxc_var_t var;
97  amxc_var_t copy_var;
98  amxc_htable_t* htable = NULL;
99 
100  assert_int_equal(amxc_var_init(&string), 0);
101  assert_int_equal(amxc_var_init(&var), 0);
102  assert_int_equal(amxc_var_init(&copy_var), 0);
103  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
104  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
105  string.data.s = "";
106 
107  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_HTABLE), 0);
108  assert_int_equal(string.type_id, AMXC_VAR_ID_CSTRING);
109  string.data.s = "Key1:Hello,Key2:world,Key3:and,Key4:anyone,Key5:else,Key6:in,Key7:the,Key8:universe";
110  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_HTABLE), 0);
111  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
112  assert_int_equal(amxc_var_copy(&copy_var, &var), 0);
113  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
114 
115  htable = &copy_var.data.vm;
116  amxc_htable_for_each(it, htable) {
117  amxc_var_t* item = amxc_var_from_htable_it(it);
118  assert_int_equal(item->type_id, AMXC_VAR_ID_CSTRING);
119  }
120 
121  amxc_var_clean(&var);
122  amxc_var_clean(&copy_var);
123 }
124 
125 void test_variant_htable_move(UNUSED void** state) {
126  amxc_var_t src;
127  amxc_var_t dst;
128 
129  assert_int_equal(amxc_var_init(&src), 0);
130  assert_int_equal(amxc_var_init(&dst), 0);
131  amxc_var_set_type(&src, AMXC_VAR_ID_HTABLE);
132 
133  amxc_var_add_key(cstring_t, &src, "key1", "item1");
134  amxc_var_add_key(cstring_t, &src, "key2", "item2");
135  amxc_var_add_key(cstring_t, &src, "key3", "item3");
136  amxc_var_add_key(cstring_t, &src, "key4", "item4");
137  amxc_var_add_key(cstring_t, &src, "key5", "item5");
138  amxc_var_add_key(cstring_t, &src, "key6", "item6");
139  amxc_var_add_key(cstring_t, &src, "key7", "item7");
140  amxc_var_add_key(cstring_t, &src, "key8", "item8");
141  amxc_var_add_key(cstring_t, &src, "key9", "item9");
142  amxc_var_add_key(cstring_t, &src, "key10", "item10");
143 
144  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &src)), 10);
145  assert_int_equal(amxc_var_move(&dst, &src), 0);
146  assert_true(amxc_var_is_null(&src));
147  assert_int_equal(amxc_var_type_of(&dst), AMXC_VAR_ID_HTABLE);
148  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &dst)), 10);
149 
150  assert_non_null(GET_ARG(&dst, "key5"));
151  assert_non_null(GET_ARG(&dst, "key1"));
152  assert_non_null(GET_ARG(&dst, "key3"));
153  assert_non_null(GET_ARG(&dst, "key7"));
154  assert_non_null(GET_ARG(&dst, "key9"));
155 
156  amxc_var_clean(&dst);
157  amxc_var_clean(&src);
158 }
159 
160 void test_variant_htable_convert_to_bool(UNUSED void** state) {
161  amxc_var_t string;
162  amxc_var_t var;
163  amxc_var_t copy_var;
164 
165  assert_int_equal(amxc_var_init(&string), 0);
166  assert_int_equal(amxc_var_init(&var), 0);
167  assert_int_equal(amxc_var_init(&copy_var), 0);
168  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
169  assert_int_equal(amxc_var_set_type(&copy_var, AMXC_VAR_ID_HTABLE), 0);
170  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_HTABLE);
171 
172  assert_true(amxc_htable_is_empty(&copy_var.data.vm));
173  assert_int_equal(amxc_var_convert(&var, &copy_var, AMXC_VAR_ID_BOOL), 0);
174  assert_false(var.data.b);
175 
176  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
177  assert_int_equal(string.type_id, AMXC_VAR_ID_CSTRING);
178  string.data.s = "Key1:Hello,Key2:world,Key3:and,Key4:anyone,Key5:else,Key6:in,Key7:the,Key8:universe";
179 
180  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_HTABLE), 0);
181  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
182  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
183  assert_true(copy_var.data.b);
184 
185  amxc_var_clean(&var);
186  amxc_var_clean(&copy_var);
187 }
188 
189 void test_variant_htable_convert_to_integer(UNUSED void** state) {
190  amxc_var_t string;
191  amxc_var_t var;
192  amxc_var_t copy_var;
193 
194  assert_int_equal(amxc_var_init(&string), 0);
195  assert_int_equal(amxc_var_init(&var), 0);
196  assert_int_equal(amxc_var_init(&copy_var), 0);
197  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
198  assert_int_equal(amxc_var_set_type(&copy_var, AMXC_VAR_ID_HTABLE), 0);
199  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_HTABLE);
200 
201  assert_true(amxc_htable_is_empty(&copy_var.data.vm));
202  assert_int_equal(amxc_var_convert(&var, &copy_var, AMXC_VAR_ID_UINT64), 0);
203  assert_int_equal(var.data.ui64, 0);
204 
205  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
206  assert_int_equal(string.type_id, AMXC_VAR_ID_CSTRING);
207  string.data.s = "Key1:Hello,Key2:world,Key3:and,Key4:anyone,Key5:else,Key6:in,Key7:the,Key8:universe";
208 
209  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_HTABLE), 0);
210  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
211  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
212  assert_int_equal(copy_var.data.ui64, 8);
213 
214  amxc_var_clean(&var);
215  amxc_var_clean(&copy_var);
216 }
217 
218 void test_variant_htable_convert_to_list(UNUSED void** state) {
219  amxc_var_t string;
220  amxc_var_t var;
221  amxc_var_t copy_var;
222 
223  assert_int_equal(amxc_var_init(&string), 0);
224  assert_int_equal(amxc_var_init(&var), 0);
225  assert_int_equal(amxc_var_init(&copy_var), 0);
226  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
227  assert_int_equal(amxc_var_set_type(&copy_var, AMXC_VAR_ID_HTABLE), 0);
228  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_HTABLE);
229 
230  assert_true(amxc_htable_is_empty(&copy_var.data.vm));
231  assert_int_equal(amxc_var_convert(&var, &copy_var, AMXC_VAR_ID_LIST), 0);
232  assert_int_equal(amxc_llist_size(&var.data.vl), 0);
233  assert_true(amxc_llist_is_empty(&var.data.vl));
234 
235  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
236  assert_int_equal(string.type_id, AMXC_VAR_ID_CSTRING);
237  string.data.s = "Key1:Hello,Key2:world,Key3:and,Key4:anyone,Key5:else,Key6:in,Key7:the,Key8:universe";
238 
239  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_HTABLE), 0);
240  assert_int_equal(var.type_id, AMXC_VAR_ID_HTABLE);
241  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
242  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
243  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_LIST);
244  assert_false(amxc_llist_is_empty(&copy_var.data.vl));
245 
246  amxc_var_clean(&var);
247  amxc_var_clean(&copy_var);
248 }
249 
250 void test_variant_htable_convert_to_string(UNUSED void** state) {
251  amxc_var_t string;
252  amxc_var_t var;
253  amxc_var_t copy_var;
254 
255  assert_int_equal(amxc_var_init(&string), 0);
256  assert_int_equal(amxc_var_init(&var), 0);
257  assert_int_equal(amxc_var_init(&copy_var), 0);
258  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
259  assert_int_equal(amxc_var_set_type(&copy_var, AMXC_VAR_ID_HTABLE), 0);
260  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_HTABLE);
261 
262  assert_true(amxc_htable_is_empty(&copy_var.data.vm));
263  assert_int_equal(amxc_var_convert(&var, &copy_var, AMXC_VAR_ID_CSTRING), 0);
264  assert_ptr_not_equal(var.data.s, NULL);
265  assert_int_equal(strlen(var.data.s), 0);
266  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
267  assert_int_equal(string.type_id, AMXC_VAR_ID_CSTRING);
268  string.data.s = "Key1:Hello,Key2:world,Key3:and,Key4:anyone,Key5:else,Key6:in,Key7:the,Key8:universe";
269 
270  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_HTABLE), 0);
271  assert_int_equal(var.type_id, AMXC_VAR_ID_HTABLE);
272  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
273  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CSTRING), 0);
274  assert_string_equal(copy_var.data.s, string.data.s);
275 
276  amxc_var_clean(&var);
277  amxc_var_clean(&copy_var);
278 }
279 
280 void test_variant_htable_convert_to_string_should_not_segfault(UNUSED void** state) {
281  amxc_var_t htable_var;
282  amxc_var_t* str_var = NULL;
283  amxc_var_t copy_var;
284 
285  assert_int_equal(amxc_var_init(&htable_var), 0);
286  assert_int_equal(amxc_var_new(&str_var), 0);
287  assert_int_equal(amxc_var_init(&copy_var), 0);
288 
289  assert_int_equal(amxc_var_set_type(str_var, AMXC_VAR_ID_CSTRING), 0);
290  assert_int_equal(str_var->type_id, AMXC_VAR_ID_CSTRING);
291  assert_int_equal(amxc_var_set_type(&htable_var, AMXC_VAR_ID_HTABLE), 0);
292  assert_int_equal(htable_var.type_id, AMXC_VAR_ID_HTABLE);
293 
294  assert_true(amxc_htable_is_empty(&htable_var.data.vm));
295  amxc_htable_insert(&htable_var.data.vm, "test", &str_var->hit);
296 
297  assert_int_equal(amxc_var_convert(&copy_var, &htable_var, AMXC_VAR_ID_CSTRING), 0);
298 
299  amxc_var_clean(&htable_var);
300  amxc_var_clean(&copy_var);
301 }
302 
303 void test_variant_htable_set_get(UNUSED void** state) {
304  amxc_var_t var;
305  amxc_var_t* item = NULL;
306  amxc_var_t string;
307  amxc_htable_t* htable = NULL;
308  const amxc_htable_t* consthtable = NULL;
309 
310  assert_int_equal(amxc_var_init(&string), 0);
311  assert_int_equal(amxc_var_init(&var), 0);
312 
313  htable = amxc_var_dyncast(amxc_htable_t, NULL);
314  assert_ptr_equal(htable, NULL);
315 
316  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE), 0);
317  htable = amxc_var_dyncast(amxc_htable_t, &var);
318  assert_ptr_equal(htable, NULL);
319  consthtable = amxc_var_constcast(amxc_htable_t, &var);
320  assert_ptr_equal(consthtable, NULL);
321 
322  assert_int_equal(amxc_var_set_type(&string, AMXC_VAR_ID_CSTRING), 0);
323  string.data.s = "Key1:Hello,Key2:world,Key3:and,Key4:anyone,Key5:else,Key6:in,Key7:the,Key8:universe";
324  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_HTABLE), 0);
325 
326  htable = amxc_var_dyncast(amxc_htable_t, &var);
327  assert_ptr_not_equal(htable, NULL);
328  amxc_htable_delete(&htable, variant_htable_it_free);
329  consthtable = amxc_var_constcast(amxc_htable_t, &var);
330  assert_ptr_not_equal(consthtable, NULL);
331 
332  item = amxc_var_get_index(&var, 0, AMXC_VAR_FLAG_DEFAULT);
333  assert_non_null(item);
334  item = amxc_var_get_index(&var, 7, AMXC_VAR_FLAG_DEFAULT);
335  assert_non_null(item);
336  item = amxc_var_get_index(&var, 8, AMXC_VAR_FLAG_DEFAULT);
337  assert_null(item);
338  assert_ptr_not_equal(amxc_var_get_index(&var, 0, AMXC_VAR_FLAG_DEFAULT), amxc_var_get_index(&var, 7, AMXC_VAR_FLAG_DEFAULT));
339 
340  amxc_var_clean(&var);
341 }
342 
343 void test_variant_htable_compare(UNUSED void** state) {
344  amxc_var_t var1;
345  amxc_var_t var2;
346  amxc_var_t data;
347  int result = 0;
348 
349  assert_int_equal(amxc_var_init(&var1), 0);
350  assert_int_equal(amxc_var_init(&var2), 0);
351  assert_int_equal(amxc_var_init(&data), 0);
352  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_HTABLE), 0);
353  assert_int_equal(var1.type_id, AMXC_VAR_ID_HTABLE);
354  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_HTABLE), 0);
355  assert_int_equal(var2.type_id, AMXC_VAR_ID_HTABLE);
356 
357  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
358  assert_true(result == 0);
359 
360  assert_non_null(amxc_var_add_key(cstring_t, &var1, "cstring_key", "my_value"));
361  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
362  assert_true(result > 0);
363  assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);
364  assert_true(result < 0);
365 
366  assert_non_null(amxc_var_add_key(cstring_t, &var2, "cstring_key", "my_value"));
367  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
368  assert_true(result == 0);
369 
370  assert_non_null(amxc_var_add_key(uint32_t, &var1, "uint32_key", 1));
371  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
372  assert_true(result > 0);
373 
374  assert_non_null(amxc_var_add_key(uint32_t, &var2, "uint32_key", 2));
375  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
376  assert_true(result < 0);
377 
378  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_HTABLE), 0);
379  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_HTABLE), 0);
380  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
381  assert_true(result == 0);
382 
383  assert_int_equal(amxc_var_set(cstring_t, &data, "value"), 0);
384  assert_int_equal(amxc_var_set_path(&var1, "table_1.2.table_2.my_string", &data,
385  AMXC_VAR_FLAG_AUTO_ADD | AMXC_VAR_FLAG_COPY), 0);
386  assert_int_equal(amxc_var_set_path(&var2, "table_1.2.table_2.my_string", &data,
387  AMXC_VAR_FLAG_AUTO_ADD | AMXC_VAR_FLAG_COPY), 0);
388  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
389  assert_true(result == 0);
390 
391  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_HTABLE), 0);
392  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_HTABLE), 0);
393  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
394  assert_true(result == 0);
395 
396  assert_non_null(amxc_var_add_key(cstring_t, &var1, "key", "my_value"));
397  assert_non_null(amxc_var_add_key(uint32_t, &var2, "key", 2));
398  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
399  assert_true(result != 0);
400 
401  assert_int_equal(amxc_var_compare(&var1, &data, &result), 0);
402  assert_true(result != 0);
403 
404  amxc_var_clean(&var1);
405  amxc_var_clean(&var2);
406  amxc_var_clean(&data);
407 }
408 
409 void test_variant_htable_add_new(UNUSED void** state) {
410  amxc_var_t var;
411  amxc_var_t* item = NULL;
412  const amxc_htable_t* consttable = NULL;
413  const amxc_llist_t* constlist = NULL;
414  amxc_htable_t atable;
415 
416  assert_int_equal(amxc_htable_init(&atable, 0), 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(amxc_htable_t, &var, 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(amxc_htable_t, &var, &atable);
428  assert_ptr_not_equal(item, NULL);
429  assert_int_equal(amxc_var_type_of(item), AMXC_VAR_ID_HTABLE);
430  consttable = amxc_var_constcast(amxc_htable_t, item);
431  assert_int_equal(amxc_htable_size(consttable), 0);
432 
433  item = amxc_var_add(amxc_htable_t, NULL, NULL);
434  assert_ptr_equal(item, NULL);
435 
436  constlist = amxc_var_constcast(amxc_llist_t, &var);
437  assert_ptr_not_equal(consttable, NULL);
438  assert_int_equal(amxc_llist_size(constlist), 2);
439 
440  amxc_htable_clean(&atable, NULL);
441  amxc_var_clean(&var);
442 }
443 
444 void test_variant_htable_add_new_key(UNUSED void** state) {
445  amxc_var_t var;
446  amxc_var_t* item = NULL;
447  const amxc_htable_t* consttable = NULL;
448  amxc_htable_t atable;
449 
450  assert_int_equal(amxc_htable_init(&atable, 0), 0);
451 
452  assert_int_equal(amxc_var_init(&var), 0);
453  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_HTABLE), 0);
454 
455  item = amxc_var_add_key(amxc_htable_t, &var, "key1", NULL);
456  assert_ptr_not_equal(item, NULL);
457  assert_int_equal(amxc_var_type_of(item), AMXC_VAR_ID_HTABLE);
458  consttable = amxc_var_constcast(amxc_htable_t, item);
459  assert_int_equal(amxc_htable_size(consttable), 0);
460 
461  item = amxc_var_add_key(amxc_htable_t, &var, "key2", &atable);
462  assert_ptr_not_equal(item, NULL);
463  assert_int_equal(amxc_var_type_of(item), AMXC_VAR_ID_HTABLE);
464  consttable = amxc_var_constcast(amxc_htable_t, item);
465  assert_int_equal(amxc_htable_size(consttable), 0);
466 
467  item = amxc_var_add_key(amxc_htable_t, NULL, "Key3", NULL);
468  assert_ptr_equal(item, NULL);
469 
470  consttable = amxc_var_constcast(amxc_htable_t, &var);
471  assert_ptr_not_equal(consttable, NULL);
472  assert_int_equal(amxc_htable_size(consttable), 2);
473 
474  amxc_htable_clean(&atable, NULL);
475  amxc_var_clean(&var);
476 }
477 
478 void test_variant_htable_add_new_key_duplicate(UNUSED void** state) {
479  amxc_var_t var;
480  amxc_var_t* item = NULL;
481 
482  assert_int_equal(amxc_var_init(&var), 0);
483  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_HTABLE), 0);
484 
485  item = amxc_var_add_key(uint32_t, &var, "key1", 1);
486  assert_ptr_not_equal(item, NULL);
487  item = amxc_var_add_key(uint32_t, &var, "key1", 2);
488  assert_ptr_equal(item, NULL);
489 
490  amxc_var_clean(&var);
491 }
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_htable_it
#define amxc_var_from_htable_it(ht_it)
Get the variant pointer from an amxc htable iterator.
Definition: amxc_variant.h:790
amxc_variant_priv.h
amxc_htable_init
int amxc_htable_init(amxc_htable_t *const htable, const size_t reserve)
Initializes a hash table.
Definition: amxc_htable.c:185
amxc_htable_delete
void amxc_htable_delete(amxc_htable_t **htable, amxc_htable_it_delete_t func)
Frees the previously allocated hash table.
Definition: amxc_htable.c:172
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_htable_insert
int amxc_htable_insert(amxc_htable_t *const htable, const char *const key, amxc_htable_it_t *const it)
Inserts an item in the hash table.
Definition: amxc_htable.c:237
amxc_htable_for_each
#define amxc_htable_for_each(it, htable)
Loops over items in the hash table.
Definition: amxc_htable.h:102
amxc_htable_clean
void amxc_htable_clean(amxc_htable_t *const htable, amxc_htable_it_delete_t func)
Removes all items from the hash table.
Definition: amxc_htable.c:200
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_VAR_FLAG_DEFAULT
#define AMXC_VAR_FLAG_DEFAULT
The default flag, do not copy, use variant as is.
Definition: amxc_variant.h:392
AMXC_VAR_FLAG_COPY
#define AMXC_VAR_FLAG_COPY
Copy the variant, creates a new variant, leaves the source variant untouched.
Definition: amxc_variant.h:398
AMXC_VAR_FLAG_AUTO_ADD
#define AMXC_VAR_FLAG_AUTO_ADD
Add none existing variants to composite variants. This flag can be used with amxc_var_set_path and am...
Definition: amxc_variant.h:418
amxc_var_set_cstring_t
int amxc_var_set_cstring_t(amxc_var_t *const var, const char *const val)
Setter helper function.
Definition: variant_char.c:549
variant_htable_it_free
void variant_htable_it_free(const char *key, amxc_htable_it_t *it)
Helper functions, can be used as delete function for htable.
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_BOOL
#define AMXC_VAR_ID_BOOL
Boolean variant id.
Definition: amxc_variant.h:200
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
GET_ARG
#define GET_ARG(a, n)
Convenience macro for getting variant out of a composite variant by key.
Definition: amxc_variant.h:436
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_set_path
amxc_var_t int amxc_var_set_path(amxc_var_t *const var, const char *const path, amxc_var_t *data, const int flags)
Sets the variant at the given path of a composite variant.
Definition: amxc_variant.c:623
amxc_var_dyncast
#define amxc_var_dyncast(type, var)
Dynamic cast a variant to a certain type.
Definition: amxc_variant.h:678
amxc_var_new
int amxc_var_new(amxc_var_t **var)
Allocates a variant and initializes it to the null variant type.
Definition: amxc_variant.c:194
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_get_index
amxc_var_t * amxc_var_get_index(const amxc_var_t *const var, const int64_t index, const int flags)
Get a reference to a part of composed variant using an index.
Definition: amxc_variant.c:489
amxc_var_set
#define amxc_var_set(type, var, data)
Convenience macro for setting a value in a variant.
Definition: amxc_variant.h:609
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::hit
amxc_htable_it_t hit
Definition: amxc_variant.h:863
_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
htable
static amxc_htable_t * htable
Definition: test_amxc_htable.c:68
var
static amxc_var_t * var
Definition: test_issue_58.c:77
test_variant_htable_add_new_key
void test_variant_htable_add_new_key(UNUSED void **state)
Definition: test_variant_htable.c:444
test_variant_htable_compare
void test_variant_htable_compare(UNUSED void **state)
Definition: test_variant_htable.c:343
test_variant_htable_init
void test_variant_htable_init(UNUSED void **state)
Definition: test_variant_htable.c:76
test_variant_htable_set_get
void test_variant_htable_set_get(UNUSED void **state)
Definition: test_variant_htable.c:303
test_variant_htable_move
void test_variant_htable_move(UNUSED void **state)
Definition: test_variant_htable.c:125
test_variant_htable_convert_to_integer
void test_variant_htable_convert_to_integer(UNUSED void **state)
Definition: test_variant_htable.c:189
test_variant_htable_convert_to_string_should_not_segfault
void test_variant_htable_convert_to_string_should_not_segfault(UNUSED void **state)
Definition: test_variant_htable.c:280
test_variant_htable_convert_to_list
void test_variant_htable_convert_to_list(UNUSED void **state)
Definition: test_variant_htable.c:218
test_variant_htable_copy
void test_variant_htable_copy(UNUSED void **state)
Definition: test_variant_htable.c:94
test_variant_htable_convert_to_string
void test_variant_htable_convert_to_string(UNUSED void **state)
Definition: test_variant_htable.c:250
test_variant_htable_add_new_key_duplicate
void test_variant_htable_add_new_key_duplicate(UNUSED void **state)
Definition: test_variant_htable.c:478
test_variant_htable_convert_to_bool
void test_variant_htable_convert_to_bool(UNUSED void **state)
Definition: test_variant_htable.c:160
test_variant_htable_add_new
void test_variant_htable_add_new(UNUSED void **state)
Definition: test_variant_htable.c:409
test_variant_htable.h