libamxc  1.10.3
C Generic Data Containers
Functions
test_variant_int8.c File Reference
#include <sys/time.h>
#include <sys/resource.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_int8.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

void test_variant_int8_copy (UNUSED void **state)
 
void test_variant_int8_convert_to (UNUSED void **state)
 
void test_variant_int8_compare (UNUSED void **state)
 
void test_variant_int8_set_get (UNUSED void **state)
 
void test_variant_int8_add (UNUSED void **state)
 

Function Documentation

◆ test_variant_int8_add()

void test_variant_int8_add ( UNUSED void **  state)

Definition at line 270 of file test_variant_int8.c.

270  {
271  amxc_var_t var;
272  const amxc_llist_t* list = NULL;
273  const amxc_htable_t* table = NULL;
274 
275  assert_int_equal(amxc_var_init(&var), 0);
276  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_LIST), 0);
277  assert_ptr_not_equal(amxc_var_add(int8_t, &var, 123), NULL);
278  assert_ptr_not_equal(amxc_var_add(int8_t, &var, 64), NULL);
279 
280  assert_ptr_equal(amxc_var_add(int8_t, NULL, 123), NULL);
281  assert_ptr_equal(amxc_var_add(int8_t, NULL, 64), NULL);
282 
283  list = amxc_var_constcast(amxc_llist_t, &var);
284  assert_int_equal(amxc_llist_size(list), 2);
285  amxc_var_clean(&var);
286 
287  assert_int_equal(amxc_var_init(&var), 0);
288  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_HTABLE), 0);
289  assert_ptr_not_equal(amxc_var_add_key(int8_t, &var, "B1", 123), NULL);
290  assert_ptr_not_equal(amxc_var_add_key(int8_t, &var, "B2", 64), NULL);
291 
292  assert_ptr_equal(amxc_var_add_key(int8_t, NULL, "B1", 123), NULL);
293  assert_ptr_equal(amxc_var_add_key(int8_t, NULL, "B2", 64), NULL);
294 
295  table = amxc_var_constcast(amxc_htable_t, &var);
296  assert_int_equal(amxc_htable_size(table), 2);
297  amxc_var_clean(&var);
298 }
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_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_ID_LIST
#define AMXC_VAR_ID_LIST
Ambiorix Linked List variant id.
Definition: amxc_variant.h:206
AMXC_VAR_ID_HTABLE
#define AMXC_VAR_ID_HTABLE
Ambiorix Hash Table variant id.
Definition: amxc_variant.h:212
amxc_var_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_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_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
var
static amxc_var_t * var
Definition: test_issue_58.c:77

◆ test_variant_int8_compare()

void test_variant_int8_compare ( UNUSED void **  state)

Definition at line 226 of file test_variant_int8.c.

226  {
227  amxc_var_t var1;
228  amxc_var_t var2;
229  int result = 0;
230 
231  assert_int_equal(amxc_var_init(&var1), 0);
232  assert_int_equal(amxc_var_init(&var2), 0);
233  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_INT8), 0);
234  assert_int_equal(var1.type_id, AMXC_VAR_ID_INT8);
235  var1.data.i8 = 100;
236  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_INT8), 0);
237  assert_int_equal(var2.type_id, AMXC_VAR_ID_INT8);
238  var2.data.i8 = -100;
239 
240  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
241  assert_true(result > 0);
242 
243  assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);
244  assert_true(result < 0);
245 
246  var2.data.i16 = 100;
247  assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);
248  assert_true(result == 0);
249 
250 }
AMXC_VAR_ID_INT8
#define AMXC_VAR_ID_INT8
Signed 8 bit integer variant id.
Definition: amxc_variant.h:140
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::data
void * data
Definition: amxc_variant.h:883
_amxc_var::type_id
uint32_t type_id
Definition: amxc_variant.h:864

◆ test_variant_int8_convert_to()

void test_variant_int8_convert_to ( UNUSED void **  state)

Definition at line 91 of file test_variant_int8.c.

91  {
92  amxc_var_t var;
93  amxc_var_t copy_var;
94 
95  assert_int_equal(amxc_var_init(&var), 0);
96  assert_int_equal(amxc_var_init(&copy_var), 0);
97  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
98  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_INT8), 0);
99  assert_int_equal(var.type_id, AMXC_VAR_ID_INT8);
100 
101  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_NULL), 0);
102  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_NULL);
103  assert_ptr_equal(copy_var.data.data, NULL);
104  var.data.i8 = 0x80;
105  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CSTRING), 0);
106  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_CSTRING);
107  assert_string_equal(copy_var.data.s, "-128");
108 
109  var.data.i8 = 0xFF;
110  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CSTRING), 0);
111  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_CSTRING);
112  assert_string_equal(copy_var.data.s, "-1");
113 
114  var.data.i8 = 127;
115  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);
116  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT8);
117  assert_int_equal(copy_var.data.i8, 127);
118  var.data.i8 = -128;
119  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);
120  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT8);
121  assert_int_equal(copy_var.data.i8, -128);
122 
123  var.data.i8 = 127;
124  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);
125  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT16);
126  assert_int_equal(copy_var.data.i8, 127);
127  var.data.i8 = -128;
128  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);
129  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT16);
130  assert_int_equal(copy_var.data.i8, -128);
131 
132  var.data.i8 = 64;
133  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);
134  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT32);
135  assert_int_equal(copy_var.data.i32, 64);
136  var.data.i8 = -64;
137  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);
138  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT32);
139  assert_int_equal(copy_var.data.i32, -64);
140 
141  var.data.i8 = -32;
142  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
143  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT64);
144  assert_int_equal(copy_var.data.i64, -32);
145  var.data.i8 = 0x7F;
146  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
147  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT64);
148  assert_int_equal(copy_var.data.i64, 0x7F);
149 
150  var.data.i8 = 127;
151  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT8), 0);
152  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT8);
153  assert_int_equal(copy_var.data.ui8, 127);
154  var.data.i8 = -128;
155  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT8), 0);
156  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT8);
157  assert_int_equal(copy_var.data.ui8, 128);
158 
159  var.data.i8 = -128;
160  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT16), 0);
161  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT16);
162  assert_int_equal(copy_var.data.ui16, 128);
163  var.data.i8 = 127;
164  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT16), 0);
165  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT16);
166  assert_int_equal(copy_var.data.ui16, 127);
167 
168  var.data.i8 = INT8_MAX;
169  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT32), 0);
170  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT32);
171  assert_int_equal(copy_var.data.ui32, INT8_MAX);
172  var.data.i8 = INT8_MIN;
173  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT32), 0);
174  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT32);
175  assert_int_equal(copy_var.data.ui16, llabs(INT8_MIN));
176 
177  var.data.i8 = INT8_MAX;
178  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
179  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT64);
180  assert_int_equal(copy_var.data.ui64, INT8_MAX);
181  var.data.i8 = INT8_MIN;
182  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
183  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT64);
184  assert_int_equal(copy_var.data.ui64, llabs(INT8_MIN));
185 
186  var.data.i8 = 100;
187  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_TIMESTAMP), 0);
188  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_TIMESTAMP);
189  var.data.i8 = -100;
190  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_TIMESTAMP), 0);
191  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_TIMESTAMP);
192 
193  var.data.i8 = 0xF0;
194  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
195  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_BOOL);
196  assert_true(copy_var.data.b);
197  var.data.i8 = 0x00;
198  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
199  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_BOOL);
200  assert_false(copy_var.data.b);
201 
202  var.data.i8 = 100;
203  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
204  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_FLOAT);
205  assert_true(copy_var.data.f == 100);
206 
207  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
208  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_DOUBLE);
209  assert_true(copy_var.data.d == 100);
210 
211  struct rlimit nofile = { 0, 0 };
212  assert_int_equal(getrlimit(RLIMIT_NOFILE, &nofile), 0);
213 
214  var.data.i8 = 0xE0;
215  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FD), 0);
216  var.data.i8 = -1;
217  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FD), 0);
218  var.data.i8 = STDIN_FILENO;
219  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FD), 0);
220  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_FD);
221  assert_int_equal(copy_var.data.fd, STDIN_FILENO);
222 
223  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CUSTOM_BASE), 0);
224 }
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_INT16
#define AMXC_VAR_ID_INT16
Signed 16 bit integer variant id.
Definition: amxc_variant.h:146
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_UINT8
#define AMXC_VAR_ID_UINT8
Unsigned 8 bit integer variant id.
Definition: amxc_variant.h:164
AMXC_VAR_ID_UINT64
#define AMXC_VAR_ID_UINT64
Unsigned 64 bit integer variant id.
Definition: amxc_variant.h:182
AMXC_VAR_ID_DOUBLE
#define AMXC_VAR_ID_DOUBLE
Double variant id.
Definition: amxc_variant.h:194
AMXC_VAR_ID_UINT16
#define AMXC_VAR_ID_UINT16
Unsigned 16 bit integer variant id.
Definition: amxc_variant.h:170
AMXC_VAR_ID_FD
#define AMXC_VAR_ID_FD
File descriptor variant id.
Definition: amxc_variant.h:218
AMXC_VAR_ID_BOOL
#define AMXC_VAR_ID_BOOL
Boolean variant id.
Definition: amxc_variant.h:200
AMXC_VAR_ID_INT32
#define AMXC_VAR_ID_INT32
Signed 32 bit integer variant id.
Definition: amxc_variant.h:152
AMXC_VAR_ID_TIMESTAMP
#define AMXC_VAR_ID_TIMESTAMP
Ambiorix timestamp variant id.
Definition: amxc_variant.h:224
AMXC_VAR_ID_FLOAT
#define AMXC_VAR_ID_FLOAT
Float variant id.
Definition: amxc_variant.h:188
AMXC_VAR_ID_INT64
#define AMXC_VAR_ID_INT64
Signed 64 bit integer variant id.
Definition: amxc_variant.h:158
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

◆ test_variant_int8_copy()

void test_variant_int8_copy ( UNUSED void **  state)

Definition at line 75 of file test_variant_int8.c.

75  {
76  amxc_var_t var;
77  amxc_var_t copy_var;
78 
79  assert_int_equal(amxc_var_init(&var), 0);
80  assert_int_equal(amxc_var_init(&copy_var), 0);
81  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
82  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_INT8), 0);
83  assert_int_equal(var.type_id, AMXC_VAR_ID_INT8);
84  var.data.i8 = 127;
85 
86  assert_int_equal(amxc_var_copy(&copy_var, &var), 0);
87  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT8);
88  assert_int_equal(copy_var.data.i8, 127);
89 }
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

◆ test_variant_int8_set_get()

void test_variant_int8_set_get ( UNUSED void **  state)

Definition at line 252 of file test_variant_int8.c.

252  {
253  amxc_var_t var1;
254 
255  assert_int_equal(amxc_var_init(&var1), 0);
256  assert_int_equal(amxc_var_set_int8_t(&var1, 128), 0);
257  assert_int_equal(var1.type_id, AMXC_VAR_ID_INT8);
258  assert_true(var1.data.i8 = 100);
259 
260  assert_true(amxc_var_get_int8_t(&var1) == 100);
261  assert_true(amxc_var_dyncast(int8_t, &var1) == 100);
262 
263  assert_int_not_equal(amxc_var_set_int8_t(NULL, 100), 0);
264  assert_true(amxc_var_get_int8_t(NULL) == 0);
265 
266  assert_int_equal(amxc_var_constcast(int8_t, &var1), 100);
267  assert_int_equal(amxc_var_constcast(int8_t, NULL), 0);
268 }
amxc_var_get_int8_t
int8_t amxc_var_get_int8_t(const amxc_var_t *const var)
Conversion helper function.
Definition: variant_int8.c:291
amxc_var_set_int8_t
int amxc_var_set_int8_t(amxc_var_t *const var, int8_t val)
Setter helper function.
Definition: variant_int8.c:278
amxc_var_dyncast
#define amxc_var_dyncast(type, var)
Dynamic cast a variant to a certain type.
Definition: amxc_variant.h:678