libamxc  1.10.3
C Generic Data Containers
Functions
test_2_index_cb_func.c File Reference
#include <sys/time.h>
#include <sys/resource.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <inttypes.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include <cmocka.h>
#include <amxc/amxc_variant.h>
#include <amxc_variant_priv.h>
#include "test_variant_list.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

void test_variant_llist_get_index (UNUSED void **state)
 
void test_variant_llist_set_index (UNUSED void **state)
 
void test_variant_llist_set_key (UNUSED void **state)
 

Function Documentation

◆ test_variant_llist_get_index()

void test_variant_llist_get_index ( UNUSED void **  state)

Definition at line 76 of file test_2_index_cb_func.c.

76  {
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 }
cstring_t
#define cstring_t
Convenience macro.
Definition: amxc_variant.h:584
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_ID_CSTRING
#define AMXC_VAR_ID_CSTRING
C-string variant id (aka char *), null terminated string.
Definition: amxc_variant.h:134
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_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_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
var
static amxc_var_t * var
Definition: test_issue_58.c:77

◆ test_variant_llist_set_index()

void test_variant_llist_set_index ( UNUSED void **  state)

Definition at line 114 of file test_2_index_cb_func.c.

114  {
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 }
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_UINT64
#define AMXC_VAR_ID_UINT64
Unsigned 64 bit integer variant id.
Definition: amxc_variant.h:182
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

◆ test_variant_llist_set_key()

void test_variant_llist_set_key ( UNUSED void **  state)

Definition at line 212 of file test_2_index_cb_func.c.

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