libamxc  1.10.3
C Generic Data Containers
Functions | Variables
test_amxc_variant.c File Reference
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <amxc/amxc_variant.h>
#include <amxc_variant_priv.h>
#include "test_amxc_variant.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

int amxc_var_init_success (amxc_var_t *const var)
 
int amxc_var_init_fail (amxc_var_t *const var)
 
void amxc_var_del (amxc_var_t *const var)
 
int amxc_var_copy_success (amxc_var_t *const dst, const amxc_var_t *const src)
 
int amxc_var_copy_fail (amxc_var_t *const dest, const amxc_var_t *const src)
 
int amxc_var_move_fail (amxc_var_t *const dest, amxc_var_t *const src)
 
int amxc_var_convert_success (amxc_var_t *const dest, const amxc_var_t *const src)
 
int amxc_var_convert_fail (amxc_var_t *const dest, const amxc_var_t *const src)
 
int amxc_var_compare_success (const amxc_var_t *const var1, const amxc_var_t *const var2, int *const result)
 
int amxc_var_compare_fail (const amxc_var_t *const var1, const amxc_var_t *const var2, int *const result)
 
int dummy4_convert_to (amxc_var_t *const dest, const amxc_var_t *const src)
 
void free_variant_htable (const char *key, amxc_htable_it_t *it)
 
void free_variant_llist (amxc_llist_it_t *it)
 
int amxc_var_init_success (UNUSED amxc_var_t *const var)
 
int amxc_var_init_fail (UNUSED amxc_var_t *const var)
 
void amxc_var_del (UNUSED amxc_var_t *const var)
 
int amxc_var_copy_fail (UNUSED amxc_var_t *const dest, UNUSED const amxc_var_t *const src)
 
int amxc_var_move_fail (UNUSED amxc_var_t *const dest, UNUSED amxc_var_t *const src)
 
int amxc_var_convert_fail (UNUSED amxc_var_t *const dest, UNUSED const amxc_var_t *const src)
 
int amxc_var_compare_fail (UNUSED const amxc_var_t *const var1, UNUSED const amxc_var_t *const var2, UNUSED int *const result)
 
static amxc_var_t * amxc_var_test_get_key (UNUSED const amxc_var_t *const src, const char *const key, int flags)
 
static int amxc_var_test_set_key (UNUSED amxc_var_t *const dest, UNUSED amxc_var_t *const src, UNUSED const char *const key, UNUSED int flags)
 
static amxc_var_t * amxc_var_test_get_index (UNUSED const amxc_var_t *const src, const int64_t index, int flags)
 
static int amxc_var_test_set_index (UNUSED amxc_var_t *const dest, UNUSED amxc_var_t *const src, UNUSED const int64_t index, UNUSED int flags)
 
void test_amxc_var_new_delete (UNUSED void **state)
 
void test_amxc_var_init_clean (UNUSED void **state)
 
void test_amxc_var_set_type (UNUSED void **state)
 
void test_amxc_var_copy (UNUSED void **state)
 
void test_amxc_var_convert (UNUSED void **state)
 
void test_amxc_var_compare (UNUSED void **state)
 
void free_variant_htable (UNUSED const char *key, amxc_htable_it_t *it)
 
void test_amxc_var_type_of (UNUSED void **state)
 
void test_amxc_var_get_set_key (UNUSED void **state)
 
void test_amxc_var_add_new_key (UNUSED void **state)
 
void test_amxc_var_add_new (UNUSED void **state)
 
void test_amxc_var_get_path (UNUSED void **state)
 
void test_amxc_var_set_path (UNUSED void **state)
 
void test_amxc_var_push_take_amxc_string (UNUSED void **state)
 
void test_amxc_var_move (UNUSED void **state)
 
void test_amxc_var_take_it (UNUSED void **state)
 

Variables

static amxc_var_t test_var
 
static amxc_var_type_t dummy1
 
static amxc_var_type_t dummy2
 
static amxc_var_type_t dummy3
 

Function Documentation

◆ amxc_var_compare_fail() [1/2]

int amxc_var_compare_fail ( const amxc_var_t *const  var1,
const amxc_var_t *const  var2,
int *const  result 
)

◆ amxc_var_compare_fail() [2/2]

int amxc_var_compare_fail ( UNUSED const amxc_var_t *const  var1,
UNUSED const amxc_var_t *const  var2,
UNUSED int *const  result 
)

Definition at line 146 of file test_amxc_variant.c.

148  {
149  return -1;
150 }

◆ amxc_var_compare_success()

int amxc_var_compare_success ( const amxc_var_t *const  var1,
const amxc_var_t *const  var2,
int *const  result 
)

Definition at line 133 of file test_amxc_variant.c.

135  {
136  if(var1->data.ui32 < var2->data.ui32) {
137  *result = -1;
138  } else if(var1->data.ui32 > var2->data.ui32) {
139  *result = 1;
140  } else {
141  *result = 0;
142  }
143  return 0;
144 }
_amxc_var::data
void * data
Definition: amxc_variant.h:883

◆ amxc_var_convert_fail() [1/2]

int amxc_var_convert_fail ( amxc_var_t *const  dest,
const amxc_var_t *const  src 
)

◆ amxc_var_convert_fail() [2/2]

int amxc_var_convert_fail ( UNUSED amxc_var_t *const  dest,
UNUSED const amxc_var_t *const  src 
)

Definition at line 128 of file test_amxc_variant.c.

129  {
130  return -1;
131 }

◆ amxc_var_convert_success()

int amxc_var_convert_success ( amxc_var_t *const  dest,
const amxc_var_t *const  src 
)

Definition at line 117 of file test_amxc_variant.c.

118  {
119 
120  if(dest->type_id != src->type_id) {
121  dest->data.ui32 = src->data.ui32 >> 1;
122  } else {
123  dest->data.ui32 = src->data.ui32;
124  }
125  return 0;
126 }
_amxc_var::type_id
uint32_t type_id
Definition: amxc_variant.h:864

◆ amxc_var_copy_fail() [1/2]

int amxc_var_copy_fail ( amxc_var_t *const  dest,
const amxc_var_t *const  src 
)

◆ amxc_var_copy_fail() [2/2]

int amxc_var_copy_fail ( UNUSED amxc_var_t *const  dest,
UNUSED const amxc_var_t *const  src 
)

Definition at line 107 of file test_amxc_variant.c.

108  {
109  return -1;
110 }

◆ amxc_var_copy_success()

int amxc_var_copy_success ( amxc_var_t *const  dst,
const amxc_var_t *const  src 
)

Definition at line 101 of file test_amxc_variant.c.

101  {
102  dest->type_id = src->type_id;
103  dest->data.ui32 = src->data.ui32;
104  return 0;
105 }

◆ amxc_var_del() [1/2]

void amxc_var_del ( amxc_var_t *const  var)

◆ amxc_var_del() [2/2]

void amxc_var_del ( UNUSED amxc_var_t *const  var)

Definition at line 97 of file test_amxc_variant.c.

97  {
98  return;
99 }

◆ amxc_var_init_fail() [1/2]

int amxc_var_init_fail ( amxc_var_t *const  var)

◆ amxc_var_init_fail() [2/2]

int amxc_var_init_fail ( UNUSED amxc_var_t *const  var)

Definition at line 93 of file test_amxc_variant.c.

93  {
94  return -1;
95 }

◆ amxc_var_init_success() [1/2]

int amxc_var_init_success ( amxc_var_t *const  var)

◆ amxc_var_init_success() [2/2]

int amxc_var_init_success ( UNUSED amxc_var_t *const  var)

Definition at line 89 of file test_amxc_variant.c.

89  {
90  return 0;
91 }

◆ amxc_var_move_fail() [1/2]

int amxc_var_move_fail ( amxc_var_t *const  dest,
amxc_var_t *const  src 
)

◆ amxc_var_move_fail() [2/2]

int amxc_var_move_fail ( UNUSED amxc_var_t *const  dest,
UNUSED amxc_var_t *const  src 
)

Definition at line 112 of file test_amxc_variant.c.

113  {
114  return -1;
115 }

◆ amxc_var_test_get_index()

static amxc_var_t* amxc_var_test_get_index ( UNUSED const amxc_var_t *const  src,
const int64_t  index,
int  flags 
)
static

Definition at line 216 of file test_amxc_variant.c.

218  {
219 
220  if((index > 5) && (index != UINT32_MAX)) {
221  return NULL;
222  }
223 
224  if((flags & AMXC_VAR_FLAG_COPY) == AMXC_VAR_FLAG_COPY) {
225  amxc_var_t* copy_var = NULL;
226  amxc_var_new(&copy_var);
227  amxc_var_copy(copy_var, &test_var);
228  return copy_var;
229  }
230 
231  return &test_var;
232 }
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_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_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
The variant struct definition.
Definition: amxc_variant.h:861
test_var
static amxc_var_t test_var
Definition: test_amxc_variant.c:186

◆ amxc_var_test_get_key()

static amxc_var_t* amxc_var_test_get_key ( UNUSED const amxc_var_t *const  src,
const char *const  key,
int  flags 
)
static

Definition at line 188 of file test_amxc_variant.c.

190  {
191  if(strcmp(key, "valid") != 0) {
192  return NULL;
193  }
194 
195  if((flags & AMXC_VAR_FLAG_COPY) == AMXC_VAR_FLAG_COPY) {
196  amxc_var_t* copy_var = NULL;
197  amxc_var_new(&copy_var);
198  amxc_var_copy(copy_var, &test_var);
199  return copy_var;
200  }
201 
202  return &test_var;
203 }

◆ amxc_var_test_set_index()

static int amxc_var_test_set_index ( UNUSED amxc_var_t *const  dest,
UNUSED amxc_var_t *const  src,
UNUSED const int64_t  index,
UNUSED int  flags 
)
static

Definition at line 234 of file test_amxc_variant.c.

237  {
238  if((index > 5) && (index != UINT32_MAX)) {
239  return -1;
240  }
241 
242  return 0;
243 }

◆ amxc_var_test_set_key()

static int amxc_var_test_set_key ( UNUSED amxc_var_t *const  dest,
UNUSED amxc_var_t *const  src,
UNUSED const char *const  key,
UNUSED int  flags 
)
static

Definition at line 205 of file test_amxc_variant.c.

208  {
209  if(strcmp(key, "valid") != 0) {
210  return -1;
211  }
212 
213  return 0;
214 }

◆ dummy4_convert_to()

int dummy4_convert_to ( amxc_var_t *const  dest,
const amxc_var_t *const  src 
)

Definition at line 152 of file test_amxc_variant.c.

153  {
154  int retval = -1;
155  amxc_var_convert_fn_t convfn[AMXC_VAR_ID_CUSTOM_BASE] = {
156  amxc_var_default_convert_to_null,
157  NULL,
158  NULL,
159  NULL,
160  NULL,
161  NULL,
162  NULL,
163  NULL,
164  NULL,
165  NULL,
166  NULL,
167  NULL,
168  NULL,
169  amxc_var_default_convert_to_list,
170  amxc_var_default_convert_to_htable,
171  NULL,
172  };
173 
174  if(dest->type_id >= AMXC_VAR_ID_CUSTOM_BASE) {
175  goto exit;
176  }
177 
178  if(convfn[dest->type_id] != NULL) {
179  retval = convfn[dest->type_id](dest, src);
180  }
181 
182 exit:
183  return retval;
184 }
amxc_var_default_convert_to_null
int PRIVATE amxc_var_default_convert_to_null(amxc_var_t *const dest, const amxc_var_t *const src)
amxc_var_default_convert_to_htable
int PRIVATE amxc_var_default_convert_to_htable(amxc_var_t *const dest, const amxc_var_t *const src)
Definition: amxc_variant.c:174
amxc_var_default_convert_to_list
int PRIVATE amxc_var_default_convert_to_list(amxc_var_t *const dest, const amxc_var_t *const src)
Definition: amxc_variant.c:155
AMXC_VAR_ID_CUSTOM_BASE
#define AMXC_VAR_ID_CUSTOM_BASE
Base variant id for custom variants.
Definition: amxc_variant.h:257
amxc_var_convert_fn_t
int(* amxc_var_convert_fn_t)(amxc_var_t *const dest, const amxc_var_t *const src)
Variant type callback function prototype for dynamically converting one type to another.
Definition: amxc_variant_type.h:118

◆ free_variant_htable() [1/2]

void free_variant_htable ( const char *  key,
amxc_htable_it_t *  it 
)

◆ free_variant_htable() [2/2]

void free_variant_htable ( UNUSED const char *  key,
amxc_htable_it_t *  it 
)

Definition at line 521 of file test_amxc_variant.c.

521  {
522  amxc_var_t* var = amxc_htable_it_get_data(it, amxc_var_t, hit);
523  amxc_var_delete(&var);
524 }
amxc_htable_it_get_data
#define amxc_htable_it_get_data(it, type, member)
Gets the data pointer from an hash table iterator.
Definition: amxc_htable.h:87
amxc_var_delete
void amxc_var_delete(amxc_var_t **var)
Frees the previously allocated variant.
Definition: amxc_variant.c:207
it
static amxc_htable_it_t it[2000]
Definition: test_amxc_htable.c:69
var
static amxc_var_t * var
Definition: test_issue_58.c:77

◆ free_variant_llist()

void free_variant_llist ( amxc_llist_it_t *  it)

Definition at line 526 of file test_amxc_variant.c.

526  {
527  amxc_var_t* var = amxc_llist_it_get_data(it, amxc_var_t, lit);
528  amxc_var_delete(&var);
529 }
amxc_llist_it_get_data
#define amxc_llist_it_get_data(it, type, member)
Gets the data pointer from a linked list iterator.
Definition: amxc_llist.h:238

◆ test_amxc_var_add_new()

void test_amxc_var_add_new ( UNUSED void **  state)

Definition at line 595 of file test_amxc_variant.c.

595  {
596  amxc_var_t var1;
597  amxc_var_t var2;
598  amxc_var_t* subvar = NULL;
599 
600  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE);
601  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
602  assert_int_equal(amxc_var_init(&var1), 0);
603  assert_int_equal(amxc_var_init(&test_var), 0);
604  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE), 0);
605 
606  subvar = amxc_var_add_new(&var1);
607  assert_ptr_not_equal(subvar, NULL);
608  assert_ptr_not_equal(subvar, &test_var);
609  amxc_var_delete(&subvar);
610 
611  assert_ptr_equal(amxc_var_add_new(NULL), NULL);
612 
613  assert_int_equal(amxc_var_init(&var2), 0);
614  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
615  assert_ptr_equal(amxc_var_add_new(&var2), NULL);
616 
617  amxc_var_remove_type(&dummy2);
618  amxc_var_remove_type(&dummy3);
619 }
amxc_var_add_type
uint32_t PRIVATE amxc_var_add_type(amxc_var_type_t *const type, const uint32_t index)
Definition: amxc_variant_type.c:119
amxc_var_remove_type
int PRIVATE amxc_var_remove_type(amxc_var_type_t *const type)
Definition: amxc_variant_type.c:157
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
dummy3
static amxc_var_type_t dummy3
Definition: test_amxc_variant.c:274
dummy2
static amxc_var_type_t dummy2
Definition: test_amxc_variant.c:262

◆ test_amxc_var_add_new_key()

void test_amxc_var_add_new_key ( UNUSED void **  state)

Definition at line 567 of file test_amxc_variant.c.

567  {
568  amxc_var_t var1;
569  amxc_var_t var2;
570  amxc_var_t* subvar = NULL;
571 
572  assert_int_equal(amxc_var_add_type(&dummy3, AMXC_VAR_ID_UINT16), AMXC_VAR_ID_UINT16);
573  assert_int_equal(amxc_var_add_type(&dummy2, AMXC_VAR_ID_UINT32), AMXC_VAR_ID_UINT32);
574  assert_int_equal(amxc_var_init(&var1), 0);
575  assert_int_equal(amxc_var_init(&test_var), 0);
576  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_UINT16), 0);
577 
578  subvar = amxc_var_add_new_key(&var1, "valid");
579  assert_ptr_not_equal(subvar, NULL);
580  assert_ptr_not_equal(subvar, &test_var);
581  amxc_var_delete(&subvar);
582 
583  assert_ptr_equal(amxc_var_add_new_key(NULL, "valid"), NULL);
584  assert_ptr_equal(amxc_var_add_new_key(&var1, NULL), NULL);
585  assert_ptr_equal(amxc_var_add_new_key(&var1, ""), NULL);
586 
587  assert_int_equal(amxc_var_init(&var2), 0);
588  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_UINT32), 0);
589  assert_ptr_equal(amxc_var_add_new_key(&var2, "valid"), NULL);
590 
591  amxc_var_remove_type(&dummy2);
592  amxc_var_remove_type(&dummy3);
593 }
AMXC_VAR_ID_UINT32
#define AMXC_VAR_ID_UINT32
Unsigned 32 bit integer variant id.
Definition: amxc_variant.h:176
AMXC_VAR_ID_UINT16
#define AMXC_VAR_ID_UINT16
Unsigned 16 bit integer variant id.
Definition: amxc_variant.h:170
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

◆ test_amxc_var_compare()

void test_amxc_var_compare ( UNUSED void **  state)

Definition at line 461 of file test_amxc_variant.c.

461  {
462  amxc_var_t var1;
463  amxc_var_t var2;
464  amxc_var_t var3;
465  int result = 0;
466  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
467  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
468  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
469 
470  assert_int_equal(amxc_var_init(&var1), 0);
471  assert_int_equal(amxc_var_init(&var2), 0);
472  assert_int_equal(amxc_var_init(&var3), 0);
473  assert_int_not_equal(amxc_var_compare(NULL, NULL, NULL), 0);
474  assert_int_equal(amxc_var_compare(NULL, NULL, &result), 0);
475  assert_int_equal(result, 0);
476  assert_int_equal(amxc_var_compare(&var1, NULL, &result), 0);
477  assert_int_equal(result, 1);
478  assert_int_equal(amxc_var_compare(NULL, &var1, &result), 0);
479  assert_int_equal(result, -1);
480  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
481  assert_int_equal(result, 0);
482 
483  var1.data.ui32 = 100;
484  var2.data.ui32 = 100;
485  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
486  assert_int_equal(result, 0);
487  var2.data.ui32 = 50;
488  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
489  assert_int_equal(result, 1);
490  var2.data.ui32 = 200;
491  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
492  assert_int_equal(result, -1);
493 
494  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
495  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE), 0);
496  assert_int_equal(amxc_var_set_type(&var3, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
497 
498  var1.data.ui32 = 100;
499  var2.data.ui32 = 100;
500  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
501  assert_int_equal(result, 1); // conversion var2 to var1
502  var1.data.ui32 = 100;
503  var2.data.ui32 = 100;
504  var3.data.ui32 = 100;
505  // should fail because compare of var2 always fails
506  assert_int_not_equal(amxc_var_compare(&var2, &var1, &result), 0);
507  assert_int_equal(amxc_var_compare(&var3, &var1, &result), 0);
508  assert_int_equal(result, -1); // conversion var3 to var1
509  assert_int_equal(amxc_var_compare(&var1, &var1, &result), 0);
510  assert_int_equal(result, 0);
511  assert_int_not_equal(amxc_var_compare(&var2, &var2, &result), 0);
512 
513  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
514  assert_int_not_equal(amxc_var_compare(&var1, &var2, &result), 0);
515  assert_int_not_equal(amxc_var_compare(&var2, &var1, &result), 0);
516 
517  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
518  assert_int_equal(amxc_var_remove_type(&dummy3), 0);
519 }
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
dummy1
static amxc_var_type_t dummy1
Definition: test_amxc_variant.c:246

◆ test_amxc_var_convert()

void test_amxc_var_convert ( UNUSED void **  state)

Definition at line 405 of file test_amxc_variant.c.

405  {
406  amxc_var_t var1;
407  amxc_var_t var2;
408  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
409  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
410  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
411 
412  assert_int_equal(amxc_var_init(&var1), 0);
413  var1.data.ui32 = 100;
414  assert_int_equal(amxc_var_init(&var2), 0);
415  assert_int_not_equal(amxc_var_convert(NULL, NULL, 0), 0);
416  assert_int_not_equal(amxc_var_convert(&var1, NULL, 0), 0);
417  assert_int_not_equal(amxc_var_convert(&var1, &var2, AMXC_VAR_ID_CUSTOM_BASE + 2), 0);
418 
419  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
420  var1.data.ui32 = 100;
421  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE), 0);
422  var2.data.ui32 = 999;
423 
424  assert_int_equal(amxc_var_convert(&var2, &var1, 0), 0);
425  assert_int_equal(var2.type_id, 0);
426  assert_ptr_equal(var2.data.ui32, 50);
427  var2.data.ui32 = 999;
428 
429  assert_int_not_equal(amxc_var_convert(&var2, &var1, AMXC_VAR_ID_CUSTOM_BASE), 0);
430  assert_int_equal(var2.type_id, 0);
431  assert_ptr_equal(var2.data.data, NULL);
432 
433  assert_int_not_equal(amxc_var_convert(&var2, &var1, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
434  assert_int_equal(var2.type_id, 0);
435  assert_ptr_equal(var2.data.data, NULL);
436 
437  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
438  var1.data.ui32 = 100;
439  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
440  assert_int_not_equal(amxc_var_convert(&var2, &var1, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
441  assert_int_equal(var2.type_id, 0);
442  assert_ptr_equal(var2.data.data, NULL);
443  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
444 
445  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
446  var1.data.ui32 = 100;
447  var2.data.ui32 = 500;
448  assert_int_equal(amxc_var_convert(&var1, &var2, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
449  assert_int_equal(var1.type_id, AMXC_VAR_ID_CUSTOM_BASE + 1);
450  assert_int_equal(var1.data.ui32, 250);
451 
452  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
453  assert_int_equal(amxc_var_set_type(&var2, 0), 0);
454  assert_int_equal(amxc_var_convert(&var1, &var2, 0), 0);
455 
456  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
457  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
458  assert_int_equal(amxc_var_remove_type(&dummy3), 0);
459 }
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_amxc_var_copy()

void test_amxc_var_copy ( UNUSED void **  state)

Definition at line 366 of file test_amxc_variant.c.

366  {
367  amxc_var_t var1;
368  amxc_var_t var2;
369  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
370  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
371  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
372 
373  assert_int_equal(amxc_var_init(&var1), 0);
374  var1.data.ui32 = 100;
375  assert_int_equal(amxc_var_init(&var2), 0);
376  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE), 0);
377  assert_int_equal(var2.type_id, AMXC_VAR_ID_CUSTOM_BASE);
378  assert_int_equal(var2.data.ui32, 0);
379 
380  assert_int_not_equal(amxc_var_copy(NULL, NULL), 0);
381  assert_int_not_equal(amxc_var_copy(&var1, NULL), 0);
382  assert_true(amxc_var_is_null(&var1));
383 
384  assert_int_equal(amxc_var_copy(&var2, &var1), 0);
385  assert_int_equal(var2.type_id, 0);
386  assert_int_equal(var2.data.ui32, 100);
387 
388  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
389  assert_int_not_equal(amxc_var_copy(&var2, &var1), 0);
390  assert_true(amxc_var_is_null(&var2));
391 
392  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
393  var1.data.ui32 = 100;
394  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
395  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE), 0);
396  assert_int_equal(amxc_var_copy(&var2, &var1), -1);
397  assert_true(amxc_var_is_null(&var2));
398  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
399 
400  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
401  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
402  assert_int_equal(amxc_var_remove_type(&dummy3), 0);
403 }
amxc_var_is_null
AMXC_INLINE bool amxc_var_is_null(const amxc_var_t *const var)
Checks if the given variant is of the "null" type.
Definition: amxc_variant.h:1594

◆ test_amxc_var_get_path()

void test_amxc_var_get_path ( UNUSED void **  state)

Definition at line 621 of file test_amxc_variant.c.

621  {
622  amxc_var_t var1;
623  amxc_var_t* subvar = NULL;
624 
625  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE);
626  assert_int_equal(amxc_var_add_type(&dummy1, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
627  assert_int_equal(amxc_var_init(&var1), 0);
628  assert_int_equal(amxc_var_init(&test_var), 0);
629  assert_int_equal(amxc_var_set_type(&test_var, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
630  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE), 0);
631 
632  subvar = amxc_var_get_path(&var1, "valid.1.valid.2.valid.3", AMXC_VAR_FLAG_DEFAULT);
633  assert_ptr_not_equal(subvar, NULL);
634  assert_ptr_equal(subvar, &test_var);
635 
636  subvar = amxc_var_get_pathf(&var1, AMXC_VAR_FLAG_DEFAULT, "valid.%d.valid.2.valid.3", 1);
637  assert_ptr_not_equal(subvar, NULL);
638  assert_ptr_equal(subvar, &test_var);
639 
640  subvar = amxc_var_get_pathf(&var1, AMXC_VAR_FLAG_DEFAULT, "%s.%d.valid.%d.valid.3", "valid", 1, 2);
641  assert_ptr_not_equal(subvar, NULL);
642  assert_ptr_equal(subvar, &test_var);
643 
644  subvar = amxc_var_get_path(&var1, "valid.1.valid.99.valid.3", AMXC_VAR_FLAG_DEFAULT);
645  assert_ptr_equal(subvar, NULL);
646  subvar = amxc_var_get_path(&var1, "valid.1.valid.99.valid.3", AMXC_VAR_FLAG_COPY);
647  assert_ptr_equal(subvar, NULL);
648 
649  subvar = amxc_var_get_path(&var1, "valid.1.valid.2.notexisting.3", AMXC_VAR_FLAG_DEFAULT);
650  assert_ptr_equal(subvar, NULL);
651  subvar = amxc_var_get_path(&var1, "valid.1.valid.2.notexisting.3", AMXC_VAR_FLAG_COPY);
652  assert_ptr_equal(subvar, NULL);
653 
654  subvar = amxc_var_get_path(&var1, "valid.1.valid.2.valid.3", AMXC_VAR_FLAG_COPY);
655  assert_ptr_not_equal(subvar, NULL);
656  assert_ptr_not_equal(subvar, &test_var);
657  amxc_var_delete(&subvar);
658 
659  subvar = amxc_var_get_path(NULL, "valid.1.valid.2.valid.3", AMXC_VAR_FLAG_COPY);
660  assert_ptr_equal(subvar, NULL);
661  subvar = amxc_var_get_path(&var1, NULL, AMXC_VAR_FLAG_COPY);
662  assert_ptr_equal(subvar, NULL);
663  subvar = amxc_var_get_path(&var1, "", AMXC_VAR_FLAG_COPY);
664  assert_ptr_equal(subvar, NULL);
665  subvar = amxc_var_get_path(&test_var, "", AMXC_VAR_FLAG_DEFAULT);
666  assert_ptr_not_equal(subvar, NULL);
667 
668  subvar = amxc_var_get_pathf(NULL, AMXC_VAR_FLAG_COPY, "valid.1.valid.2.valid.3");
669  assert_ptr_equal(subvar, NULL);
670  subvar = amxc_var_get_pathf(NULL, AMXC_VAR_FLAG_COPY, NULL);
671  assert_ptr_equal(subvar, NULL);
672 
673  amxc_var_remove_type(&dummy3);
674  amxc_var_remove_type(&dummy1);
675 }
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_get_pathf
amxc_var_t * amxc_var_get_pathf(const amxc_var_t *const var, const int flags, const char *const fmt,...) __attribute__((format(printf
Retrieves the variant at the given path of a composite variant.
amxc_var_get_path
amxc_var_t * amxc_var_get_path(const amxc_var_t *const var, const char *const path, const int flags)
Retrieves the variant at the given path of a composite variant.
Definition: amxc_variant.c:573

◆ test_amxc_var_get_set_key()

void test_amxc_var_get_set_key ( UNUSED void **  state)

Definition at line 545 of file test_amxc_variant.c.

545  {
546  amxc_var_t var1;
547  amxc_var_t* subvar = NULL;
548 
549  assert_int_equal(amxc_var_add_type(&dummy3, AMXC_VAR_ID_NULL), AMXC_VAR_ID_NULL);
550  assert_int_equal(amxc_var_init(&var1), 0);
551  assert_int_equal(amxc_var_init(&test_var), 0);
552  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
553 
554  subvar = amxc_var_get_key(&var1, "valid", AMXC_VAR_FLAG_DEFAULT);
555  assert_ptr_equal(subvar, &test_var);
556  subvar = amxc_var_get_key(&var1, "valid", AMXC_VAR_FLAG_COPY);
557  assert_ptr_not_equal(subvar, NULL);
558  assert_ptr_not_equal(subvar, &test_var);
559  amxc_var_delete(&subvar);
560 
561  subvar = amxc_var_get_key(&var1, "not_valid", AMXC_VAR_FLAG_DEFAULT);
562  assert_ptr_equal(subvar, NULL);
563 
564  amxc_var_remove_type(&dummy3);
565 }
AMXC_VAR_ID_NULL
#define AMXC_VAR_ID_NULL
Null variant type id (aka void)
Definition: amxc_variant.h:128
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

◆ test_amxc_var_init_clean()

void test_amxc_var_init_clean ( UNUSED void **  state)

Definition at line 311 of file test_amxc_variant.c.

311  {
312  amxc_var_t var;
313  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
314  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
315 
316  assert_int_equal(amxc_var_init(NULL), -1);
317 
318  assert_int_equal(amxc_var_init(&var), 0);
319  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
320  assert_ptr_equal(var.data.data, NULL);
321  assert_ptr_equal(var.lit.llist, NULL);
322  assert_ptr_equal(var.hit.ait, NULL);
323 
324  amxc_var_clean(NULL);
325  amxc_var_clean(&var);
326 
327  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
328  amxc_var_clean(&var);
329 
330  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
331 }
amxc_var_clean
void amxc_var_clean(amxc_var_t *const var)
Clean-up and reset variant.
Definition: amxc_variant.c:237
_amxc_htable_it::ait
amxc_array_it_t * ait
Definition: amxc_htable.h:139
_amxc_llist_it::llist
struct _amxc_llist * llist
Definition: amxc_llist.h:220
_amxc_var::lit
amxc_llist_it_t lit
Definition: amxc_variant.h:862
_amxc_var::hit
amxc_htable_it_t hit
Definition: amxc_variant.h:863

◆ test_amxc_var_move()

void test_amxc_var_move ( UNUSED void **  state)

Definition at line 724 of file test_amxc_variant.c.

724  {
725  amxc_var_t src;
726  amxc_var_t dst;
727 
728  assert_int_equal(amxc_var_add_type(&dummy1, -1), AMXC_VAR_ID_CUSTOM_BASE);
729  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
730  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE + 2);
731  amxc_var_init(&src);
732  amxc_var_init(&dst);
733 
734  assert_int_equal(amxc_var_set_type(&src, AMXC_VAR_ID_CUSTOM_BASE), 0);
735  assert_int_equal(amxc_var_move(&dst, &src), 0);
736  assert_int_equal(amxc_var_type_of(&dst), AMXC_VAR_ID_CUSTOM_BASE);
737  assert_true(amxc_var_is_null(&src));
738 
739  assert_int_equal(amxc_var_set_type(&dst, AMXC_VAR_ID_CUSTOM_BASE), 0);
740  assert_int_equal(amxc_var_set_type(&src, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
741  assert_int_not_equal(amxc_var_move(&dst, &src), 0);
742  assert_int_equal(amxc_var_type_of(&src), AMXC_VAR_ID_CUSTOM_BASE + 1);
743  assert_true(amxc_var_is_null(&dst));
744 
745  assert_int_equal(amxc_var_set_type(&dst, AMXC_VAR_ID_CUSTOM_BASE), 0);
746  assert_int_equal(amxc_var_set_type(&src, AMXC_VAR_ID_CUSTOM_BASE + 2), 0);
747  assert_int_not_equal(amxc_var_move(&dst, &src), 0);
748  assert_int_equal(amxc_var_type_of(&src), AMXC_VAR_ID_CUSTOM_BASE + 2);
749  assert_true(amxc_var_is_null(&dst));
750 
751  amxc_var_clean(&src);
752  amxc_var_clean(&dst);
753 
754  assert_int_not_equal(amxc_var_move(&dst, NULL), 0);
755  assert_int_not_equal(amxc_var_move(NULL, &src), 0);
756 
757  amxc_var_remove_type(&dummy1);
758  amxc_var_remove_type(&dummy2);
759  amxc_var_remove_type(&dummy3);
760 }
amxc_var_move
int amxc_var_move(amxc_var_t *const dest, amxc_var_t *const src)
Moves the type and data from one variant (source) in another variant (destination).
Definition: amxc_variant.c:308
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

◆ test_amxc_var_new_delete()

void test_amxc_var_new_delete ( UNUSED void **  state)

Definition at line 290 of file test_amxc_variant.c.

290  {
291  amxc_var_t* var = NULL;
292  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
293  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
294 
295  assert_int_equal(amxc_var_new(NULL), -1);
296 
297  assert_int_equal(amxc_var_new(&var), 0);
298  assert_ptr_not_equal(var, NULL);
299  assert_int_equal(var->type_id, AMXC_VAR_ID_NULL);
300  assert_ptr_equal(var->data.data, NULL);
301  assert_ptr_equal(var->lit.llist, NULL);
302  assert_ptr_equal(var->hit.ait, NULL);
303 
304  amxc_var_delete(NULL);
305  amxc_var_delete(&var);
306 
307  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
308  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
309 }

◆ test_amxc_var_push_take_amxc_string()

void test_amxc_var_push_take_amxc_string ( UNUSED void **  state)

Definition at line 694 of file test_amxc_variant.c.

694  {
695  amxc_var_t var1;
696  amxc_string_t source;
697  amxc_string_t* string = NULL;
698 
699  assert_int_equal(amxc_string_init(&source, 0), 0);
700  assert_int_equal(amxc_string_append(&source, "This is a test string", 21), 0);
701  assert_int_equal(amxc_var_init(&var1), 0);
702  assert_int_equal(amxc_var_push_amxc_string_t(&var1, &source), 0);
703  assert_int_equal(amxc_var_type_of(&var1), AMXC_VAR_ID_CSTRING);
704  assert_int_equal(source.length, 0);
705  assert_int_equal(source.last_used, 0);
706  assert_ptr_equal(source.buffer, NULL);
707 
708  string = amxc_var_take_amxc_string_t(&var1);
709  assert_int_equal(amxc_var_type_of(&var1), AMXC_VAR_ID_NULL);
710  assert_ptr_not_equal(string, NULL);
711  assert_int_not_equal(string->length, 0);
712  assert_int_not_equal(string->last_used, 0);
713  assert_ptr_not_equal(string->buffer, NULL);
714  amxc_string_delete(&string);
715 
716  amxc_var_clean(&var1);
717  assert_ptr_equal(var1.data.s, NULL);
718  string = amxc_var_take_amxc_string_t(&var1);
719  assert_ptr_equal(string, NULL);
720 
721  amxc_string_clean(&source);
722 }
amxc_string_delete
void amxc_string_delete(amxc_string_t **string)
Frees the previously allocated string.
Definition: amxc_string.c:150
amxc_string_append
AMXC_INLINE int amxc_string_append(amxc_string_t *const string, const char *const text, const size_t length)
Appends text to the end of the current content of the string buffer.
Definition: amxc_string.h:920
amxc_string_init
int amxc_string_init(amxc_string_t *const string, const size_t length)
Initializes a string.
Definition: amxc_string.c:163
amxc_string_clean
void amxc_string_clean(amxc_string_t *const string)
Frees the string buffer and reset length attributes.
Definition: amxc_string.c:189
amxc_var_take_amxc_string_t
amxc_string_t * amxc_var_take_amxc_string_t(amxc_var_t *const var)
Takes a value from a variant.
Definition: amxc_variant.c:676
amxc_var_push_amxc_string_t
int amxc_var_push_amxc_string_t(amxc_var_t *const var, amxc_string_t *val)
Pushes a value in a variant.
Definition: amxc_variant.c:696
AMXC_VAR_ID_CSTRING
#define AMXC_VAR_ID_CSTRING
C-string variant id (aka char *), null terminated string.
Definition: amxc_variant.h:134
_amxc_string
The string structure.
Definition: amxc_string.h:103
_amxc_string::buffer
char * buffer
Definition: amxc_string.h:104
_amxc_string::last_used
size_t last_used
Definition: amxc_string.h:106
_amxc_string::length
size_t length
Definition: amxc_string.h:105

◆ test_amxc_var_set_path()

void test_amxc_var_set_path ( UNUSED void **  state)

Definition at line 677 of file test_amxc_variant.c.

677  {
678  amxc_var_t var1;
679  amxc_var_t var2;
680 
681  assert_int_equal(amxc_var_add_type(&dummy3, -1), AMXC_VAR_ID_CUSTOM_BASE);
682  assert_int_equal(amxc_var_add_type(&dummy1, -1), AMXC_VAR_ID_CUSTOM_BASE + 1);
683  assert_int_equal(amxc_var_init(&var1), 0);
684  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE), 0);
685  assert_int_equal(amxc_var_init(&var2), 0);
686  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
687 
688  assert_int_equal(amxc_var_set_path(&var1, "valid.1.valid.2.valid.3", &var2, AMXC_VAR_FLAG_DEFAULT | AMXC_VAR_FLAG_AUTO_ADD), 0);
689 
690  amxc_var_remove_type(&dummy3);
691  amxc_var_remove_type(&dummy1);
692 }
AMXC_VAR_FLAG_AUTO_ADD
#define AMXC_VAR_FLAG_AUTO_ADD
Add none existing variants to composite variants. This flag can be used with amxc_var_set_path and am...
Definition: amxc_variant.h:418
amxc_var_set_path
amxc_var_t int amxc_var_set_path(amxc_var_t *const var, const char *const path, amxc_var_t *data, const int flags)
Sets the variant at the given path of a composite variant.
Definition: amxc_variant.c:623

◆ test_amxc_var_set_type()

void test_amxc_var_set_type ( UNUSED void **  state)

Definition at line 333 of file test_amxc_variant.c.

333  {
334  amxc_var_t var;
335  assert_int_equal(amxc_var_add_type(&dummy1, 0), 0);
336  assert_int_equal(amxc_var_add_type(&dummy2, -1), AMXC_VAR_ID_CUSTOM_BASE);
337 
338  assert_int_equal(amxc_var_init(&var), 0);
339 
340  assert_int_equal(amxc_var_set_type(NULL, 0), -1);
341  assert_int_not_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
342  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE), 0);
343  assert_int_equal(var.type_id, AMXC_VAR_ID_CUSTOM_BASE);
344  assert_int_equal(var.data.data, NULL);
345 
346  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE), 0);
347  assert_int_equal(var.type_id, AMXC_VAR_ID_CUSTOM_BASE);
348  assert_int_equal(var.data.data, NULL);
349 
350  assert_int_not_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE + 1), 0);
351  assert_int_equal(var.type_id, AMXC_VAR_ID_CUSTOM_BASE);
352  assert_int_equal(var.data.data, NULL);
353 
354  assert_int_equal(amxc_var_set_type(&var, 0), 0);
355  assert_int_equal(var.type_id, 0);
356  assert_int_equal(var.data.data, NULL);
357 
358  dummy2.init = amxc_var_init_fail;
359  assert_int_not_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CUSTOM_BASE), 0);
360  dummy2.init = NULL;
361 
362  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
363  assert_int_equal(amxc_var_remove_type(&dummy2), 0);
364 }
_amxc_var_type::init
amxc_var_new_fn_t init
Definition: amxc_variant_type.h:212
amxc_var_init_fail
int amxc_var_init_fail(amxc_var_t *const var)

◆ test_amxc_var_take_it()

void test_amxc_var_take_it ( UNUSED void **  state)

Definition at line 762 of file test_amxc_variant.c.

762  {
763  amxc_var_take_it(NULL);
764 }
amxc_var_take_it
AMXC_INLINE void amxc_var_take_it(amxc_var_t *const var)
Removes the variant for a llist and/or a htable.
Definition: amxc_variant.h:1107

◆ test_amxc_var_type_of()

void test_amxc_var_type_of ( UNUSED void **  state)

Definition at line 531 of file test_amxc_variant.c.

531  {
532  amxc_var_t var1;
533 
534  assert_int_equal(amxc_var_add_type(&dummy1, AMXC_VAR_ID_NULL), AMXC_VAR_ID_NULL);
535  assert_int_equal(amxc_var_init(&var1), 0);
536  assert_int_equal(amxc_var_set_type(&var1, 0), 0);
537  assert_int_equal(amxc_var_type_of(&var1), AMXC_VAR_ID_NULL);
538  assert_true(amxc_var_type_of(NULL) == AMXC_VAR_ID_INVALID);
539  assert_ptr_equal(amxc_var_type_name_of(NULL), NULL);
540  assert_string_equal(amxc_var_type_name_of(&var1), "dummy1_t");
541 
542  assert_int_equal(amxc_var_remove_type(&dummy1), 0);
543 }
AMXC_VAR_ID_INVALID
#define AMXC_VAR_ID_INVALID
Invalid variant type id.
Definition: amxc_variant.h:122
amxc_var_type_name_of
const char * amxc_var_type_name_of(const amxc_var_t *const var)
Gets the variant type name of a variant.
Definition: amxc_variant.c:672

Variable Documentation

◆ dummy1

amxc_var_type_t dummy1
static
Initial value:
=
{
.init = amxc_var_init_success,
.del = amxc_var_del,
.copy = amxc_var_default_copy,
.move = amxc_var_default_move,
.convert_from = amxc_var_convert_success,
.convert_to = amxc_var_convert_success,
.compare = amxc_var_compare_success,
.get_key = amxc_var_test_get_key,
.set_key = amxc_var_test_set_key,
.get_index = amxc_var_test_get_index,
.set_index = amxc_var_test_set_index,
.name = "dummy1_t"
}
amxc_var_default_move
int PRIVATE amxc_var_default_move(amxc_var_t *const dest, amxc_var_t *const src)
Definition: amxc_variant.c:142
amxc_var_default_copy
int PRIVATE amxc_var_default_copy(amxc_var_t *const dest, const amxc_var_t *const src)
Definition: amxc_variant.c:136
amxc_var_convert_success
int amxc_var_convert_success(amxc_var_t *const dest, const amxc_var_t *const src)
Definition: test_amxc_variant.c:117
amxc_var_test_set_index
static int amxc_var_test_set_index(UNUSED amxc_var_t *const dest, UNUSED amxc_var_t *const src, UNUSED const int64_t index, UNUSED int flags)
Definition: test_amxc_variant.c:234
amxc_var_test_get_key
static amxc_var_t * amxc_var_test_get_key(UNUSED const amxc_var_t *const src, const char *const key, int flags)
Definition: test_amxc_variant.c:188
amxc_var_del
void amxc_var_del(amxc_var_t *const var)
amxc_var_compare_success
int amxc_var_compare_success(const amxc_var_t *const var1, const amxc_var_t *const var2, int *const result)
Definition: test_amxc_variant.c:133
amxc_var_test_set_key
static int amxc_var_test_set_key(UNUSED amxc_var_t *const dest, UNUSED amxc_var_t *const src, UNUSED const char *const key, UNUSED int flags)
Definition: test_amxc_variant.c:205
amxc_var_test_get_index
static amxc_var_t * amxc_var_test_get_index(UNUSED const amxc_var_t *const src, const int64_t index, int flags)
Definition: test_amxc_variant.c:216
amxc_var_init_success
int amxc_var_init_success(amxc_var_t *const var)

Definition at line 246 of file test_amxc_variant.c.

◆ dummy2

amxc_var_type_t dummy2
static
Initial value:
=
{
.init = NULL,
.del = NULL,
.copy = amxc_var_copy_fail,
.move = amxc_var_move_fail,
.convert_from = amxc_var_convert_fail,
.convert_to = amxc_var_convert_fail,
.compare = amxc_var_compare_fail,
.name = "dummy2_t"
}
amxc_var_compare_fail
int amxc_var_compare_fail(const amxc_var_t *const var1, const amxc_var_t *const var2, int *const result)
amxc_var_copy_fail
int amxc_var_copy_fail(amxc_var_t *const dest, const amxc_var_t *const src)
amxc_var_move_fail
int amxc_var_move_fail(amxc_var_t *const dest, amxc_var_t *const src)
amxc_var_convert_fail
int amxc_var_convert_fail(amxc_var_t *const dest, const amxc_var_t *const src)

Definition at line 262 of file test_amxc_variant.c.

◆ dummy3

amxc_var_type_t dummy3
static
Initial value:
=
{
.init = NULL,
.del = NULL,
.copy = NULL,
.move = NULL,
.convert_from = NULL,
.convert_to = NULL,
.compare = NULL,
.get_key = amxc_var_test_get_key,
.set_key = amxc_var_test_set_key,
.get_index = amxc_var_test_get_index,
.set_index = amxc_var_test_set_index,
.name = "dummy3_t"
}

Definition at line 274 of file test_amxc_variant.c.

◆ test_var

amxc_var_t test_var
static

Definition at line 186 of file test_amxc_variant.c.