libamxc  1.10.3
C Generic Data Containers
•All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
test_2_index_cb_func.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_llist_get_index(UNUSED void** state) {
77  amxc_var_t var;
78  amxc_var_t string;
79  amxc_var_t* key_part = NULL;
80  const amxc_var_t* key_part_const = NULL;
81 
82  amxc_var_init(&var);
83  amxc_var_init(&string);
84  amxc_var_set(cstring_t, &string, "Hello,world,and,anyone,else,in,the,universe");
85  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
86  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_LIST);
87  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
88 
89  key_part = amxc_var_get_index(&var, 6, AMXC_VAR_FLAG_COPY);
90  assert_ptr_not_equal(key_part, NULL);
91  assert_int_equal(amxc_var_type_of(key_part), AMXC_VAR_ID_CSTRING);
92  assert_ptr_equal(key_part->lit.llist, NULL);
93  assert_string_equal(key_part->data.s, "the");
94  amxc_var_delete(&key_part);
95  assert_ptr_equal(key_part, NULL);
96 
97  key_part_const = amxc_var_get_index(&var, 5, AMXC_VAR_FLAG_DEFAULT);
98  assert_ptr_not_equal(key_part_const, NULL);
99  assert_int_equal(amxc_var_type_of(key_part_const), AMXC_VAR_ID_CSTRING);
100  assert_ptr_not_equal(key_part_const->lit.llist, NULL);
101  assert_string_equal(key_part_const->data.s, "in");
102 
103  key_part = amxc_var_get_index(&var, 99, AMXC_VAR_FLAG_COPY);
104  assert_ptr_equal(key_part, NULL);
105 
106  amxc_var_set_type(&var, AMXC_VAR_ID_BOOL);
107  key_part = amxc_var_get_index(&var, 6, AMXC_VAR_FLAG_COPY);
108  assert_ptr_equal(key_part, NULL);
109 
110  amxc_var_clean(&string);
111  amxc_var_clean(&var);
112 }
113 
114 void test_variant_llist_set_index(UNUSED void** state) {
115  amxc_var_t var;
116  amxc_var_t string;
117  amxc_var_t* key_part = NULL;
118  amxc_var_t* key_part_copy = NULL;
119  const amxc_var_t* key_part_const = NULL;
120 
121  amxc_var_init(&var);
122  amxc_var_init(&string);
123  amxc_var_set(cstring_t, &string, "Hello,world,and,anyone,else,in,the,universe");
124  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
125  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_LIST);
126  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
127 
128  assert_int_equal(amxc_var_new(&key_part), 0);
129  amxc_var_set(cstring_t, key_part, "some text");
130  assert_int_equal(amxc_var_set_index(&var, 6, key_part, AMXC_VAR_FLAG_COPY | AMXC_VAR_FLAG_UPDATE), 0);
131  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
132  key_part_copy = amxc_var_get_index(&var, 6, AMXC_VAR_FLAG_COPY);
133  assert_ptr_not_equal(key_part_copy, NULL);
134  amxc_var_delete(&key_part_copy);
135 
136  assert_int_equal(amxc_var_set_index(&var, 6, key_part, AMXC_VAR_FLAG_COPY), 0);
137  assert_ptr_equal(key_part->lit.llist, NULL);
138  assert_int_equal(amxc_llist_size(&var.data.vl), 9);
139  key_part_copy = amxc_var_get_index(&var, 6, AMXC_VAR_FLAG_COPY);
140  assert_ptr_not_equal(key_part_copy, NULL);
141  assert_ptr_not_equal(key_part_copy, key_part);
142  amxc_var_delete(&key_part_copy);
143  assert_int_equal(amxc_llist_size(&var.data.vl), 9);
144  amxc_var_delete(&key_part);
145  assert_int_equal(amxc_llist_size(&var.data.vl), 9);
146 
147  assert_int_equal(amxc_var_new(&key_part), 0);
148  amxc_var_set(cstring_t, key_part, "some text");
149  assert_int_equal(amxc_var_set_index(&var, 5, key_part, AMXC_VAR_FLAG_UPDATE), 0);
150  assert_int_equal(amxc_llist_size(&var.data.vl), 9);
151 
152  key_part_const = amxc_var_get_index(&var, 5, AMXC_VAR_FLAG_DEFAULT);
153  assert_ptr_not_equal(key_part_const, NULL);
154  assert_int_equal(amxc_var_type_of(key_part_const), AMXC_VAR_ID_CSTRING);
155  assert_string_equal(key_part_const->data.s, "some text");
156 
157  assert_int_equal(amxc_var_new(&key_part), 0);
158  amxc_var_set(uint64_t, key_part, 123);
159  assert_int_equal(amxc_var_set_index(&var, 8, key_part, AMXC_VAR_FLAG_COPY | AMXC_VAR_FLAG_UPDATE), 0);
160  assert_int_equal(amxc_llist_size(&var.data.vl), 9);
161  amxc_var_delete(&key_part);
162 
163  assert_int_equal(amxc_var_new(&key_part), 0);
164  amxc_var_set(uint64_t, key_part, 123);
165  assert_int_equal(amxc_var_set_index(&var, 0, key_part, AMXC_VAR_FLAG_DEFAULT), 0);
166  assert_int_equal(amxc_llist_size(&var.data.vl), 10);
167  assert_ptr_equal(amxc_var_get_index(&var, 0, AMXC_VAR_FLAG_DEFAULT), key_part);
168  amxc_var_delete(&key_part);
169 
170  amxc_var_new(&key_part);
171  amxc_var_set(cstring_t, key_part, "more text");
172  assert_int_equal(amxc_var_set_index(&var, -1, key_part, AMXC_VAR_FLAG_COPY), 0);
173  assert_int_equal(amxc_llist_size(&var.data.vl), 10);
174  assert_int_equal(amxc_var_set_index(&var, -1, key_part, AMXC_VAR_FLAG_UPDATE), 0);
175  assert_int_equal(amxc_llist_size(&var.data.vl), 11);
176  assert_int_equal(amxc_var_set_index(&var, -1, key_part, AMXC_VAR_FLAG_DEFAULT), 0);
177  assert_int_equal(amxc_llist_size(&var.data.vl), 11);
178  amxc_var_new(&key_part);
179  amxc_var_set(cstring_t, key_part, "some text");
180  assert_int_equal(amxc_var_set_index(&var, -1, key_part, AMXC_VAR_FLAG_DEFAULT), 0);
181  assert_int_equal(amxc_llist_size(&var.data.vl), 12);
182  amxc_var_delete(&key_part);
183  assert_int_equal(amxc_llist_size(&var.data.vl), 11);
184 
185  amxc_var_new(&key_part);
186  amxc_var_set(cstring_t, key_part, "some text");
187  assert_int_equal(amxc_var_set_index(&var, 2, key_part, AMXC_VAR_FLAG_DEFAULT), 0);
188  assert_int_equal(amxc_llist_size(&var.data.vl), 12);
189  amxc_var_delete(&key_part);
190  assert_int_equal(amxc_llist_size(&var.data.vl), 11);
191 
192  key_part = amxc_var_get_index(&var, 8, AMXC_VAR_FLAG_COPY);
193  assert_int_equal(amxc_var_type_of(key_part), AMXC_VAR_ID_UINT64);
194  assert_int_equal(key_part->data.ui64, 123);
195 
196  assert_int_not_equal(amxc_var_set_index(&var, 8, NULL, AMXC_VAR_FLAG_COPY), 0);
197  assert_int_not_equal(amxc_var_set_index(&var, 99, key_part, AMXC_VAR_FLAG_COPY), 0);
198  assert_int_not_equal(amxc_var_set_index(NULL, 6, key_part, AMXC_VAR_FLAG_COPY), 0);
199 
200  assert_int_not_equal(amxc_var_set_index(&var, 8, NULL, AMXC_VAR_FLAG_DEFAULT), 0);
201  assert_int_not_equal(amxc_var_set_index(&var, 99, key_part, AMXC_VAR_FLAG_DEFAULT), 0);
202  assert_int_not_equal(amxc_var_set_index(NULL, 6, key_part, AMXC_VAR_FLAG_DEFAULT), 0);
203 
204  amxc_var_set_type(&var, AMXC_VAR_ID_BOOL);
205  assert_int_not_equal(amxc_var_set_index(&var, 6, key_part, AMXC_VAR_FLAG_COPY), 0);
206 
207  amxc_var_delete(&key_part);
208  amxc_var_clean(&string);
209  amxc_var_clean(&var);
210 }
211 
212 void test_variant_llist_set_key(UNUSED void** state) {
213  amxc_var_t var;
214  amxc_var_t string;
215  amxc_var_t* key_part = NULL;
216  const amxc_var_t* key_part_const = NULL;
217 
218  amxc_var_init(&var);
219  amxc_var_init(&string);
220  amxc_var_set(cstring_t, &string, "Hello,world,and,anyone,else,in,the,universe");
221  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_LIST), 0);
222  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_LIST);
223  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
224 
225  assert_int_equal(amxc_var_new(&key_part), 0);
226  amxc_var_set(cstring_t, key_part, "some text");
227  assert_int_equal(amxc_var_set_key(&var, "6", key_part, AMXC_VAR_FLAG_COPY | AMXC_VAR_FLAG_UPDATE), 0);
228  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
229 
230  assert_int_equal(amxc_var_set_key(&var, "5", key_part, AMXC_VAR_FLAG_DEFAULT | AMXC_VAR_FLAG_UPDATE), 0);
231  assert_int_equal(amxc_llist_size(&var.data.vl), 8);
232 
233  key_part = amxc_var_get_key(&var, "6", AMXC_VAR_FLAG_COPY);
234  assert_ptr_not_equal(key_part, NULL);
235  assert_int_equal(amxc_var_type_of(key_part), AMXC_VAR_ID_CSTRING);
236  assert_string_equal(key_part->data.s, "some text");
237  amxc_var_delete(&key_part);
238 
239  key_part_const = amxc_var_get_key(&var, "5", AMXC_VAR_FLAG_DEFAULT);
240  assert_ptr_not_equal(key_part_const, NULL);
241  assert_int_equal(amxc_var_type_of(key_part_const), AMXC_VAR_ID_CSTRING);
242  assert_string_equal(key_part_const->data.s, "some text");
243 
244  assert_int_equal(amxc_var_new(&key_part), 0);
245  amxc_var_set(uint64_t, key_part, 123);
246  assert_int_equal(amxc_var_set_key(&var, "8", key_part, AMXC_VAR_FLAG_COPY | AMXC_VAR_FLAG_UPDATE), 0);
247  assert_int_equal(amxc_llist_size(&var.data.vl), 9);
248  amxc_var_delete(&key_part);
249 
250  key_part = amxc_var_get_key(&var, "8", AMXC_VAR_FLAG_COPY);
251  assert_int_equal(amxc_var_type_of(key_part), AMXC_VAR_ID_UINT64);
252  assert_int_equal(key_part->data.ui64, 123);
253 
254  assert_int_not_equal(amxc_var_set_key(&var, "8", NULL, AMXC_VAR_FLAG_COPY), 0);
255  assert_int_not_equal(amxc_var_set_key(&var, "99", key_part, AMXC_VAR_FLAG_COPY), 0);
256  assert_int_not_equal(amxc_var_set_key(NULL, "6", key_part, AMXC_VAR_FLAG_COPY), 0);
257 
258  assert_int_not_equal(amxc_var_set_key(&var, "8", NULL, AMXC_VAR_FLAG_DEFAULT), 0);
259  assert_int_not_equal(amxc_var_set_key(&var, "99", key_part, AMXC_VAR_FLAG_DEFAULT), 0);
260  assert_int_not_equal(amxc_var_set_key(NULL, "6", key_part, AMXC_VAR_FLAG_DEFAULT), 0);
261 
262 
263  amxc_var_set_type(&var, AMXC_VAR_ID_BOOL);
264  assert_int_not_equal(amxc_var_set_key(&var, "6", key_part, AMXC_VAR_FLAG_COPY), 0);
265 
266  amxc_var_delete(&key_part);
267  amxc_var_clean(&string);
268  amxc_var_clean(&var);
269 }
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_variant_priv.h
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_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_UPDATE
#define AMXC_VAR_FLAG_UPDATE
Replaces the value of the variant, leaves the source variant untouched.
Definition: amxc_variant.h:404
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_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_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_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_set_index
int amxc_var_set_index(amxc_var_t *const var, const int64_t index, amxc_var_t *data, const int flags)
Set a part of composed variant using an index.
Definition: amxc_variant.c:507
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_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_set_key
int amxc_var_set_key(amxc_var_t *const var, const char *const key, amxc_var_t *data, const int flags)
Sets a part of composed variant using a key.
Definition: amxc_variant.c:468
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_llist_it::llist
struct _amxc_llist * llist
Definition: amxc_llist.h:220
_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
test_variant_llist_get_index
void test_variant_llist_get_index(UNUSED void **state)
Definition: test_2_index_cb_func.c:76
test_variant_llist_set_index
void test_variant_llist_set_index(UNUSED void **state)
Definition: test_2_index_cb_func.c:114
test_variant_llist_set_key
void test_variant_llist_set_key(UNUSED void **state)
Definition: test_2_index_cb_func.c:212
var
static amxc_var_t * var
Definition: test_issue_58.c:77
test_variant_list.h