libamxc  1.10.3
C Generic Data Containers
Data Structures | Functions | Variables
test_amxc_variant_dump.c File Reference
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <setjmp.h>
#include <cmocka.h>
#include <syslog.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <malloc.h>
#include <amxc/amxc_variant_type.h>
#include "test_amxc_variant_dump.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Data Structures

struct  teststate_t
 

Functions

int test_amxc_variant_dump_testsetup (void **state)
 
int test_amxc_variant_dump_testteardown (void **state)
 
void test_amxc_variant_dump (UNUSED void **state)
 
void test_amxc_variant_dump2 (UNUSED void **state)
 
void test_amxc_variant_log (UNUSED void **state)
 
void test_amxc_variant_dump_null (UNUSED void **state)
 
void test_amxc_variant_dump2_null (UNUSED void **state)
 
void test_amxc_variant_log_null (UNUSED void **state)
 
void test_amxc_variant_dump_list_comma_position (void **state)
 
void test_amxc_variant_dump_htable_comma_position (void **state)
 

Variables

static amxc_var_type_t my_dummy_type
 

Function Documentation

◆ test_amxc_variant_dump()

void test_amxc_variant_dump ( UNUSED void **  state)

Definition at line 116 of file test_amxc_variant_dump.c.

116  {
117  amxc_var_t myvar;
118  amxc_var_t* subvar = NULL;
119 
120  amxc_var_register_type(&my_dummy_type);
121  int dummy_type_id = amxc_var_get_type_id_from_name(my_dummy_type.name);
122 
123  amxc_var_init(&myvar);
124  amxc_var_set_type(&myvar, AMXC_VAR_ID_HTABLE);
125 
126  subvar = amxc_var_add_new_key(&myvar, "KEY1");
127  amxc_var_set_type(subvar, AMXC_VAR_ID_LIST);
128  amxc_var_add_new(subvar);
129  amxc_var_add_new(subvar);
130  subvar = amxc_var_add_new_key(&myvar, "KEY2");
131  amxc_var_set_type(subvar, AMXC_VAR_ID_HTABLE);
132  amxc_var_add_new_key(subvar, "Foo");
133  amxc_var_add_new_key(subvar, "Bar");
134  subvar = amxc_var_add_key(cstring_t, &myvar, "KEY3", "Hello world");
135  subvar = amxc_var_add_key(uint64_t, &myvar, "KEY4", 666);
136  subvar = amxc_var_add_key(fd_t, &myvar, "KEY5", STDOUT_FILENO);
137  subvar = amxc_var_add_new_key(&myvar, "KEY6");
138  amxc_var_set_type(subvar, dummy_type_id);
139 
140  amxc_var_dump(&myvar, STDOUT_FILENO);
141 
142  amxc_var_unregister_type(&my_dummy_type);
143 
144  amxc_var_clean(&myvar);
145 }
fd_t
#define fd_t
Convenience macro.
Definition: amxc_variant.h:600
cstring_t
#define cstring_t
Convenience macro.
Definition: amxc_variant.h:584
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_register_type
uint32_t amxc_var_register_type(amxc_var_type_t *const type)
Register a new variant type.
Definition: amxc_variant_type.c:199
amxc_var_get_type_id_from_name
uint32_t amxc_var_get_type_id_from_name(const char *const name)
Get the type id.
Definition: amxc_variant_type.c:234
amxc_var_unregister_type
int amxc_var_unregister_type(amxc_var_type_t *const type)
Unregisters an already registered variant type.
Definition: amxc_variant_type.c:209
amxc_var_dump
int amxc_var_dump(const amxc_var_t *const var, int fd)
Dumps the content of the variant in a human readable manner.
Definition: amxc_variant_dump.c:340
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_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_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_clean
void amxc_var_clean(amxc_var_t *const var)
Clean-up and reset variant.
Definition: amxc_variant.c:237
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_type::name
const char * name
Definition: amxc_variant_type.h:225
_amxc_var
The variant struct definition.
Definition: amxc_variant.h:861
my_dummy_type
static amxc_var_type_t my_dummy_type
Definition: test_amxc_variant_dump.c:76

◆ test_amxc_variant_dump2()

void test_amxc_variant_dump2 ( UNUSED void **  state)

Definition at line 147 of file test_amxc_variant_dump.c.

147  {
148  amxc_var_t myvar;
149  amxc_var_t* subvar = NULL;
150  FILE* fp = NULL;
151  static char msgbuf[512];
152 
153  memset(msgbuf, 0, sizeof(msgbuf));
154  fp = fmemopen(msgbuf, 512, "w");
155  assert_non_null(fp);
156 
157  amxc_var_register_type(&my_dummy_type);
158  int dummy_type_id = amxc_var_get_type_id_from_name(my_dummy_type.name);
159 
160  amxc_var_init(&myvar);
161  amxc_var_set_type(&myvar, AMXC_VAR_ID_HTABLE);
162 
163  subvar = amxc_var_add_new_key(&myvar, "KEY1");
164  amxc_var_set_type(subvar, AMXC_VAR_ID_LIST);
165  amxc_var_add_new(subvar);
166  amxc_var_add_new(subvar);
167  subvar = amxc_var_add_new_key(&myvar, "KEY2");
168  amxc_var_set_type(subvar, AMXC_VAR_ID_HTABLE);
169  amxc_var_add_new_key(subvar, "Foo");
170  amxc_var_add_new_key(subvar, "Bar");
171  subvar = amxc_var_add_key(cstring_t, &myvar, "KEY3", "Hello world");
172  subvar = amxc_var_add_key(uint64_t, &myvar, "KEY4", 666);
173  subvar = amxc_var_add_key(fd_t, &myvar, "KEY5", STDOUT_FILENO);
174  subvar = amxc_var_add_new_key(&myvar, "KEY6");
175  amxc_var_set_type(subvar, dummy_type_id);
176 
177  amxc_var_dump_stream(&myvar, fp);
178  fclose(fp);
179  assert_non_null(strstr(msgbuf, "KEY1"));
180  assert_non_null(strstr(msgbuf, "KEY2"));
181  assert_non_null(strstr(msgbuf, "Foo"));
182  assert_non_null(strstr(msgbuf, "Bar"));
183  assert_non_null(strstr(msgbuf, "KEY3"));
184  assert_non_null(strstr(msgbuf, "Hello world"));
185  assert_non_null(strstr(msgbuf, "KEY4"));
186  assert_non_null(strstr(msgbuf, "666"));
187  assert_non_null(strstr(msgbuf, "KEY5"));
188  assert_non_null(strstr(msgbuf, "KEY6"));
189  assert_non_null(strstr(msgbuf, "my_dummy_type_t"));
190 
191  amxc_var_unregister_type(&my_dummy_type);
192 
193  amxc_var_clean(&myvar);
194 }
amxc_var_dump_stream
int amxc_var_dump_stream(const amxc_var_t *const var, FILE *stream)
Dumps the content of the variant in a human readable manner.
Definition: amxc_variant_dump.c:344

◆ test_amxc_variant_dump2_null()

void test_amxc_variant_dump2_null ( UNUSED void **  state)

Definition at line 234 of file test_amxc_variant_dump.c.

234  {
235  amxc_var_t myvar;
236  amxc_var_t* subvar = NULL;
237  FILE* fp = NULL;
238  static char msgbuf[512];
239 
240  memset(msgbuf, 0, sizeof(msgbuf));
241  fp = fmemopen(msgbuf, 512, "w");
242  assert_non_null(fp);
243 
244  amxc_var_register_type(&my_dummy_type);
245  int dummy_type_id = amxc_var_get_type_id_from_name(my_dummy_type.name);
246 
247  amxc_var_init(&myvar);
248  amxc_var_set_type(&myvar, AMXC_VAR_ID_HTABLE);
249 
250  subvar = amxc_var_add_new_key(&myvar, "KEY1");
251  amxc_var_set_type(subvar, AMXC_VAR_ID_LIST);
252  amxc_var_add_new(subvar);
253  amxc_var_add_new(subvar);
254  subvar = amxc_var_add_new_key(&myvar, "KEY2");
255  amxc_var_set_type(subvar, AMXC_VAR_ID_HTABLE);
256  amxc_var_add_new_key(subvar, "Foo");
257  amxc_var_add_new_key(subvar, "Bar");
258  subvar = amxc_var_add_key(cstring_t, &myvar, "KEY3", "Hello world");
259  subvar = amxc_var_add_key(uint64_t, &myvar, "KEY4", 666);
260  subvar = amxc_var_add_key(fd_t, &myvar, "KEY5", STDOUT_FILENO);
261  subvar = amxc_var_add_new_key(&myvar, "KEY6");
262  amxc_var_set_type(subvar, dummy_type_id);
263 
264  amxc_var_dump_stream(NULL, NULL);
265  amxc_var_dump_stream(&myvar, NULL);
266  amxc_var_dump_stream(NULL, fp);
267  fclose(fp);
268 
269  amxc_var_unregister_type(&my_dummy_type);
270 
271  amxc_var_clean(&myvar);
272 }

◆ test_amxc_variant_dump_htable_comma_position()

void test_amxc_variant_dump_htable_comma_position ( void **  state)

Definition at line 308 of file test_amxc_variant_dump.c.

308  {
309  amxc_var_t myvar;
310  teststate_t* teststate = *state;
311  int status = -1;
312 
313  // GIVEN a variant containing a hashtable
314  amxc_var_init(&myvar);
315  amxc_var_set_type(&myvar, AMXC_VAR_ID_HTABLE);
316  amxc_var_add_key(cstring_t, &myvar, "key1", "text1");
317  amxc_var_add_key(cstring_t, &myvar, "key2", "text2");
318  amxc_var_add_key(int32_t, &myvar, "key3", 3);
319  amxc_var_add_key(bool, &myvar, "key4", true);
320 
321  // WHEN serializing it
322  status = amxc_var_dump(&myvar, teststate->fd);
323 
324  // THEN the element without trailing comma is the last in the in the serialization output
325  // (not the last in hashtable internal order).
326  assert_int_equal(0, status);
327  assert_string_equal(teststate->buffer,
328  "{\n"
329  " key1 = \"text1\",\n"
330  " key2 = \"text2\",\n"
331  " key3 = 3,\n"
332  " key4 = true\n"
333  "}\n");
334 
335  amxc_var_clean(&myvar);
336 }
teststate_t
Definition: test_amxc_variant_dump.c:87
teststate_t::buffer
char * buffer
Definition: test_amxc_variant_dump.c:89
teststate_t::fd
int fd
Definition: test_amxc_variant_dump.c:88

◆ test_amxc_variant_dump_list_comma_position()

void test_amxc_variant_dump_list_comma_position ( void **  state)

Definition at line 278 of file test_amxc_variant_dump.c.

278  {
279  amxc_var_t myvar;
280  teststate_t* teststate = *state;
281  int status = -1;
282 
283  // GIVEN a variant containing a list
284  amxc_var_init(&myvar);
285  amxc_var_set_type(&myvar, AMXC_VAR_ID_LIST);
286  amxc_var_add(cstring_t, &myvar, "text1");
287  amxc_var_add(cstring_t, &myvar, "text2");
288  amxc_var_add(int32_t, &myvar, 3);
289  amxc_var_add(bool, &myvar, true);
290 
291  // WHEN serializing it
292  status = amxc_var_dump(&myvar, teststate->fd);
293 
294  // THEN in the serialization output, commas are inbetween the elements
295  // and not after the last element
296  assert_int_equal(0, status);
297  assert_string_equal(teststate->buffer,
298  "[\n"
299  " \"text1\",\n"
300  " \"text2\",\n"
301  " 3,\n"
302  " true\n"
303  "]\n");
304 
305  amxc_var_clean(&myvar);
306 }
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

◆ test_amxc_variant_dump_null()

void test_amxc_variant_dump_null ( UNUSED void **  state)

Definition at line 230 of file test_amxc_variant_dump.c.

230  {
231  amxc_var_dump(NULL, STDOUT_FILENO);
232 }

◆ test_amxc_variant_dump_testsetup()

int test_amxc_variant_dump_testsetup ( void **  state)

Definition at line 93 of file test_amxc_variant_dump.c.

93  {
94  teststate_t* teststate = calloc(1, sizeof(teststate_t));
95  assert_non_null(teststate);
96 
97  teststate->fd = shm_open("/test_amxc_variant_dump", O_CREAT | O_TRUNC | O_RDWR, S_IRUSR | S_IWUSR);
98  assert_int_not_equal(teststate->fd, -1);
99  assert_int_not_equal(-1, ftruncate(teststate->fd, 1024));
100  teststate->buffer = mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, teststate->fd, 0);
101  assert_non_null(teststate->buffer);
102 
103  *state = teststate;
104  return 0;
105 }

◆ test_amxc_variant_dump_testteardown()

int test_amxc_variant_dump_testteardown ( void **  state)

Definition at line 108 of file test_amxc_variant_dump.c.

108  {
109  assert_non_null(state);
110  shm_unlink("/test_amxc_variant_dump");
111  free(*state);
112  *state = NULL;
113  return 0;
114 }

◆ test_amxc_variant_log()

void test_amxc_variant_log ( UNUSED void **  state)

Definition at line 196 of file test_amxc_variant_dump.c.

196  {
197  amxc_var_t myvar;
198  amxc_var_t* subvar = NULL;
199 
200  openlog("test", LOG_PID | LOG_CONS, LOG_DAEMON);
201 
202  amxc_var_register_type(&my_dummy_type);
203  int dummy_type_id = amxc_var_get_type_id_from_name(my_dummy_type.name);
204 
205  amxc_var_init(&myvar);
206  amxc_var_set_type(&myvar, AMXC_VAR_ID_HTABLE);
207 
208  subvar = amxc_var_add_new_key(&myvar, "KEY1");
209  amxc_var_set_type(subvar, AMXC_VAR_ID_LIST);
210  amxc_var_add_new(subvar);
211  amxc_var_add_new(subvar);
212  subvar = amxc_var_add_new_key(&myvar, "KEY2");
213  amxc_var_set_type(subvar, AMXC_VAR_ID_HTABLE);
214  amxc_var_add_new_key(subvar, "Foo");
215  amxc_var_add_new_key(subvar, "Bar");
216  subvar = amxc_var_add_key(cstring_t, &myvar, "KEY3", "Hello world");
217  subvar = amxc_var_add_key(uint64_t, &myvar, "KEY4", 666);
218  subvar = amxc_var_add_key(fd_t, &myvar, "KEY5", STDOUT_FILENO);
219  subvar = amxc_var_add_new_key(&myvar, "KEY6");
220  amxc_var_set_type(subvar, dummy_type_id);
221 
222  amxc_var_log(&myvar);
223 
224  amxc_var_unregister_type(&my_dummy_type);
225 
226  amxc_var_clean(&myvar);
227  closelog();
228 }
amxc_var_log
int amxc_var_log(const amxc_var_t *const var)
Logs the content of the variant in a human readable manner to syslog.
Definition: amxc_variant_dump.c:348

◆ test_amxc_variant_log_null()

void test_amxc_variant_log_null ( UNUSED void **  state)

Definition at line 274 of file test_amxc_variant_dump.c.

274  {
275  amxc_var_log(NULL);
276 }

Variable Documentation

◆ my_dummy_type

amxc_var_type_t my_dummy_type
static
Initial value:
=
{
.init = NULL,
.del = NULL,
.copy = NULL,
.convert_from = NULL,
.convert_to = NULL,
.compare = NULL,
.name = "my_dummy_type_t"
}

Definition at line 76 of file test_amxc_variant_dump.c.