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

Go to the source code of this file.

Functions

void test_variant_htable_get_key (UNUSED void **state)
 
void test_variant_htable_set_key (UNUSED void **state)
 

Function Documentation

◆ test_variant_htable_get_key()

void test_variant_htable_get_key ( UNUSED void **  state)

Definition at line 76 of file test_2_key_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, "Key1:Hello,Key2:world,Key3:and,Key4:anyone,Key5:else,Key6:in,Key7:the,Key8:universe");
85  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_HTABLE), 0);
86  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_HTABLE);
87  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
88 
89  key_part = amxc_var_get_key(&var, "Key7", AMXC_VAR_FLAG_COPY);
90  assert_int_equal(amxc_var_type_of(key_part), AMXC_VAR_ID_CSTRING);
91  assert_string_equal(key_part->data.s, "the");
92  amxc_var_delete(&key_part);
93  assert_ptr_equal(key_part, NULL);
94 
95  key_part_const = amxc_var_get_key(&var, "Key6", AMXC_VAR_FLAG_DEFAULT);
96  assert_int_equal(amxc_var_type_of(key_part_const), AMXC_VAR_ID_CSTRING);
97  assert_string_equal(key_part_const->data.s, "in");
98 
99  key_part = amxc_var_get_key(&var, NULL, AMXC_VAR_FLAG_COPY);
100  assert_ptr_equal(key_part, NULL);
101 
102  key_part = amxc_var_get_key(&var, "", AMXC_VAR_FLAG_DEFAULT);
103  assert_ptr_equal(key_part, NULL);
104 
105  key_part = amxc_var_get_key(&var, "non-existing-key", AMXC_VAR_FLAG_COPY);
106  assert_ptr_equal(key_part, AMXC_VAR_ID_NULL);
107 
108  amxc_var_set_type(&var, AMXC_VAR_ID_BOOL);
109  key_part = amxc_var_get_key(&var, "key7", AMXC_VAR_FLAG_COPY);
110  assert_ptr_equal(key_part, AMXC_VAR_ID_NULL);
111 
112  amxc_var_clean(&string);
113  amxc_var_clean(&var);
114 }
cstring_t
#define cstring_t
Convenience macro.
Definition: amxc_variant.h:584
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_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_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_BOOL
#define AMXC_VAR_ID_BOOL
Boolean variant id.
Definition: amxc_variant.h:200
AMXC_VAR_ID_HTABLE
#define AMXC_VAR_ID_HTABLE
Ambiorix Hash Table variant id.
Definition: amxc_variant.h:212
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_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
#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_var
The variant struct definition.
Definition: amxc_variant.h:861
_amxc_var::data
void * data
Definition: amxc_variant.h:883
var
static amxc_var_t * var
Definition: test_issue_58.c:77

◆ test_variant_htable_set_key()

void test_variant_htable_set_key ( UNUSED void **  state)

Definition at line 116 of file test_2_key_cb_func.c.

116  {
117  amxc_var_t var;
118  amxc_var_t string;
119  amxc_var_t* key_part = NULL;
120  amxc_var_t* key_part_copy = NULL;
121 
122  amxc_var_init(&var);
123  amxc_var_init(&string);
124  amxc_var_set(cstring_t, &string, "Key1:Hello,Key2:world,Key3:and,Key4:anyone,Key5:else,Key6:in,Key7:the,Key8:universe");
125  assert_int_equal(amxc_var_convert(&var, &string, AMXC_VAR_ID_HTABLE), 0);
126 
127  assert_int_equal(amxc_var_type_of(&var), AMXC_VAR_ID_HTABLE);
128  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
129 
130  assert_int_equal(amxc_var_new(&key_part), 0);
131  amxc_var_set(cstring_t, key_part, "some text");
132  assert_int_equal(amxc_var_set_key(&var, "Key8", key_part, AMXC_VAR_FLAG_COPY | AMXC_VAR_FLAG_UPDATE), 0);
133  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
134 
135  assert_int_equal(amxc_var_set_key(&var, "Key7", key_part, AMXC_VAR_FLAG_UPDATE), 0);
136  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
137 
138  key_part_copy = amxc_var_get_key(&var, "Key8", AMXC_VAR_FLAG_COPY);
139  assert_int_equal(amxc_var_type_of(key_part), AMXC_VAR_ID_CSTRING);
140  assert_string_equal(key_part_copy->data.s, "some text");
141  amxc_var_delete(&key_part_copy);
142  assert_int_equal(amxc_htable_size(&var.data.vm), 8);
143 
144  key_part_copy = amxc_var_get_key(&var, "Key7", AMXC_VAR_FLAG_DEFAULT);
145  assert_int_equal(amxc_var_type_of(key_part_copy), AMXC_VAR_ID_CSTRING);
146  assert_string_equal(key_part_copy->data.s, "some text");
147  assert_ptr_equal(key_part, key_part_copy);
148 
149  assert_int_equal(amxc_var_new(&key_part), 0);
150  amxc_var_set(uint64_t, key_part, 123);
151  assert_int_equal(amxc_var_set_key(&var, "Key9", key_part, AMXC_VAR_FLAG_COPY), 0);
152  assert_int_equal(amxc_htable_size(&var.data.vm), 9);
153  amxc_var_delete(&key_part);
154  assert_int_equal(amxc_htable_size(&var.data.vm), 9);
155 
156  assert_int_equal(amxc_var_new(&key_part), 0);
157  amxc_var_set(uint64_t, key_part, 456);
158  assert_int_equal(amxc_var_set_key(&var, "Key10", key_part, AMXC_VAR_FLAG_DEFAULT), 0);
159  assert_int_equal(amxc_htable_size(&var.data.vm), 10);
160  amxc_var_delete(&key_part);
161  assert_int_equal(amxc_htable_size(&var.data.vm), 9);
162 
163  assert_int_equal(amxc_var_new(&key_part), 0);
164  amxc_var_set(uint64_t, key_part, 456);
165  assert_int_equal(amxc_var_set_key(&var, "Key10", key_part, AMXC_VAR_FLAG_DEFAULT), 0);
166  assert_int_equal(amxc_htable_size(&var.data.vm), 10);
167 
168  key_part_copy = amxc_var_get_key(&var, "Key9", AMXC_VAR_FLAG_COPY);
169  assert_int_equal(amxc_var_type_of(key_part_copy), AMXC_VAR_ID_UINT64);
170  assert_int_equal(key_part_copy->data.ui64, 123);
171  amxc_var_delete(&key_part_copy);
172 
173  key_part_copy = amxc_var_get_key(&var, "Key9", AMXC_VAR_FLAG_DEFAULT);
174  assert_int_equal(amxc_htable_size(&var.data.vm), 10);
175  amxc_var_delete(&key_part_copy);
176  assert_int_equal(amxc_htable_size(&var.data.vm), 9);
177 
178  assert_int_equal(amxc_var_new(&key_part), 0);
179  amxc_var_set(uint64_t, key_part, 123);
180  assert_int_equal(amxc_var_set_key(&var, "Key9", key_part, AMXC_VAR_FLAG_COPY), 0);
181 
182  assert_int_not_equal(amxc_var_set_key(&var, "Key8", NULL, AMXC_VAR_FLAG_COPY), 0);
183  assert_int_not_equal(amxc_var_set_key(&var, "", key_part, AMXC_VAR_FLAG_COPY), 0);
184  assert_int_not_equal(amxc_var_set_key(&var, NULL, key_part, AMXC_VAR_FLAG_COPY), 0);
185  assert_int_not_equal(amxc_var_set_key(NULL, "Key8", key_part, AMXC_VAR_FLAG_COPY), 0);
186 
187  assert_int_not_equal(amxc_var_set_key(&var, "Key8", NULL, AMXC_VAR_FLAG_DEFAULT), 0);
188  assert_int_not_equal(amxc_var_set_key(&var, "", key_part, AMXC_VAR_FLAG_DEFAULT), 0);
189  assert_int_not_equal(amxc_var_set_key(&var, NULL, key_part, AMXC_VAR_FLAG_DEFAULT), 0);
190  assert_int_not_equal(amxc_var_set_key(NULL, "Key8", key_part, AMXC_VAR_FLAG_DEFAULT), 0);
191 
192  amxc_var_set_type(&var, AMXC_VAR_ID_BOOL);
193  assert_int_not_equal(amxc_var_set_key(&var, "Key8", key_part, AMXC_VAR_FLAG_COPY), 0);
194 
195  amxc_var_delete(&key_part);
196  amxc_var_clean(&string);
197  amxc_var_clean(&var);
198 }
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_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_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