libamxc  1.10.3
C Generic Data Containers
test_amxc_variant.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 <string.h>
58 #include <stdarg.h>
59 #include <stddef.h>
60 #include <setjmp.h>
61 #include <cmocka.h>
62 
63 #include <amxc/amxc_variant.h>
64 #include <amxc_variant_priv.h>
65 
66 #include "test_amxc_variant.h"
67 
68 #include <amxc/amxc_macros.h>
69 int amxc_var_init_success(amxc_var_t* const var);
70 int amxc_var_init_fail(amxc_var_t* const var);
71 void amxc_var_del(amxc_var_t* const var);
72 int amxc_var_copy_success(amxc_var_t* const dst, const amxc_var_t* const src);
73 int amxc_var_copy_fail(amxc_var_t* const dest, const amxc_var_t* const src);
74 int amxc_var_move_fail(amxc_var_t* const dest, amxc_var_t* const src);
75 int amxc_var_convert_success(amxc_var_t* const dest, const amxc_var_t* const src);
76 int amxc_var_convert_fail(amxc_var_t* const dest, const amxc_var_t* const src);
77 int amxc_var_compare_success(const amxc_var_t* const var1,
78  const amxc_var_t* const var2,
79  int* const result);
80 int amxc_var_compare_fail(const amxc_var_t* const var1,
81  const amxc_var_t* const var2,
82  int* const result);
83 int dummy4_convert_to(amxc_var_t* const dest,
84  const amxc_var_t* const src);
85 
86 void free_variant_htable(const char* key, amxc_htable_it_t* it);
87 void free_variant_llist(amxc_llist_it_t* it);
88 
89 int amxc_var_init_success(UNUSED amxc_var_t* const var) {
90  return 0;
91 }
92 
93 int amxc_var_init_fail(UNUSED amxc_var_t* const var) {
94  return -1;
95 }
96 
97 void amxc_var_del(UNUSED amxc_var_t* const var) {
98  return;
99 }
100 
101 int amxc_var_copy_success(amxc_var_t* const dest, const amxc_var_t* const src) {
102  dest->type_id = src->type_id;
103  dest->data.ui32 = src->data.ui32;
104  return 0;
105 }
106 
107 int amxc_var_copy_fail(UNUSED amxc_var_t* const dest,
108  UNUSED const amxc_var_t* const src) {
109  return -1;
110 }
111 
112 int amxc_var_move_fail(UNUSED amxc_var_t* const dest,
113  UNUSED amxc_var_t* const src) {
114  return -1;
115 }
116 
117 int amxc_var_convert_success(amxc_var_t* const dest,
118  const amxc_var_t* const src) {
119 
120  if(dest->type_id != src->type_id) {
121  dest->data.ui32 = src->data.ui32 >> 1;
122  } else {
123  dest->data.ui32 = src->data.ui32;
124  }
125  return 0;
126 }
127 
128 int amxc_var_convert_fail(UNUSED amxc_var_t* const dest,
129  UNUSED const amxc_var_t* const src) {
130  return -1;
131 }
132 
133 int amxc_var_compare_success(const amxc_var_t* const var1,
134  const amxc_var_t* const var2,
135  int* const result) {
136  if(var1->data.ui32 < var2->data.ui32) {
137  *result = -1;
138  } else if(var1->data.ui32 > var2->data.ui32) {
139  *result = 1;
140  } else {
141  *result = 0;
142  }
143  return 0;
144 }
145 
146 int amxc_var_compare_fail(UNUSED const amxc_var_t* const var1,
147  UNUSED const amxc_var_t* const var2,
148  UNUSED int* const result) {
149  return -1;
150 }
151 
152 int dummy4_convert_to(amxc_var_t* const dest,
153  const amxc_var_t* const src) {
154  int retval = -1;
155  amxc_var_convert_fn_t convfn[AMXC_VAR_ID_CUSTOM_BASE] = {
156  amxc_var_default_convert_to_null,
157  NULL,
158  NULL,
159  NULL,
160  NULL,
161  NULL,
162  NULL,
163  NULL,
164  NULL,
165  NULL,
166  NULL,
167  NULL,
168  NULL,
169  amxc_var_default_convert_to_list,
170  amxc_var_default_convert_to_htable,
171  NULL,
172  };
173 
174  if(dest->type_id >= AMXC_VAR_ID_CUSTOM_BASE) {
175  goto exit;
176  }
177 
178  if(convfn[dest->type_id] != NULL) {
179  retval = convfn[dest->type_id](dest, src);
180  }
181 
182 exit:
183  return retval;
184 }
185 
186 static amxc_var_t test_var;
187 
188 static amxc_var_t* amxc_var_test_get_key(UNUSED const amxc_var_t* const src,
189  const char* const key,
190  int flags) {
191  if(strcmp(key, "valid") != 0) {
192  return NULL;
193  }
194 
195  if((flags & AMXC_VAR_FLAG_COPY) == AMXC_VAR_FLAG_COPY) {
196  amxc_var_t* copy_var = NULL;
197  amxc_var_new(&copy_var);
198  amxc_var_copy(copy_var, &test_var);
199  return copy_var;
200  }
201 
202  return &test_var;
203 }
204 
205 static int amxc_var_test_set_key(UNUSED amxc_var_t* const dest,
206  UNUSED amxc_var_t* const src,
207  UNUSED const char* const key,
208  UNUSED int flags) {
209  if(strcmp(key, "valid") != 0) {
210  return -1;
211  }
212 
213  return 0;
214 }
215 
216 static amxc_var_t* amxc_var_test_get_index(UNUSED const amxc_var_t* const src,
217  const int64_t index,
218  int flags) {
219 
220  if((index > 5) && (index != UINT32_MAX)) {
221  return NULL;
222  }
223 
224  if((flags & AMXC_VAR_FLAG_COPY) == AMXC_VAR_FLAG_COPY) {
225  amxc_var_t* copy_var = NULL;
226  amxc_var_new(&copy_var);
227  amxc_var_copy(copy_var, &test_var);
228  return copy_var;
229  }
230 
231  return &test_var;
232 }
233 
234 static int amxc_var_test_set_index(UNUSED amxc_var_t* const dest,
235  UNUSED amxc_var_t* const src,
236  UNUSED const int64_t index,
237  UNUSED int flags) {
238  if((index > 5) && (index != UINT32_MAX)) {
239  return -1;
240  }
241 
242  return 0;
243 }
244 
245 
246 static amxc_var_type_t dummy1 =
247 {
248  .init = amxc_var_init_success,
249  .del = amxc_var_del,
250  .copy = amxc_var_default_copy,
251  .move = amxc_var_default_move,
252  .convert_from = amxc_var_convert_success,
253  .convert_to = amxc_var_convert_success,
254  .compare = amxc_var_compare_success,
255  .get_key = amxc_var_test_get_key,
256  .set_key = amxc_var_test_set_key,
257  .get_index = amxc_var_test_get_index,
258  .set_index = amxc_var_test_set_index,
259  .name = "dummy1_t"
260 };
261 
262 static amxc_var_type_t dummy2 =
263 {
264  .init = NULL,
265  .del = NULL,
266  .copy = amxc_var_copy_fail,
267  .move = amxc_var_move_fail,
268  .convert_from = amxc_var_convert_fail,
269  .convert_to = amxc_var_convert_fail,
270  .compare = amxc_var_compare_fail,
271  .name = "dummy2_t"
272 };
273 
274 static amxc_var_type_t dummy3 =
275 {
276  .init = NULL,
277  .del = NULL,
278  .copy = NULL,
279  .move = NULL,
280  .convert_from = NULL,
281  .convert_to = NULL,
282  .compare = NULL,
283  .get_key = amxc_var_test_get_key,
284  .set_key = amxc_var_test_set_key,
285  .get_index = amxc_var_test_get_index,
286  .set_index = amxc_var_test_set_index,
287  .name = "dummy3_t"
288 };
289 
290 void test_amxc_var_new_delete(UNUSED void** state) {
291  amxc_var_t* var = NULL;
292  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
293  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
294 
295  assert_int_equal(amxc_var_new(NULL), -1);
296 
297  assert_int_equal(amxc_var_new(&var), 0);
298  assert_ptr_not_equal(var, NULL);
299  assert_int_equal(var->type_id, AMXC_VAR_ID_NULL);
300  assert_ptr_equal(var->data.data, NULL);
301  assert_ptr_equal(var->lit.llist, NULL);
302  assert_ptr_equal(var->hit.ait, NULL);
303 
304  amxc_var_delete(NULL);
305  amxc_var_delete(&var);
306 
307  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
308  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
309 }
310 
311 void test_amxc_var_init_clean(UNUSED void** state) {
312  amxc_var_t var;
313  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
314  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
315 
316  assert_int_equal(amxc_var_init(NULL), -1);
317 
318  assert_int_equal(amxc_var_init(&var), 0);
319  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
320  assert_ptr_equal(var.data.data, NULL);
321  assert_ptr_equal(var.lit.llist, NULL);
322  assert_ptr_equal(var.hit.ait, NULL);
323 
324  amxc_var_clean(NULL);
325  amxc_var_clean(&var);
326 
327  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
328  amxc_var_clean(&var);
329 
330  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
331 }
332 
333 void test_amxc_var_set_type(UNUSED void** state) {
334  amxc_var_t var;
335  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
336  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
337 
338  assert_int_equal(amxc_var_init(&var), 0);
339 
340  assert_int_equal(amxc_var_set_type(NULL, 0), -1);
341  assert_int_not_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
342  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE), 0);
343  assert_int_equal(var.type_id, AMXC_VAR_ID_CUSTOM_BASE);
344  assert_int_equal(var.data.data, NULL);
345 
346  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE), 0);
347  assert_int_equal(var.type_id, AMXC_VAR_ID_CUSTOM_BASE);
348  assert_int_equal(var.data.data, NULL);
349 
350  assert_int_not_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
351  assert_int_equal(var.type_id, AMXC_VAR_ID_CUSTOM_BASE);
352  assert_int_equal(var.data.data, NULL);
353 
354  assert_int_equal(amxc_var_set_type(&var, 0), 0);
355  assert_int_equal(var.type_id, 0);
356  assert_int_equal(var.data.data, NULL);
357 
358  dummy2.init = amxc_var_init_fail;
359  assert_int_not_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE), 0);
360  dummy2.init = NULL;
361 
362  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
363  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
364 }
365 
366 void test_amxc_var_copy(UNUSED void** state) {
367  amxc_var_t var1;
368  amxc_var_t var2;
369  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
370  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
371  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
372 
373  assert_int_equal(amxc_var_init(&var1), 0);
374  var1.data.ui32 = 100;
375  assert_int_equal(amxc_var_init(&var2), 0);
376  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE), 0);
377  assert_int_equal(var2.type_id, AMXC_VAR_ID_CUSTOM_BASE);
378  assert_int_equal(var2.data.ui32, 0);
379 
380  assert_int_not_equal(amxc_var_copy(NULL, NULL), 0);
381  assert_int_not_equal(amxc_var_copy(&var1, NULL), 0);
382  assert_true(amxc_var_is_null(&var1));
383 
384  assert_int_equal(amxc_var_copy(&var2, &var1), 0);
385  assert_int_equal(var2.type_id, 0);
386  assert_int_equal(var2.data.ui32, 100);
387 
388  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
389  assert_int_not_equal(amxc_var_copy(&var2, &var1), 0);
390  assert_true(amxc_var_is_null(&var2));
391 
392  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
393  var1.data.ui32 = 100;
394  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
395  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE), 0);
396  assert_int_equal(amxc_var_copy(&var2, &var1), -1);
397  assert_true(amxc_var_is_null(&var2));
398  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
399 
400  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
401  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
402  assert_int_equal(amxc_var_remove_type(&dummy3), 0);
403 }
404 
405 void test_amxc_var_convert(UNUSED void** state) {
406  amxc_var_t var1;
407  amxc_var_t var2;
408  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
409  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
410  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
411 
412  assert_int_equal(amxc_var_init(&var1), 0);
413  var1.data.ui32 = 100;
414  assert_int_equal(amxc_var_init(&var2), 0);
415  assert_int_not_equal(amxc_var_convert(NULL, NULL, 0), 0);
416  assert_int_not_equal(amxc_var_convert(&var1, NULL, 0), 0);
417  assert_int_not_equal(amxc_var_convert(&var1, &var2, AMXC_VAR_ID_CUSTOM_BASE + 2), 0);
418 
419  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
420  var1.data.ui32 = 100;
421  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE), 0);
422  var2.data.ui32 = 999;
423 
424  assert_int_equal(amxc_var_convert(&var2, &var1, 0), 0);
425  assert_int_equal(var2.type_id, 0);
426  assert_ptr_equal(var2.data.ui32, 50);
427  var2.data.ui32 = 999;
428 
429  assert_int_not_equal(amxc_var_convert(&var2, &var1, AMXC_VAR_ID_CUSTOM_BASE), 0);
430  assert_int_equal(var2.type_id, 0);
431  assert_ptr_equal(var2.data.data, NULL);
432 
433  assert_int_not_equal(amxc_var_convert(&var2, &var1, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
434  assert_int_equal(var2.type_id, 0);
435  assert_ptr_equal(var2.data.data, NULL);
436 
437  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
438  var1.data.ui32 = 100;
439  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
440  assert_int_not_equal(amxc_var_convert(&var2, &var1, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
441  assert_int_equal(var2.type_id, 0);
442  assert_ptr_equal(var2.data.data, NULL);
443  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
444 
445  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
446  var1.data.ui32 = 100;
447  var2.data.ui32 = 500;
448  assert_int_equal(amxc_var_convert(&var1, &var2, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
449  assert_int_equal(var1.type_id, AMXC_VAR_ID_CUSTOM_BASE + 1);
450  assert_int_equal(var1.data.ui32, 250);
451 
452  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
453  assert_int_equal(amxc_var_set_type(&var2, 0), 0);
454  assert_int_equal(amxc_var_convert(&var1, &var2, 0), 0);
455 
456  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
457  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
458  assert_int_equal(amxc_var_remove_type(&dummy3), 0);
459 }
460 
461 void test_amxc_var_compare(UNUSED void** state) {
462  amxc_var_t var1;
463  amxc_var_t var2;
464  amxc_var_t var3;
465  int result = 0;
466  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
467  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
468  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
469 
470  assert_int_equal(amxc_var_init(&var1), 0);
471  assert_int_equal(amxc_var_init(&var2), 0);
472  assert_int_equal(amxc_var_init(&var3), 0);
473  assert_int_not_equal(amxc_var_compare(NULL, NULL, NULL), 0);
474  assert_int_equal(amxc_var_compare(NULL, NULL, &result), 0);
475  assert_int_equal(result, 0);
476  assert_int_equal(amxc_var_compare(&var1, NULL, &result), 0);
477  assert_int_equal(result, 1);
478  assert_int_equal(amxc_var_compare(NULL, &var1, &result), 0);
479  assert_int_equal(result, -1);
480  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
481  assert_int_equal(result, 0);
482 
483  var1.data.ui32 = 100;
484  var2.data.ui32 = 100;
485  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
486  assert_int_equal(result, 0);
487  var2.data.ui32 = 50;
488  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
489  assert_int_equal(result, 1);
490  var2.data.ui32 = 200;
491  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
492  assert_int_equal(result, -1);
493 
494  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
495  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE), 0);
496  assert_int_equal(amxc_var_set_type(&var3, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
497 
498  var1.data.ui32 = 100;
499  var2.data.ui32 = 100;
500  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
501  assert_int_equal(result, 1); // conversion var2 to var1
502  var1.data.ui32 = 100;
503  var2.data.ui32 = 100;
504  var3.data.ui32 = 100;
505  // should fail because compare of var2 always fails
506  assert_int_not_equal(amxc_var_compare(&var2, &var1, &result), 0);
507  assert_int_equal(amxc_var_compare(&var3, &var1, &result), 0);
508  assert_int_equal(result, -1); // conversion var3 to var1
509  assert_int_equal(amxc_var_compare(&var1, &var1, &result), 0);
510  assert_int_equal(result, 0);
511  assert_int_not_equal(amxc_var_compare(&var2, &var2, &result), 0);
512 
513  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
514  assert_int_not_equal(amxc_var_compare(&var1, &var2, &result), 0);
515  assert_int_not_equal(amxc_var_compare(&var2, &var1, &result), 0);
516 
517  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
518  assert_int_equal(amxc_var_remove_type(&dummy3), 0);
519 }
520 
521 void free_variant_htable(UNUSED const char* key, amxc_htable_it_t* it) {
522  amxc_var_t* var = amxc_htable_it_get_data(it, amxc_var_t, hit);
523  amxc_var_delete(&var);
524 }
525 
526 void free_variant_llist(amxc_llist_it_t* it) {
527  amxc_var_t* var = amxc_llist_it_get_data(it, amxc_var_t, lit);
528  amxc_var_delete(&var);
529 }
530 
531 void test_amxc_var_type_of(UNUSED void** state) {
532  amxc_var_t var1;
533 
534  assert_int_equal(amxc_var_add_type(&dummy1, AMXC_VAR_ID_NULL), AMXC_VAR_ID_NULL);
535  assert_int_equal(amxc_var_init(&var1), 0);
536  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
537  assert_int_equal(amxc_var_type_of(&var1), AMXC_VAR_ID_NULL);
538  assert_true(amxc_var_type_of(NULL) == AMXC_VAR_ID_INVALID);
539  assert_ptr_equal(amxc_var_type_name_of(NULL), NULL);
540  assert_string_equal(amxc_var_type_name_of(&var1), "dummy1_t");
541 
542  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
543 }
544 
545 void test_amxc_var_get_set_key(UNUSED void** state) {
546  amxc_var_t var1;
547  amxc_var_t* subvar = NULL;
548 
549  assert_int_equal(amxc_var_add_type(&dummy3, AMXC_VAR_ID_NULL), AMXC_VAR_ID_NULL);
550  assert_int_equal(amxc_var_init(&var1), 0);
551  assert_int_equal(amxc_var_init(&test_var), 0);
552  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
553 
554  subvar = amxc_var_get_key(&var1, "valid", AMXC_VAR_FLAG_DEFAULT);
555  assert_ptr_equal(subvar, &test_var);
556  subvar = amxc_var_get_key(&var1, "valid", AMXC_VAR_FLAG_COPY);
557  assert_ptr_not_equal(subvar, NULL);
558  assert_ptr_not_equal(subvar, &test_var);
559  amxc_var_delete(&subvar);
560 
561  subvar = amxc_var_get_key(&var1, "not_valid", AMXC_VAR_FLAG_DEFAULT);
562  assert_ptr_equal(subvar, NULL);
563 
564  amxc_var_remove_type(&dummy3);
565 }
566 
567 void test_amxc_var_add_new_key(UNUSED void** state) {
568  amxc_var_t var1;
569  amxc_var_t var2;
570  amxc_var_t* subvar = NULL;
571 
572  assert_int_equal(amxc_var_add_type(&dummy3, AMXC_VAR_ID_UINT16), AMXC_VAR_ID_UINT16);
573  assert_int_equal(amxc_var_add_type(&dummy2, AMXC_VAR_ID_UINT32), AMXC_VAR_ID_UINT32);
574  assert_int_equal(amxc_var_init(&var1), 0);
575  assert_int_equal(amxc_var_init(&test_var), 0);
576  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_UINT16), 0);
577 
578  subvar = amxc_var_add_new_key(&var1, "valid");
579  assert_ptr_not_equal(subvar, NULL);
580  assert_ptr_not_equal(subvar, &test_var);
581  amxc_var_delete(&subvar);
582 
583  assert_ptr_equal(amxc_var_add_new_key(NULL, "valid"), NULL);
584  assert_ptr_equal(amxc_var_add_new_key(&var1, NULL), NULL);
585  assert_ptr_equal(amxc_var_add_new_key(&var1, ""), NULL);
586 
587  assert_int_equal(amxc_var_init(&var2), 0);
588  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_UINT32), 0);
589  assert_ptr_equal(amxc_var_add_new_key(&var2, "valid"), NULL);
590 
591  amxc_var_remove_type(&dummy2);
592  amxc_var_remove_type(&dummy3);
593 }
594 
595 void test_amxc_var_add_new(UNUSED void** state) {
596  amxc_var_t var1;
597  amxc_var_t var2;
598  amxc_var_t* subvar = NULL;
599 
600  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE);
601  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
602  assert_int_equal(amxc_var_init(&var1), 0);
603  assert_int_equal(amxc_var_init(&test_var), 0);
604  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE), 0);
605 
606  subvar = amxc_var_add_new(&var1);
607  assert_ptr_not_equal(subvar, NULL);
608  assert_ptr_not_equal(subvar, &test_var);
609  amxc_var_delete(&subvar);
610 
611  assert_ptr_equal(amxc_var_add_new(NULL), NULL);
612 
613  assert_int_equal(amxc_var_init(&var2), 0);
614  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
615  assert_ptr_equal(amxc_var_add_new(&var2), NULL);
616 
617  amxc_var_remove_type(&dummy2);
618  amxc_var_remove_type(&dummy3);
619 }
620 
621 void test_amxc_var_get_path(UNUSED void** state) {
622  amxc_var_t var1;
623  amxc_var_t* subvar = NULL;
624 
625  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE);
626  assert_int_equal(amxc_var_add_type(&dummy1, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
627  assert_int_equal(amxc_var_init(&var1), 0);
628  assert_int_equal(amxc_var_init(&test_var), 0);
629  assert_int_equal(amxc_var_set_type(&test_var, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
630  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE), 0);
631 
632  subvar = amxc_var_get_path(&var1, "valid.1.valid.2.valid.3", AMXC_VAR_FLAG_DEFAULT);
633  assert_ptr_not_equal(subvar, NULL);
634  assert_ptr_equal(subvar, &test_var);
635 
636  subvar = amxc_var_get_pathf(&var1, AMXC_VAR_FLAG_DEFAULT, "valid.%d.valid.2.valid.3", 1);
637  assert_ptr_not_equal(subvar, NULL);
638  assert_ptr_equal(subvar, &test_var);
639 
640  subvar = amxc_var_get_pathf(&var1, AMXC_VAR_FLAG_DEFAULT, "%s.%d.valid.%d.valid.3", "valid", 1, 2);
641  assert_ptr_not_equal(subvar, NULL);
642  assert_ptr_equal(subvar, &test_var);
643 
644  subvar = amxc_var_get_path(&var1, "valid.1.valid.99.valid.3", AMXC_VAR_FLAG_DEFAULT);
645  assert_ptr_equal(subvar, NULL);
646  subvar = amxc_var_get_path(&var1, "valid.1.valid.99.valid.3", AMXC_VAR_FLAG_COPY);
647  assert_ptr_equal(subvar, NULL);
648 
649  subvar = amxc_var_get_path(&var1, "valid.1.valid.2.notexisting.3", AMXC_VAR_FLAG_DEFAULT);
650  assert_ptr_equal(subvar, NULL);
651  subvar = amxc_var_get_path(&var1, "valid.1.valid.2.notexisting.3", AMXC_VAR_FLAG_COPY);
652  assert_ptr_equal(subvar, NULL);
653 
654  subvar = amxc_var_get_path(&var1, "valid.1.valid.2.valid.3", AMXC_VAR_FLAG_COPY);
655  assert_ptr_not_equal(subvar, NULL);
656  assert_ptr_not_equal(subvar, &test_var);
657  amxc_var_delete(&subvar);
658 
659  subvar = amxc_var_get_path(NULL, "valid.1.valid.2.valid.3", AMXC_VAR_FLAG_COPY);
660  assert_ptr_equal(subvar, NULL);
661  subvar = amxc_var_get_path(&var1, NULL, AMXC_VAR_FLAG_COPY);
662  assert_ptr_equal(subvar, NULL);
663  subvar = amxc_var_get_path(&var1, "", AMXC_VAR_FLAG_COPY);
664  assert_ptr_equal(subvar, NULL);
665  subvar = amxc_var_get_path(&test_var, "", AMXC_VAR_FLAG_DEFAULT);
666  assert_ptr_not_equal(subvar, NULL);
667 
668  subvar = amxc_var_get_pathf(NULL, AMXC_VAR_FLAG_COPY, "valid.1.valid.2.valid.3");
669  assert_ptr_equal(subvar, NULL);
670  subvar = amxc_var_get_pathf(NULL, AMXC_VAR_FLAG_COPY, NULL);
671  assert_ptr_equal(subvar, NULL);
672 
673  amxc_var_remove_type(&dummy3);
674  amxc_var_remove_type(&dummy1);
675 }
676 
677 void test_amxc_var_set_path(UNUSED void** state) {
678  amxc_var_t var1;
679  amxc_var_t var2;
680 
681  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE);
682  assert_int_equal(amxc_var_add_type(&dummy1, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
683  assert_int_equal(amxc_var_init(&var1), 0);
684  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE), 0);
685  assert_int_equal(amxc_var_init(&var2), 0);
686  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
687 
688  assert_int_equal(amxc_var_set_path(&var1, "valid.1.valid.2.valid.3", &var2, AMXC_VAR_FLAG_DEFAULT | AMXC_VAR_FLAG_AUTO_ADD), 0);
689 
690  amxc_var_remove_type(&dummy3);
691  amxc_var_remove_type(&dummy1);
692 }
693 
694 void test_amxc_var_push_take_amxc_string(UNUSED void** state) {
695  amxc_var_t var1;
696  amxc_string_t source;
697  amxc_string_t* string = NULL;
698 
699  assert_int_equal(amxc_string_init(&source, 0), 0);
700  assert_int_equal(amxc_string_append(&source, "This is a test string", 21), 0);
701  assert_int_equal(amxc_var_init(&var1), 0);
702  assert_int_equal(amxc_var_push_amxc_string_t(&var1, &source), 0);
703  assert_int_equal(amxc_var_type_of(&var1), AMXC_VAR_ID_CSTRING);
704  assert_int_equal(source.length, 0);
705  assert_int_equal(source.last_used, 0);
706  assert_ptr_equal(source.buffer, NULL);
707 
708  string = amxc_var_take_amxc_string_t(&var1);
709  assert_int_equal(amxc_var_type_of(&var1), AMXC_VAR_ID_NULL);
710  assert_ptr_not_equal(string, NULL);
711  assert_int_not_equal(string->length, 0);
712  assert_int_not_equal(string->last_used, 0);
713  assert_ptr_not_equal(string->buffer, NULL);
714  amxc_string_delete(&string);
715 
716  amxc_var_clean(&var1);
717  assert_ptr_equal(var1.data.s, NULL);
718  string = amxc_var_take_amxc_string_t(&var1);
719  assert_ptr_equal(string, NULL);
720 
721  amxc_string_clean(&source);
722 }
723 
724 void test_amxc_var_move(UNUSED void** state) {
725  amxc_var_t src;
726  amxc_var_t dst;
727 
728  assert_int_equal(amxc_var_add_type(&dummy1, -1), AMXC_VAR_ID_CUSTOM_BASE);
729  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
730  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE + 2);
731  amxc_var_init(&src);
732  amxc_var_init(&dst);
733 
734  assert_int_equal(amxc_var_set_type(&src, AMXC_VAR_ID_CUSTOM_BASE), 0);
735  assert_int_equal(amxc_var_move(&dst, &src), 0);
736  assert_int_equal(amxc_var_type_of(&dst), AMXC_VAR_ID_CUSTOM_BASE);
737  assert_true(amxc_var_is_null(&src));
738 
739  assert_int_equal(amxc_var_set_type(&dst, AMXC_VAR_ID_CUSTOM_BASE), 0);
740  assert_int_equal(amxc_var_set_type(&src, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
741  assert_int_not_equal(amxc_var_move(&dst, &src), 0);
742  assert_int_equal(amxc_var_type_of(&src), AMXC_VAR_ID_CUSTOM_BASE + 1);
743  assert_true(amxc_var_is_null(&dst));
744 
745  assert_int_equal(amxc_var_set_type(&dst, AMXC_VAR_ID_CUSTOM_BASE), 0);
746  assert_int_equal(amxc_var_set_type(&src, AMXC_VAR_ID_CUSTOM_BASE + 2), 0);
747  assert_int_not_equal(amxc_var_move(&dst, &src), 0);
748  assert_int_equal(amxc_var_type_of(&src), AMXC_VAR_ID_CUSTOM_BASE + 2);
749  assert_true(amxc_var_is_null(&dst));
750 
751  amxc_var_clean(&src);
752  amxc_var_clean(&dst);
753 
754  assert_int_not_equal(amxc_var_move(&dst, NULL), 0);
755  assert_int_not_equal(amxc_var_move(NULL, &src), 0);
756 
757  amxc_var_remove_type(&dummy1);
758  amxc_var_remove_type(&dummy2);
759  amxc_var_remove_type(&dummy3);
760 }
761 
762 void test_amxc_var_take_it(UNUSED void** state) {
763  amxc_var_take_it(NULL);
764 }
amxc_macros.h
UNUSED
#define UNUSED
Definition: amxc_macros.h:70
amxc_variant.h
Ambiorix variant API header file.
amxc_variant_priv.h
amxc_var_default_convert_to_null
int PRIVATE amxc_var_default_convert_to_null(amxc_var_t *const dest, const amxc_var_t *const src)
amxc_var_default_move
int PRIVATE amxc_var_default_move(amxc_var_t *const dest, amxc_var_t *const src)
Definition: amxc_variant.c:142
amxc_var_add_type
uint32_t PRIVATE amxc_var_add_type(amxc_var_type_t *const type, const uint32_t index)
Definition: amxc_variant_type.c:119
amxc_var_default_convert_to_htable
int PRIVATE amxc_var_default_convert_to_htable(amxc_var_t *const dest, const amxc_var_t *const src)
Definition: amxc_variant.c:174
amxc_var_default_copy
int PRIVATE amxc_var_default_copy(amxc_var_t *const dest, const amxc_var_t *const src)
Definition: amxc_variant.c:136
amxc_var_remove_type
int PRIVATE amxc_var_remove_type(amxc_var_type_t *const type)
Definition: amxc_variant_type.c:157
amxc_var_default_convert_to_list
int PRIVATE amxc_var_default_convert_to_list(amxc_var_t *const dest, const amxc_var_t *const src)
Definition: amxc_variant.c:155
amxc_htable_it_get_data
#define amxc_htable_it_get_data(it, type, member)
Gets the data pointer from an hash table iterator.
Definition: amxc_htable.h:87
amxc_llist_it_get_data
#define amxc_llist_it_get_data(it, type, member)
Gets the data pointer from a linked list iterator.
Definition: amxc_llist.h:238
amxc_string_delete
void amxc_string_delete(amxc_string_t **string)
Frees the previously allocated string.
Definition: amxc_string.c:150
amxc_string_append
AMXC_INLINE int amxc_string_append(amxc_string_t *const string, const char *const text, const size_t length)
Appends text to the end of the current content of the string buffer.
Definition: amxc_string.h:920
amxc_string_init
int amxc_string_init(amxc_string_t *const string, const size_t length)
Initializes a string.
Definition: amxc_string.c:163
amxc_string_clean
void amxc_string_clean(amxc_string_t *const string)
Frees the string buffer and reset length attributes.
Definition: amxc_string.c:189
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_take_amxc_string_t
amxc_string_t * amxc_var_take_amxc_string_t(amxc_var_t *const var)
Takes a value from a variant.
Definition: amxc_variant.c:676
amxc_var_push_amxc_string_t
int amxc_var_push_amxc_string_t(amxc_var_t *const var, amxc_string_t *val)
Pushes a value in a variant.
Definition: amxc_variant.c:696
AMXC_VAR_ID_INVALID
#define AMXC_VAR_ID_INVALID
Invalid variant type id.
Definition: amxc_variant.h:122
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_UINT16
#define AMXC_VAR_ID_UINT16
Unsigned 16 bit integer variant id.
Definition: amxc_variant.h:170
amxc_var_convert_fn_t
int(* amxc_var_convert_fn_t)(amxc_var_t *const dest, const amxc_var_t *const src)
Variant type callback function prototype for dynamically converting one type to another.
Definition: amxc_variant_type.h:118
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_get_pathf
amxc_var_t * amxc_var_get_pathf(const amxc_var_t *const var, const int flags, const char *const fmt,...) __attribute__((format(printf
Retrieves the variant at the given path of a composite variant.
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_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_get_key
amxc_var_t * amxc_var_get_key(const amxc_var_t *const var, const char *const key, const int flags)
Get a reference to a part of composed variant using a key.
Definition: amxc_variant.c:449
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_add_new
amxc_var_t * amxc_var_add_new(amxc_var_t *const var)
Adds a new variant to a composite variant.
Definition: amxc_variant.c:551
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_delete
void amxc_var_delete(amxc_var_t **var)
Frees the previously allocated variant.
Definition: amxc_variant.c:207
amxc_var_add_new_key
amxc_var_t * amxc_var_add_new_key(amxc_var_t *const var, const char *key)
Adds a new variant with a key to a composite variant.
Definition: amxc_variant.c:526
amxc_var_take_it
AMXC_INLINE void amxc_var_take_it(amxc_var_t *const var)
Removes the variant for a llist and/or a htable.
Definition: amxc_variant.h:1107
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_type_name_of
const char * amxc_var_type_name_of(const amxc_var_t *const var)
Gets the variant type name of a variant.
Definition: amxc_variant.c:672
_amxc_htable_it
The hash table iterator structure.
Definition: amxc_htable.h:138
_amxc_htable_it::ait
amxc_array_it_t * ait
Definition: amxc_htable.h:139
_amxc_llist_it
The linked list iterator structure.
Definition: amxc_llist.h:215
_amxc_llist_it::llist
struct _amxc_llist * llist
Definition: amxc_llist.h:220
_amxc_string
The string structure.
Definition: amxc_string.h:103
_amxc_string::buffer
char * buffer
Definition: amxc_string.h:104
_amxc_string::last_used
size_t last_used
Definition: amxc_string.h:106
_amxc_string::length
size_t length
Definition: amxc_string.h:105
_amxc_var_type
A variant type structure.
Definition: amxc_variant_type.h:211
_amxc_var_type::init
amxc_var_new_fn_t init
Definition: amxc_variant_type.h:212
_amxc_var
The variant struct definition.
Definition: amxc_variant.h:861
_amxc_var::data
void * data
Definition: amxc_variant.h:883
_amxc_var::lit
amxc_llist_it_t lit
Definition: amxc_variant.h:862
_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
it
static amxc_htable_it_t it[2000]
Definition: test_amxc_htable.c:69
test_amxc_var_convert
void test_amxc_var_convert(UNUSED void **state)
Definition: test_amxc_variant.c:405
test_amxc_var_set_type
void test_amxc_var_set_type(UNUSED void **state)
Definition: test_amxc_variant.c:333
amxc_var_convert_success
int amxc_var_convert_success(amxc_var_t *const dest, const amxc_var_t *const src)
Definition: test_amxc_variant.c:117
amxc_var_compare_fail
int amxc_var_compare_fail(const amxc_var_t *const var1, const amxc_var_t *const var2, int *const result)
dummy1
static amxc_var_type_t dummy1
Definition: test_amxc_variant.c:246
free_variant_htable
void free_variant_htable(const char *key, amxc_htable_it_t *it)
amxc_var_test_set_index
static int amxc_var_test_set_index(UNUSED amxc_var_t *const dest, UNUSED amxc_var_t *const src, UNUSED const int64_t index, UNUSED int flags)
Definition: test_amxc_variant.c:234
test_var
static amxc_var_t test_var
Definition: test_amxc_variant.c:186
dummy4_convert_to
int dummy4_convert_to(amxc_var_t *const dest, const amxc_var_t *const src)
Definition: test_amxc_variant.c:152
test_amxc_var_push_take_amxc_string
void test_amxc_var_push_take_amxc_string(UNUSED void **state)
Definition: test_amxc_variant.c:694
amxc_var_init_fail
int amxc_var_init_fail(amxc_var_t *const var)
amxc_var_test_get_key
static amxc_var_t * amxc_var_test_get_key(UNUSED const amxc_var_t *const src, const char *const key, int flags)
Definition: test_amxc_variant.c:188
amxc_var_copy_fail
int amxc_var_copy_fail(amxc_var_t *const dest, const amxc_var_t *const src)
test_amxc_var_type_of
void test_amxc_var_type_of(UNUSED void **state)
Definition: test_amxc_variant.c:531
amxc_var_del
void amxc_var_del(amxc_var_t *const var)
amxc_var_move_fail
int amxc_var_move_fail(amxc_var_t *const dest, amxc_var_t *const src)
amxc_var_convert_fail
int amxc_var_convert_fail(amxc_var_t *const dest, const amxc_var_t *const src)
test_amxc_var_add_new_key
void test_amxc_var_add_new_key(UNUSED void **state)
Definition: test_amxc_variant.c:567
test_amxc_var_get_path
void test_amxc_var_get_path(UNUSED void **state)
Definition: test_amxc_variant.c:621
dummy3
static amxc_var_type_t dummy3
Definition: test_amxc_variant.c:274
test_amxc_var_copy
void test_amxc_var_copy(UNUSED void **state)
Definition: test_amxc_variant.c:366
amxc_var_compare_success
int amxc_var_compare_success(const amxc_var_t *const var1, const amxc_var_t *const var2, int *const result)
Definition: test_amxc_variant.c:133
amxc_var_test_set_key
static int amxc_var_test_set_key(UNUSED amxc_var_t *const dest, UNUSED amxc_var_t *const src, UNUSED const char *const key, UNUSED int flags)
Definition: test_amxc_variant.c:205
test_amxc_var_new_delete
void test_amxc_var_new_delete(UNUSED void **state)
Definition: test_amxc_variant.c:290
amxc_var_copy_success
int amxc_var_copy_success(amxc_var_t *const dst, const amxc_var_t *const src)
Definition: test_amxc_variant.c:101
test_amxc_var_move
void test_amxc_var_move(UNUSED void **state)
Definition: test_amxc_variant.c:724
test_amxc_var_add_new
void test_amxc_var_add_new(UNUSED void **state)
Definition: test_amxc_variant.c:595
test_amxc_var_get_set_key
void test_amxc_var_get_set_key(UNUSED void **state)
Definition: test_amxc_variant.c:545
amxc_var_test_get_index
static amxc_var_t * amxc_var_test_get_index(UNUSED const amxc_var_t *const src, const int64_t index, int flags)
Definition: test_amxc_variant.c:216
test_amxc_var_init_clean
void test_amxc_var_init_clean(UNUSED void **state)
Definition: test_amxc_variant.c:311
free_variant_llist
void free_variant_llist(amxc_llist_it_t *it)
Definition: test_amxc_variant.c:526
test_amxc_var_set_path
void test_amxc_var_set_path(UNUSED void **state)
Definition: test_amxc_variant.c:677
amxc_var_init_success
int amxc_var_init_success(amxc_var_t *const var)
test_amxc_var_take_it
void test_amxc_var_take_it(UNUSED void **state)
Definition: test_amxc_variant.c:762
dummy2
static amxc_var_type_t dummy2
Definition: test_amxc_variant.c:262
test_amxc_var_compare
void test_amxc_var_compare(UNUSED void **state)
Definition: test_amxc_variant.c:461
test_amxc_variant.h
var
static amxc_var_t * var
Definition: test_issue_58.c:77