libamxc  1.10.3
C Generic Data Containers
Functions
test_variant_double.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_double.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

void test_variant_double_copy (UNUSED void **state)
 
void test_variant_double_convert_to_bool (UNUSED void **state)
 
void test_variant_double_convert_to_integer (UNUSED void **state)
 
void test_variant_double_convert_to_htable (UNUSED void **state)
 
void test_variant_double_convert_to_list (UNUSED void **state)
 
void test_variant_double_convert_to_string (UNUSED void **state)
 
void test_variant_double_compare (UNUSED void **state)
 
void test_variant_double_set_get (UNUSED void **state)
 
void test_variant_double_add (UNUSED void **state)
 

Function Documentation

◆ test_variant_double_add()

void test_variant_double_add ( UNUSED void **  state)

Definition at line 254 of file test_variant_double.c.

254  {
255  amxc_var_t var;
256  const amxc_llist_t* list = NULL;
257  const amxc_htable_t* table = NULL;
258 
259  assert_int_equal(amxc_var_init(&var), 0);
260  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_LIST), 0);
261  assert_ptr_not_equal(amxc_var_add(double, &var, 3.1415), NULL);
262  assert_ptr_not_equal(amxc_var_add(double, &var, 0.3333), NULL);
263 
264  assert_ptr_equal(amxc_var_add(double, NULL, 3.1415), NULL);
265  assert_ptr_equal(amxc_var_add(double, NULL, 0.3333), NULL);
266 
267  list = amxc_var_constcast(amxc_llist_t, &var);
268  assert_int_equal(amxc_llist_size(list), 2);
269  amxc_var_clean(&var);
270 
271  assert_int_equal(amxc_var_init(&var), 0);
272  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_HTABLE), 0);
273  assert_ptr_not_equal(amxc_var_add_key(double, &var, "B1", 3.1415), NULL);
274  assert_ptr_not_equal(amxc_var_add_key(double, &var, "B2", 0.3333), NULL);
275 
276  assert_ptr_equal(amxc_var_add_key(double, NULL, "B1", 3.1415), NULL);
277  assert_ptr_equal(amxc_var_add_key(double, NULL, "B2", 0.3333), NULL);
278 
279  table = amxc_var_constcast(amxc_htable_t, &var);
280  assert_int_equal(amxc_htable_size(table), 2);
281  amxc_var_clean(&var);
282 }
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_double_compare()

void test_variant_double_compare ( UNUSED void **  state)

Definition at line 214 of file test_variant_double.c.

214  {
215  amxc_var_t var1;
216  amxc_var_t var2;
217  int result = 0;
218 
219  assert_int_equal(amxc_var_init(&var1), 0);
220  assert_int_equal(amxc_var_init(&var2), 0);
221 
222  assert_int_equal(amxc_var_set(double, &var1, 3.141595), 0);
223  assert_int_equal(amxc_var_type_of(&var1), AMXC_VAR_ID_DOUBLE);
224  assert_int_equal(amxc_var_set(double, &var2, 3.141596), 0);
225  assert_int_equal(amxc_var_type_of(&var2), AMXC_VAR_ID_DOUBLE);
226 
227  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
228  assert_true(result < 0);
229  assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);
230  assert_true(result > 0);
231 
232  assert_int_equal(amxc_var_copy(&var1, &var2), 0);
233  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
234  assert_true(result == 0);
235 
236  amxc_var_clean(&var1);
237  amxc_var_clean(&var2);
238 }
AMXC_VAR_ID_DOUBLE
#define AMXC_VAR_ID_DOUBLE
Double variant id.
Definition: amxc_variant.h:194
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_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_set
#define amxc_var_set(type, var, data)
Convenience macro for setting a value in a variant.
Definition: amxc_variant.h:609
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

◆ test_variant_double_convert_to_bool()

void test_variant_double_convert_to_bool ( UNUSED void **  state)

Definition at line 94 of file test_variant_double.c.

94  {
95  amxc_var_t var;
96  amxc_var_t copy_var;
97 
98  assert_int_equal(amxc_var_init(&var), 0);
99  assert_int_equal(amxc_var_init(&copy_var), 0);
100 
101  assert_int_equal(amxc_var_set(double, &var, 3.141595), 0);
102  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_DOUBLE);
103 
104  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
105  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_BOOL);
106  assert_true(amxc_var_constcast(bool, &copy_var));
107 
108  assert_int_equal(amxc_var_set(double, &var, 0), 0);
109  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_DOUBLE);
110 
111  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
112  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_BOOL);
113  assert_false(amxc_var_constcast(bool, &copy_var));
114 
115  amxc_var_clean(&var);
116  amxc_var_clean(&copy_var);
117 }
AMXC_VAR_ID_BOOL
#define AMXC_VAR_ID_BOOL
Boolean variant id.
Definition: amxc_variant.h:200
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_double_convert_to_htable()

void test_variant_double_convert_to_htable ( UNUSED void **  state)

Definition at line 159 of file test_variant_double.c.

159  {
160  amxc_var_t var;
161  amxc_var_t copy_var;
162 
163  assert_int_equal(amxc_var_init(&var), 0);
164  assert_int_equal(amxc_var_init(&copy_var), 0);
165 
166  assert_int_equal(amxc_var_set(double, &var, 3.141595), 0);
167  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_DOUBLE);
168 
169  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_HTABLE), 0);
170  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_HTABLE);
171  assert_int_equal(amxc_htable_size(&copy_var.data.vm), 1);
172  assert_false(amxc_htable_is_empty(&copy_var.data.vm));
173 
174  amxc_var_clean(&var);
175  amxc_var_clean(&copy_var);
176 }
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_var::data
void * data
Definition: amxc_variant.h:883

◆ test_variant_double_convert_to_integer()

void test_variant_double_convert_to_integer ( UNUSED void **  state)

Definition at line 119 of file test_variant_double.c.

119  {
120  amxc_var_t var;
121  amxc_var_t copy_var;
122 
123  assert_int_equal(amxc_var_init(&var), 0);
124  assert_int_equal(amxc_var_init(&copy_var), 0);
125 
126  assert_int_equal(amxc_var_set(double, &var, 3.141595), 0);
127  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_DOUBLE);
128 
129  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
130  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_INT64);
131  assert_int_equal(amxc_var_constcast(int64_t, &copy_var), 3);
132 
133  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);
134  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_INT32);
135 
136  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);
137  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_INT16);
138 
139  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);
140  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_INT8);
141 
142  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
143  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_UINT64);
144  assert_int_equal(amxc_var_constcast(uint64_t, &copy_var), 3);
145 
146  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT32), 0);
147  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_UINT32);
148 
149  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT16), 0);
150  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_UINT16);
151 
152  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT8), 0);
153  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_UINT8);
154 
155  amxc_var_clean(&var);
156  amxc_var_clean(&copy_var);
157 }
AMXC_VAR_ID_UINT32
#define AMXC_VAR_ID_UINT32
Unsigned 32 bit integer variant id.
Definition: amxc_variant.h:176
AMXC_VAR_ID_INT16
#define AMXC_VAR_ID_INT16
Signed 16 bit integer variant id.
Definition: amxc_variant.h:146
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_UINT16
#define AMXC_VAR_ID_UINT16
Unsigned 16 bit integer variant id.
Definition: amxc_variant.h:170
AMXC_VAR_ID_INT32
#define AMXC_VAR_ID_INT32
Signed 32 bit integer variant id.
Definition: amxc_variant.h:152
AMXC_VAR_ID_INT8
#define AMXC_VAR_ID_INT8
Signed 8 bit integer variant id.
Definition: amxc_variant.h:140
AMXC_VAR_ID_INT64
#define AMXC_VAR_ID_INT64
Signed 64 bit integer variant id.
Definition: amxc_variant.h:158

◆ test_variant_double_convert_to_list()

void test_variant_double_convert_to_list ( UNUSED void **  state)

Definition at line 178 of file test_variant_double.c.

178  {
179  amxc_var_t var;
180  amxc_var_t copy_var;
181 
182  assert_int_equal(amxc_var_init(&var), 0);
183  assert_int_equal(amxc_var_init(&copy_var), 0);
184 
185  assert_int_equal(amxc_var_set(double, &var, 3.141595), 0);
186  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_DOUBLE);
187 
188  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
189  assert_int_equal(amxc_llist_size(&copy_var.data.vl), 1);
190  assert_false(amxc_llist_is_empty(&copy_var.data.vl));
191 
192  amxc_var_clean(&var);
193  amxc_var_clean(&copy_var);
194 }
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

◆ test_variant_double_convert_to_string()

void test_variant_double_convert_to_string ( UNUSED void **  state)

Definition at line 196 of file test_variant_double.c.

196  {
197  amxc_var_t var;
198  amxc_var_t copy_var;
199 
200  assert_int_equal(amxc_var_init(&var), 0);
201  assert_int_equal(amxc_var_init(&copy_var), 0);
202 
203  assert_int_equal(amxc_var_set(double, &var, 3.141595), 0);
204  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_DOUBLE);
205 
206  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CSTRING), 0);
207  assert_ptr_not_equal(copy_var.data.s, NULL);
208  assert_string_equal(copy_var.data.s, "3.141595");
209 
210  amxc_var_clean(&var);
211  amxc_var_clean(&copy_var);
212 }
AMXC_VAR_ID_CSTRING
#define AMXC_VAR_ID_CSTRING
C-string variant id (aka char *), null terminated string.
Definition: amxc_variant.h:134

◆ test_variant_double_copy()

void test_variant_double_copy ( UNUSED void **  state)

Definition at line 76 of file test_variant_double.c.

76  {
77  amxc_var_t var;
78  amxc_var_t copy_var;
79 
80  assert_int_equal(amxc_var_init(&var), 0);
81  assert_int_equal(amxc_var_init(&copy_var), 0);
82 
83  assert_int_equal(amxc_var_set(double, &var, 3.141595), 0);
84  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_DOUBLE);
85 
86  assert_int_equal(amxc_var_copy(&copy_var, &var), 0);
87  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_DOUBLE);
88  assert_true(amxc_var_constcast(double, &copy_var) == 3.141595);
89 
90  amxc_var_clean(&var);
91  amxc_var_clean(&copy_var);
92 }

◆ test_variant_double_set_get()

void test_variant_double_set_get ( UNUSED void **  state)

Definition at line 240 of file test_variant_double.c.

240  {
241  amxc_var_t var;
242 
243  assert_int_equal(amxc_var_init(&var), 0);
244 
245  assert_int_equal(amxc_var_set(double, &var, 3.141595), 0);
246  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_DOUBLE);
247 
248  assert_true(amxc_var_get_double(&var) == 3.141595);
249  assert_true(amxc_var_get_double(NULL) == 0);
250 
251  amxc_var_clean(&var);
252 }
amxc_var_get_double
double amxc_var_get_double(const amxc_var_t *var)
Conversion helper function.
Definition: variant_double.c:313