libamxc  1.10.3
C Generic Data Containers
Functions
test_variant_char.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 <string.h>
#include <amxc/amxc_variant.h>
#include <amxc_variant_priv.h>
#include "test_variant_char.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

void test_variant_char_copy (UNUSED void **state)
 
void test_variant_char_convert_to_bool (UNUSED void **state)
 
void test_variant_char_convert_to_integer (UNUSED void **state)
 
void test_variant_char_convert_to_uinteger (UNUSED void **state)
 
void test_variant_char_convert_to_list (UNUSED void **state)
 
void test_variant_ssv_char_convert_to_list (UNUSED void **state)
 
void test_variant_char_convert_to_htable (UNUSED void **state)
 
void test_variant_char_convert_to_double (UNUSED void **state)
 
void test_variant_char_convert_to_float (UNUSED void **state)
 
void test_variant_char_convert_to_ts (UNUSED void **state)
 
void test_variant_char_compare (UNUSED void **state)
 
void test_variant_char_set_get (UNUSED void **state)
 
void test_variant_cstring_add (UNUSED void **state)
 
void test_variant_char_copy_null (UNUSED void **state)
 
void test_variant_char_take_push (UNUSED void **state)
 
void test_variant_char_move (UNUSED void **state)
 
void test_variant_char_cast (UNUSED void **state)
 

Function Documentation

◆ test_variant_char_cast()

void test_variant_char_cast ( UNUSED void **  state)

Definition at line 832 of file test_variant_char.c.

832  {
833  amxc_var_t test_var;
834 
835  amxc_var_init(&test_var);
836 
837  amxc_var_set(cstring_t, &test_var, "true");
838  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
839  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
840  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_BOOL);
841  assert_true(amxc_var_constcast(bool, &test_var));
842 
843  amxc_var_set(cstring_t, &test_var, "TRUE");
844  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
845  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
846  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_BOOL);
847  assert_true(amxc_var_constcast(bool, &test_var));
848 
849  amxc_var_set(cstring_t, &test_var, "Yes");
850  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
851  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
852  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_BOOL);
853  assert_true(amxc_var_constcast(bool, &test_var));
854 
855  amxc_var_set(cstring_t, &test_var, "false");
856  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
857  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
858  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_BOOL);
859  assert_false(amxc_var_constcast(bool, &test_var));
860 
861  amxc_var_set(cstring_t, &test_var, "FaLsE");
862  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
863  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
864  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_BOOL);
865  assert_false(amxc_var_constcast(bool, &test_var));
866 
867  amxc_var_set(cstring_t, &test_var, "\n false");
868  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
869  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
870  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_BOOL);
871  assert_false(amxc_var_constcast(bool, &test_var));
872 
873  amxc_var_set(cstring_t, &test_var, "NO");
874  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
875  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
876  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_BOOL);
877  assert_false(amxc_var_constcast(bool, &test_var));
878 
879  amxc_var_set(cstring_t, &test_var, "1970-01-01T00:00:00Z");
880  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
881  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
882  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_TIMESTAMP);
883  amxc_var_dump(&test_var, STDOUT_FILENO);
884 
885  amxc_var_set(cstring_t, &test_var, "-3.141592654");
886  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
887  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
888  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_DOUBLE);
889 
890  amxc_var_set(cstring_t, &test_var, "3.141592654");
891  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
892  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
893  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_DOUBLE);
894 
895  amxc_var_set(cstring_t, &test_var, "+3.141592654");
896  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
897  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
898  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_DOUBLE);
899 
900  amxc_var_set(cstring_t, &test_var, "+1024");
901  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
902  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
903  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_INT32);
904  assert_int_equal(test_var.data.i32, 1024);
905 
906  amxc_var_set(cstring_t, &test_var, "-1024");
907  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
908  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
909  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_INT32);
910  assert_int_equal(test_var.data.i32, -1024);
911 
912  amxc_var_set(cstring_t, &test_var, "1024");
913  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
914  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
915  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_UINT32);
916  assert_int_equal(test_var.data.ui32, 1024);
917 
918  amxc_var_set(cstring_t, &test_var, "+2147483648");
919  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
920  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
921  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_INT64);
922  assert_int_equal(test_var.data.i64, 2147483648);
923 
924  amxc_var_set(cstring_t, &test_var, "-2147483649");
925  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
926  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
927  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_INT64);
928  assert_int_equal(test_var.data.i64, -2147483649);
929 
930  amxc_var_set(cstring_t, &test_var, "4294967296");
931  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
932  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
933  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_UINT64);
934  assert_int_equal(test_var.data.ui64, 4294967296);
935 
936  amxc_var_set(cstring_t, &test_var, " HELLO WORLD ");
937  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
938  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
939  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
940  assert_string_equal(test_var.data.s, " HELLO WORLD ");
941 
942  amxc_var_set(cstring_t, &test_var, "");
943  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
944  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_ANY), 0);
945  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSTRING);
946  assert_string_equal(test_var.data.s, "");
947 
948  amxc_var_set(csv_string_t, &test_var, "Phonebook.Contact.[FirstName=='ward'].PhoneNumber.*,Phonebook.Contact.");
949  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSV_STRING);
950  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_LIST), 0);
951  amxc_var_dump(&test_var, STDOUT_FILENO);
952  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_LIST);
953  assert_string_equal(GETI_CHAR(&test_var, 0), "Phonebook.Contact.[FirstName=='ward'].PhoneNumber.*");
954  assert_string_equal(GETI_CHAR(&test_var, 1), "Phonebook.Contact.");
955 
956  amxc_var_set(csv_string_t, &test_var, "Phonebook.Contact.[FirstName=='ward'].PhoneNumber.*");
957  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSV_STRING);
958  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_LIST), 0);
959  amxc_var_dump(&test_var, STDOUT_FILENO);
960  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_LIST);
961  assert_string_equal(GETI_CHAR(&test_var, 0), "Phonebook.Contact.[FirstName=='ward'].PhoneNumber.*");
962 
963  amxc_var_set(csv_string_t, &test_var, "a,[b,c],d");
964  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_CSV_STRING);
965  assert_int_equal(amxc_var_cast(&test_var, AMXC_VAR_ID_LIST), 0);
966  amxc_var_dump(&test_var, STDOUT_FILENO);
967  assert_int_equal(amxc_var_type_of(&test_var), AMXC_VAR_ID_LIST);
968  assert_string_equal(GETI_CHAR(&test_var, 0), "a");
969  assert_int_equal(amxc_var_type_of(GETI_ARG(&test_var, 1)), AMXC_VAR_ID_LIST);
970  assert_string_equal(GETP_CHAR(&test_var, "1.0"), "b");
971  assert_string_equal(GETP_CHAR(&test_var, "1.1"), "c");
972  assert_string_equal(GETI_CHAR(&test_var, 2), "d");
973 
974  amxc_var_clean(&test_var);
975 }
csv_string_t
#define csv_string_t
Convenience macro.
Definition: amxc_variant.h:589
cstring_t
#define cstring_t
Convenience macro.
Definition: amxc_variant.h:584
AMXC_VAR_ID_UINT32
#define AMXC_VAR_ID_UINT32
Unsigned 32 bit integer variant id.
Definition: amxc_variant.h:176
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_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_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_ANY
#define AMXC_VAR_ID_ANY
Special variant id, typically used in cast or conversion functions.
Definition: amxc_variant.h:247
AMXC_VAR_ID_TIMESTAMP
#define AMXC_VAR_ID_TIMESTAMP
Ambiorix timestamp variant id.
Definition: amxc_variant.h:224
AMXC_VAR_ID_CSV_STRING
#define AMXC_VAR_ID_CSV_STRING
Comma Separated Values string variant id.
Definition: amxc_variant.h:230
AMXC_VAR_ID_LIST
#define AMXC_VAR_ID_LIST
Ambiorix Linked List variant id.
Definition: amxc_variant.h:206
AMXC_VAR_ID_INT64
#define AMXC_VAR_ID_INT64
Signed 64 bit integer variant id.
Definition: amxc_variant.h:158
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
GETI_CHAR
#define GETI_CHAR(a, i)
Convenience macro for getting a char* out of a composite variant by index.
Definition: amxc_variant.h:507
GETP_CHAR
#define GETP_CHAR(a, p)
Convenience macro for getting a string out of a composite variant by path.
Definition: amxc_variant.h:558
GETI_ARG
#define GETI_ARG(a, i)
Convenience macro for getting variant out of a composite variant by index.
Definition: amxc_variant.h:487
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_cast
int amxc_var_cast(amxc_var_t *const var, const uint32_t type_id)
Casts the variant to another variant type id.
Definition: amxc_variant.c:372
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_set
#define amxc_var_set(type, var, data)
Convenience macro for setting a value in a variant.
Definition: amxc_variant.h:609
amxc_var_constcast
#define amxc_var_constcast(type, var)
Takes the content from a variant.
Definition: amxc_variant.h:722
_amxc_var
The variant struct definition.
Definition: amxc_variant.h:861
_amxc_var::data
void * data
Definition: amxc_variant.h:883
test_var
static amxc_var_t test_var
Definition: test_amxc_variant.c:186

◆ test_variant_char_compare()

void test_variant_char_compare ( UNUSED void **  state)

Definition at line 611 of file test_variant_char.c.

611  {
612  amxc_var_t var1;
613  amxc_var_t var2;
614  int result = 0;
615 
616  assert_int_equal(amxc_var_init(&var1), 0);
617  assert_int_equal(amxc_var_init(&var2), 0);
618  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CSTRING), 0);
619  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_CSTRING), 0);
620  assert_int_equal(var1.type_id, AMXC_VAR_ID_CSTRING);
621  assert_int_equal(var2.type_id, AMXC_VAR_ID_CSTRING);
622 
623  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
624  assert_int_equal(result, 0);
625 
626  var1.data.s = "Hello world";
627  var2.data.s = "Hello world";
628 
629  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
630  assert_int_equal(result, 0);
631 
632  var2.data.s = "Hello europe";
633  assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);
634  assert_true(result < 0);
635 
636  var2.data.s = "Hello zulu";
637  assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);
638  assert_true(result > 0);
639 }
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_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::type_id
uint32_t type_id
Definition: amxc_variant.h:864

◆ test_variant_char_convert_to_bool()

void test_variant_char_convert_to_bool ( UNUSED void **  state)

Definition at line 92 of file test_variant_char.c.

92  {
93  amxc_var_t var;
94  amxc_var_t copy_var;
95 
96 
97  assert_int_equal(amxc_var_init(&var), 0);
98  assert_int_equal(amxc_var_init(&copy_var), 0);
99  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
100  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CSTRING), 0);
101  assert_int_equal(var.type_id, AMXC_VAR_ID_CSTRING);
102 
103  var.data.s = NULL;
104  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
105  var.data.s = "";
106  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
107 
108  var.data.s = "Hello world";
109  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
110  var.data.s = "0x10";
111  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
112 
113  var.data.s = "true";
114  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
115  assert_true(copy_var.data.b);
116 
117  var.data.s = "false";
118  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
119  assert_false(copy_var.data.b);
120 
121  var.data.s = "yes";
122  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
123  assert_true(copy_var.data.b);
124 
125  var.data.s = "no";
126  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
127  assert_false(copy_var.data.b);
128 
129  var.data.s = "1";
130  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
131  assert_true(copy_var.data.b);
132 
133  var.data.s = "0";
134  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
135  assert_false(copy_var.data.b);
136 
137  var.data.s = "ON";
138  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
139  assert_true(copy_var.data.b);
140 
141  var.data.s = "Off";
142  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
143  assert_false(copy_var.data.b);
144 
145  var.data.s = " \n\t true";
146  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
147  assert_true(copy_var.data.b);
148 }
AMXC_VAR_ID_NULL
#define AMXC_VAR_ID_NULL
Null variant type id (aka void)
Definition: amxc_variant.h:128
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
var
static amxc_var_t * var
Definition: test_issue_58.c:77

◆ test_variant_char_convert_to_double()

void test_variant_char_convert_to_double ( UNUSED void **  state)

Definition at line 515 of file test_variant_char.c.

515  {
516  amxc_var_t var;
517  amxc_var_t copy_var;
518 
519  assert_int_equal(amxc_var_init(&var), 0);
520  assert_int_equal(amxc_var_init(&copy_var), 0);
521  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
522  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CSTRING), 0);
523  assert_int_equal(var.type_id, AMXC_VAR_ID_CSTRING);
524 
525  var.data.s = NULL;
526  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
527  var.data.s = "";
528  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
529 
530  var.data.s = "NULL";
531  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
532  var.data.s = "\n\t NULL";
533  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
534  var.data.s = "Hello World";
535  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
536  var.data.s = "12345Hello World";
537  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
538  var.data.s = " 12345 ";
539  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
540 
541  var.data.s = "12345";
542  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
543  assert_true(copy_var.data.d == 12345);
544 
545  var.data.s = "1e+10";
546  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
547  assert_true(copy_var.data.d == 1e+10);
548 
549  var.data.s = "1e-10";
550  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
551 
552  var.data.s = "2.2204460492503131e-400";
553  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
554 }

◆ test_variant_char_convert_to_float()

void test_variant_char_convert_to_float ( UNUSED void **  state)

Definition at line 556 of file test_variant_char.c.

556  {
557  amxc_var_t var;
558  amxc_var_t copy_var;
559 
560  assert_int_equal(amxc_var_init(&var), 0);
561  assert_int_equal(amxc_var_init(&copy_var), 0);
562  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
563  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CSTRING), 0);
564  assert_int_equal(var.type_id, AMXC_VAR_ID_CSTRING);
565 
566  var.data.s = NULL;
567  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
568  var.data.s = "";
569  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
570 
571  var.data.s = "NULL";
572  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
573  var.data.s = "\n\t NULL";
574  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
575  var.data.s = "Hello World";
576  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
577  var.data.s = "12345Hello World";
578  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
579  var.data.s = " 12345 ";
580  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
581 
582  var.data.s = "12345";
583  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
584  assert_true(copy_var.data.f == 12345);
585 
586  var.data.s = "1e+10";
587  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
588 
589  var.data.s = "2.2204460492503131e-400";
590  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
591 }
AMXC_VAR_ID_FLOAT
#define AMXC_VAR_ID_FLOAT
Float variant id.
Definition: amxc_variant.h:188

◆ test_variant_char_convert_to_htable()

void test_variant_char_convert_to_htable ( UNUSED void **  state)

Definition at line 447 of file test_variant_char.c.

447  {
448  amxc_var_t var;
449  amxc_var_t copy_var;
450  amxc_htable_it_t* it = NULL;
451 
452  assert_int_equal(amxc_var_init(&var), 0);
453  assert_int_equal(amxc_var_init(&copy_var), 0);
454  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
455  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CSTRING), 0);
456  assert_int_equal(var.type_id, AMXC_VAR_ID_CSTRING);
457 
458  var.data.s = NULL;
459  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_HTABLE), 0);
460  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_HTABLE);
461  var.data.s = "";
462  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_HTABLE), 0);
463  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_HTABLE);
464 
465  var.data.s = "NULL";
466  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_HTABLE), 0);
467  assert_int_equal(amxc_htable_size(&copy_var.data.vm), 1);
468  it = amxc_htable_get_first(&copy_var.data.vm);
469  assert_ptr_not_equal(amxc_var_from_htable_it(it), NULL);
470  assert_ptr_equal(amxc_var_from_htable_it(it)->data.s, NULL);
471  assert_ptr_not_equal(amxc_htable_it_get_key(it), NULL);
472  assert_string_equal(amxc_htable_it_get_key(it), "NULL");
473 
474  var.data.s = "key1:a,key2:b,key3:c,key4:d,key5:e";
475  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_HTABLE), 0);
476  assert_int_equal(amxc_htable_size(&copy_var.data.vm), 5);
477  it = amxc_htable_get(&copy_var.data.vm, "key1");
478  assert_ptr_not_equal(amxc_var_from_htable_it(it), NULL);
479  assert_ptr_not_equal(amxc_var_from_htable_it(it)->data.s, NULL);
480  assert_string_equal(amxc_var_from_htable_it(it)->data.s, "a");
481  assert_ptr_not_equal(amxc_htable_it_get_key(it), NULL);
482  assert_string_equal(amxc_htable_it_get_key(it), "key1");
483 
484  it = amxc_htable_get(&copy_var.data.vm, "key2");
485  assert_ptr_not_equal(amxc_var_from_htable_it(it), NULL);
486  assert_ptr_not_equal(amxc_var_from_htable_it(it)->data.s, NULL);
487  assert_string_equal(amxc_var_from_htable_it(it)->data.s, "b");
488  assert_ptr_not_equal(amxc_htable_it_get_key(it), NULL);
489  assert_string_equal(amxc_htable_it_get_key(it), "key2");
490 
491  it = amxc_htable_get(&copy_var.data.vm, "key3");
492  assert_ptr_not_equal(amxc_var_from_htable_it(it), NULL);
493  assert_ptr_not_equal(amxc_var_from_htable_it(it)->data.s, NULL);
494  assert_string_equal(amxc_var_from_htable_it(it)->data.s, "c");
495  assert_ptr_not_equal(amxc_htable_it_get_key(it), NULL);
496  assert_string_equal(amxc_htable_it_get_key(it), "key3");
497 
498  it = amxc_htable_get(&copy_var.data.vm, "key4");
499  assert_ptr_not_equal(amxc_var_from_htable_it(it), NULL);
500  assert_ptr_not_equal(amxc_var_from_htable_it(it)->data.s, NULL);
501  assert_string_equal(amxc_var_from_htable_it(it)->data.s, "d");
502  assert_ptr_not_equal(amxc_htable_it_get_key(it), NULL);
503  assert_string_equal(amxc_htable_it_get_key(it), "key4");
504 
505  it = amxc_htable_get(&copy_var.data.vm, "key5");
506  assert_ptr_not_equal(amxc_var_from_htable_it(it), NULL);
507  assert_ptr_not_equal(amxc_var_from_htable_it(it)->data.s, NULL);
508  assert_string_equal(amxc_var_from_htable_it(it)->data.s, "e");
509  assert_ptr_not_equal(amxc_htable_it_get_key(it), NULL);
510  assert_string_equal(amxc_htable_it_get_key(it), "key5");
511 
512  amxc_var_clean(&copy_var);
513 }
amxc_var_from_htable_it
#define amxc_var_from_htable_it(ht_it)
Get the variant pointer from an amxc htable iterator.
Definition: amxc_variant.h:790
amxc_htable_it_get_key
AMXC_INLINE const char * amxc_htable_it_get_key(const amxc_htable_it_t *const it)
Gets the key from the iterator.
Definition: amxc_htable.h:672
amxc_htable_get_first
amxc_htable_it_t * amxc_htable_get_first(const amxc_htable_t *const htable)
Gets the first item stored in the table.
Definition: amxc_htable.c:313
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_htable_get
amxc_htable_it_t * amxc_htable_get(const amxc_htable_t *const htable, const char *const key)
Gets a hash table iterator from the hash table.
Definition: amxc_htable.c:278
AMXC_VAR_ID_HTABLE
#define AMXC_VAR_ID_HTABLE
Ambiorix Hash Table variant id.
Definition: amxc_variant.h:212
_amxc_htable_it
The hash table iterator structure.
Definition: amxc_htable.h:138
data
char data[]
Definition: test_amxc_array.c:69
it
static amxc_htable_it_t it[2000]
Definition: test_amxc_htable.c:69

◆ test_variant_char_convert_to_integer()

void test_variant_char_convert_to_integer ( UNUSED void **  state)

Definition at line 150 of file test_variant_char.c.

150  {
151  amxc_var_t var;
152  amxc_var_t copy_var;
153 
154 
155  assert_int_equal(amxc_var_init(&var), 0);
156  assert_int_equal(amxc_var_init(&copy_var), 0);
157  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
158  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CSTRING), 0);
159  assert_int_equal(var.type_id, AMXC_VAR_ID_CSTRING);
160 
161  var.data.s = NULL;
162  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
163  var.data.s = "";
164  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
165 
166  var.data.s = "NULL";
167  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
168  var.data.s = "\n\t NULL";
169  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
170  var.data.s = "Hello World";
171  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
172  var.data.s = "12345Hello World";
173  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
174  var.data.s = " 12345 ";
175  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
176 
177  var.data.s = "12345";
178  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
179  assert_int_equal(copy_var.data.i64, 12345);
180 
181  var.data.s = " +555";
182  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
183  assert_int_equal(copy_var.data.i64, 555);
184 
185  var.data.s = " -987";
186  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
187  assert_int_equal(copy_var.data.i64, -987);
188 
189  var.data.s = "92233720368547758081";
190  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
191  var.data.s = "-92233720368547758081";
192  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
193 }

◆ test_variant_char_convert_to_list()

void test_variant_char_convert_to_list ( UNUSED void **  state)

Definition at line 238 of file test_variant_char.c.

238  {
239  amxc_var_t var;
240  amxc_var_t copy_var;
241  amxc_llist_it_t* it = NULL;
242 
243  assert_int_equal(amxc_var_init(&var), 0);
244  assert_int_equal(amxc_var_init(&copy_var), 0);
245  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
246  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CSTRING), 0);
247  assert_int_equal(var.type_id, AMXC_VAR_ID_CSTRING);
248 
249  var.data.s = NULL;
250  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
251  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_LIST);
252  var.data.s = strdup("");
253  amxc_var_clean(&copy_var);
254  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
255  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_LIST);
256  assert_int_equal(amxc_llist_size(&copy_var.data.vl), 0);
257  free(var.data.s);
258 
259  var.data.s = strdup("NULL");
260  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
261  assert_int_equal(amxc_llist_size(&copy_var.data.vl), 1);
262  it = amxc_llist_get_first(&copy_var.data.vl);
263  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
264  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "NULL");
265  amxc_llist_clean(&copy_var.data.vl, variant_list_it_free);
266  free(var.data.s);
267 
268  var.data.s = strdup("a,b,c,d,e");
269  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
270  assert_int_equal(amxc_llist_size(&copy_var.data.vl), 5);
271  it = amxc_llist_get_first(&copy_var.data.vl);
272  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
273  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "a");
274 
275  it = amxc_llist_it_get_next(it);
276  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
277  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "b");
278 
279  it = amxc_llist_it_get_next(it);
280  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
281  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "c");
282 
283  it = amxc_llist_it_get_next(it);
284  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
285  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "d");
286 
287  it = amxc_llist_it_get_next(it);
288  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
289  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "e");
290  amxc_llist_clean(&copy_var.data.vl, variant_list_it_free);
291  free(var.data.s);
292 
293  var.data.s = strdup("a , b , c , d , \t \n e");
294  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
295  assert_int_equal(amxc_llist_size(&copy_var.data.vl), 5);
296  it = amxc_llist_get_first(&copy_var.data.vl);
297  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
298  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "a");
299 
300  it = amxc_llist_it_get_next(it);
301  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
302  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "b");
303 
304  it = amxc_llist_it_get_next(it);
305  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
306  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "c");
307 
308  it = amxc_llist_it_get_next(it);
309  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
310  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "d");
311 
312  it = amxc_llist_it_get_next(it);
313  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
314  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "e");
315  amxc_llist_clean(&copy_var.data.vl, variant_list_it_free);
316  free(var.data.s);
317 
318  var.data.s = strdup("a,,b,,c,,d, ,e");
319  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
320  assert_int_equal(amxc_llist_size(&copy_var.data.vl), 9);
321  it = amxc_llist_get_first(&copy_var.data.vl);
322  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
323  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "a");
324 
325  it = amxc_llist_it_get_next(it);
326  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
327  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "");
328 
329  it = amxc_llist_it_get_next(it);
330  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
331  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "b");
332 
333  it = amxc_llist_it_get_next(it);
334  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
335  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "");
336 
337  it = amxc_llist_it_get_next(it);
338  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
339  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "c");
340 
341  it = amxc_llist_it_get_next(it);
342  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
343  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "");
344 
345  it = amxc_llist_it_get_next(it);
346  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
347  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "d");
348 
349  it = amxc_llist_it_get_next(it);
350  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
351  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "");
352 
353  it = amxc_llist_it_get_next(it);
354  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
355  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "e");
356  free(var.data.s);
357 
358  amxc_llist_clean(&copy_var.data.vl, variant_list_it_free);
359 
360  amxc_var_clean(&copy_var);
361 }
amxc_var_from_llist_it
#define amxc_var_from_llist_it(ll_it)
Get the variant pointer from an amxc linked list iterator.
Definition: amxc_variant.h:799
amxc_llist_it_get_next
AMXC_INLINE amxc_llist_it_t * amxc_llist_it_get_next(const amxc_llist_it_t *const reference)
Gets the next iterator in the list.
Definition: amxc_llist.h:824
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_llist_clean
void amxc_llist_clean(amxc_llist_t *const llist, amxc_llist_it_delete_t func)
Removes all items from the linked list.
Definition: amxc_llist.c:124
amxc_llist_get_first
AMXC_INLINE amxc_llist_it_t * amxc_llist_get_first(const amxc_llist_t *const llist)
Gets the first item of the linked list.
Definition: amxc_llist.h:713
variant_list_it_free
void variant_list_it_free(amxc_llist_it_t *it)
Helper functions, can be used as delete function for linked lists.
Definition: variant_list.c:66
_amxc_llist_it
The linked list iterator structure.
Definition: amxc_llist.h:215

◆ test_variant_char_convert_to_ts()

void test_variant_char_convert_to_ts ( UNUSED void **  state)

Definition at line 593 of file test_variant_char.c.

593  {
594  amxc_var_t var1;
595  amxc_var_t var2;
596 
597  amxc_var_init(&var1);
598  amxc_var_init(&var2);
599 
600  assert_int_equal(amxc_var_set(cstring_t, &var1, "2020-06-19T09:08:16Z"), 0);
601  assert_int_equal(amxc_var_convert(&var2, &var1, AMXC_VAR_ID_TIMESTAMP), 0);
602  assert_int_equal(var2.type_id, AMXC_VAR_ID_TIMESTAMP);
603 
604  assert_int_equal(amxc_var_set(cstring_t, &var1, "THIS IS NOT A TIMESTAMP"), 0);
605  assert_int_not_equal(amxc_var_convert(&var2, &var1, AMXC_VAR_ID_TIMESTAMP), 0);
606 
607  amxc_var_clean(&var1);
608  amxc_var_clean(&var2);
609 }

◆ test_variant_char_convert_to_uinteger()

void test_variant_char_convert_to_uinteger ( UNUSED void **  state)

Definition at line 195 of file test_variant_char.c.

195  {
196  amxc_var_t var;
197  amxc_var_t copy_var;
198 
199 
200  assert_int_equal(amxc_var_init(&var), 0);
201  assert_int_equal(amxc_var_init(&copy_var), 0);
202  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
203  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CSTRING), 0);
204  assert_int_equal(var.type_id, AMXC_VAR_ID_CSTRING);
205 
206  var.data.s = NULL;
207  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
208  var.data.s = "";
209  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
210 
211  var.data.s = "NULL";
212  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
213  var.data.s = "\n\t NULL";
214  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
215  var.data.s = "Hello World";
216  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
217  var.data.s = "12345Hello World";
218  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
219  var.data.s = " 12345 ";
220  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
221 
222  var.data.s = "12345";
223  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
224  assert_int_equal(copy_var.data.ui64, 12345);
225 
226  var.data.s = " +555";
227  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
228  assert_int_equal(copy_var.data.ui64, 555);
229 
230  var.data.s = " -987";
231  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
232  assert_int_equal(copy_var.data.ui64, 987);
233 
234  var.data.s = "92233720368547758081";
235  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
236 }

◆ test_variant_char_copy()

void test_variant_char_copy ( UNUSED void **  state)

Definition at line 76 of file test_variant_char.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  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
83  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_CSTRING), 0);
84  assert_int_equal(var.type_id, AMXC_VAR_ID_CSTRING);
85  var.data.s = "Hello world";
86 
87  assert_int_equal(amxc_var_copy(&copy_var, &var), 0);
88  assert_string_equal(copy_var.data.s, "Hello world");
89  free(copy_var.data.s);
90 }
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_char_copy_null()

void test_variant_char_copy_null ( UNUSED void **  state)

Definition at line 768 of file test_variant_char.c.

768  {
769  amxc_var_t var1;
770  amxc_var_t var2;
771 
772  assert_int_equal(amxc_var_init(&var1), 0);
773  assert_int_equal(amxc_var_init(&var2), 0);
774  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CSTRING), 0);
775  assert_int_equal(amxc_var_copy(&var2, &var1), 0);
776 
777  amxc_var_clean(&var1);
778  amxc_var_clean(&var2);
779 }

◆ test_variant_char_move()

void test_variant_char_move ( UNUSED void **  state)

Definition at line 818 of file test_variant_char.c.

818  {
819  amxc_var_t src;
820  amxc_var_t dst;
821 
822  amxc_var_init(&src);
823  amxc_var_init(&dst);
824 
825  amxc_var_set(cstring_t, &src, "This is a tekst - ... ");
826  assert_int_equal(amxc_var_move(&dst, &src), 0);
827 
828  amxc_var_clean(&src);
829  amxc_var_clean(&dst);
830 }
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

◆ test_variant_char_set_get()

void test_variant_char_set_get ( UNUSED void **  state)

Definition at line 641 of file test_variant_char.c.

641  {
642  amxc_var_t var1;
643  char* text = NULL;
644  const char* consttext = NULL;
645 
646  assert_int_equal(amxc_var_init(&var1), 0);
647  amxc_var_set_type(&var1, AMXC_VAR_ID_CSTRING);
648  assert_string_equal(amxc_var_constcast(cstring_t, &var1), "");
649  text = amxc_var_dyncast(cstring_t, &var1);
650  assert_string_equal(text, "");
651  free(text);
652 
653  assert_int_equal(amxc_var_set_cstring_t(&var1, "Hello world"), 0);
654  assert_int_equal(var1.type_id, AMXC_VAR_ID_CSTRING);
655  assert_string_equal(var1.data.s, "Hello world");
656 
657  text = amxc_var_get_cstring_t(&var1);
658  assert_ptr_not_equal(text, NULL);
659  assert_string_equal(text, "Hello world");
660  free(text);
661 
662  assert_int_equal(amxc_var_set_csv_string_t(&var1, "Hello world"), 0);
663  assert_int_equal(var1.type_id, AMXC_VAR_ID_CSV_STRING);
664  text = amxc_var_get_csv_string_t(&var1);
665  assert_ptr_not_equal(text, NULL);
666  assert_string_equal(text, "Hello world");
667  free(text);
668 
669  assert_int_equal(amxc_var_set_ssv_string_t(&var1, "Hello world"), 0);
670  assert_int_equal(var1.type_id, AMXC_VAR_ID_SSV_STRING);
671  text = amxc_var_get_ssv_string_t(&var1);
672  assert_ptr_not_equal(text, NULL);
673  assert_string_equal(text, "Hello world");
674  free(text);
675 
676  text = amxc_var_dyncast(cstring_t, &var1);
677  assert_ptr_not_equal(text, NULL);
678  assert_string_equal(text, "Hello world");
679  free(text);
680  consttext = amxc_var_constcast(cstring_t, &var1);
681  assert_ptr_not_equal(consttext, NULL);
682  assert_string_equal(consttext, "Hello world");
683 
684  text = amxc_var_dyncast(csv_string_t, &var1);
685  assert_ptr_not_equal(text, NULL);
686  assert_string_equal(text, "Hello world");
687  free(text);
688  consttext = amxc_var_constcast(csv_string_t, &var1);
689  assert_ptr_not_equal(consttext, NULL);
690  assert_string_equal(consttext, "Hello world");
691 
692  text = amxc_var_dyncast(ssv_string_t, &var1);
693  assert_ptr_not_equal(text, NULL);
694  assert_string_equal(text, "Hello world");
695  free(text);
696  consttext = amxc_var_constcast(ssv_string_t, &var1);
697  assert_ptr_not_equal(consttext, NULL);
698  assert_string_equal(consttext, "Hello world");
699 
700  text = amxc_var_dyncast(cstring_t, NULL);
701  assert_ptr_equal(text, NULL);
702  text = amxc_var_dyncast(csv_string_t, NULL);
703  assert_ptr_equal(text, NULL);
704  text = amxc_var_dyncast(ssv_string_t, NULL);
705  assert_ptr_equal(text, NULL);
706 
707  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_CUSTOM_BASE), 0);
708  text = amxc_var_dyncast(cstring_t, &var1);
709  assert_ptr_equal(text, NULL);
710  consttext = amxc_var_constcast(cstring_t, &var1);
711  assert_ptr_equal(consttext, NULL);
712 
713  consttext = amxc_var_constcast(cstring_t, NULL);
714  assert_ptr_equal(consttext, NULL);
715  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_BOOL), 0);
716  consttext = amxc_var_constcast(cstring_t, &var1);
717  assert_ptr_equal(consttext, NULL);
718 
719  assert_int_not_equal(amxc_var_set_cstring_t(NULL, NULL), 0);
720  assert_int_not_equal(amxc_var_set_cstring_t(NULL, "Hello world"), 0);
721  assert_int_not_equal(amxc_var_set_cstring_t(&var1, NULL), 0);
722 
723  assert_int_not_equal(amxc_var_set_csv_string_t(NULL, NULL), 0);
724  assert_int_not_equal(amxc_var_set_csv_string_t(NULL, "Hello world"), 0);
725  assert_int_not_equal(amxc_var_set_csv_string_t(&var1, NULL), 0);
726 
727  assert_int_not_equal(amxc_var_set_ssv_string_t(NULL, NULL), 0);
728  assert_int_not_equal(amxc_var_set_ssv_string_t(NULL, "Hello world"), 0);
729  assert_int_not_equal(amxc_var_set_ssv_string_t(&var1, NULL), 0);
730 
731  amxc_var_clean(&var1);
732 }
ssv_string_t
#define ssv_string_t
Convenience macro.
Definition: amxc_variant.h:594
amxc_var_get_csv_string_t
AMXC_INLINE char * amxc_var_get_csv_string_t(const amxc_var_t *const var)
Conversion helper function.
Definition: amxc_variant.h:2234
amxc_var_set_cstring_t
int amxc_var_set_cstring_t(amxc_var_t *const var, const char *const val)
Setter helper function.
Definition: variant_char.c:549
amxc_var_set_ssv_string_t
int amxc_var_set_ssv_string_t(amxc_var_t *const var, const char *const val)
Setter helper function.
Definition: variant_char.c:573
amxc_var_get_ssv_string_t
AMXC_INLINE char * amxc_var_get_ssv_string_t(const amxc_var_t *const var)
Conversion helper function.
Definition: amxc_variant.h:2255
amxc_var_get_cstring_t
char * amxc_var_get_cstring_t(const amxc_var_t *const var)
Conversion helper function.
Definition: variant_char.c:585
amxc_var_set_csv_string_t
int amxc_var_set_csv_string_t(amxc_var_t *const var, const char *const val)
Setter helper function.
Definition: variant_char.c:561
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_SSV_STRING
#define AMXC_VAR_ID_SSV_STRING
Space Separated Values string variant id.
Definition: amxc_variant.h:236
amxc_var_dyncast
#define amxc_var_dyncast(type, var)
Dynamic cast a variant to a certain type.
Definition: amxc_variant.h:678

◆ test_variant_char_take_push()

void test_variant_char_take_push ( UNUSED void **  state)

Definition at line 781 of file test_variant_char.c.

781  {
782  amxc_var_t var1;
783  char* txt = NULL;
784 
785  amxc_var_init(&var1);
786  amxc_var_set(cstring_t, &var1, "Hello World.");
787 
788  txt = amxc_var_take(cstring_t, &var1);
789  assert_ptr_not_equal(txt, NULL);
790  assert_int_equal(var1.type_id, AMXC_VAR_ID_NULL);
791  assert_ptr_equal(var1.data.s, NULL);
792  assert_string_equal(txt, "Hello World.");
793 
794  assert_int_equal(amxc_var_push(cstring_t, &var1, txt), 0);
795  assert_int_equal(var1.type_id, AMXC_VAR_ID_CSTRING);
796  assert_ptr_not_equal(var1.data.s, NULL);
797  assert_string_equal(var1.data.s, "Hello World.");
798 
799  txt = amxc_var_take(csv_string_t, &var1);
800  assert_int_equal(amxc_var_push(csv_string_t, &var1, txt), 0);
801  assert_int_equal(var1.type_id, AMXC_VAR_ID_CSV_STRING);
802  assert_ptr_not_equal(var1.data.s, NULL);
803  assert_string_equal(var1.data.s, "Hello World.");
804 
805  txt = amxc_var_take(ssv_string_t, &var1);
806  assert_int_equal(amxc_var_push(ssv_string_t, &var1, txt), 0);
807  assert_int_equal(var1.type_id, AMXC_VAR_ID_SSV_STRING);
808  assert_ptr_not_equal(var1.data.s, NULL);
809  assert_string_equal(var1.data.s, "Hello World.");
810 
811  assert_ptr_equal(amxc_var_take(csv_string_t, NULL), NULL);
812  assert_ptr_equal(amxc_var_take(ssv_string_t, NULL), NULL);
813  assert_ptr_equal(amxc_var_take(cstring_t, NULL), NULL);
814 
815  amxc_var_clean(&var1);
816 }
amxc_var_take
#define amxc_var_take(type, var)
Takes the content from a variant.
Definition: amxc_variant.h:757
amxc_var_push
#define amxc_var_push(type, var, val)
Pushes a value into the variant.
Definition: amxc_variant.h:780

◆ test_variant_cstring_add()

void test_variant_cstring_add ( UNUSED void **  state)

Definition at line 734 of file test_variant_char.c.

734  {
735  amxc_var_t var;
736  const amxc_llist_t* list = NULL;
737  const amxc_htable_t* table = NULL;
738 
739  assert_int_equal(amxc_var_init(&var), 0);
740  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_LIST), 0);
741  assert_ptr_not_equal(amxc_var_add(cstring_t, &var, "hello"), NULL);
742  assert_ptr_not_equal(amxc_var_add(csv_string_t, &var, "world"), NULL);
743  assert_ptr_not_equal(amxc_var_add(ssv_string_t, &var, "."), NULL);
744 
745  assert_ptr_equal(amxc_var_add(cstring_t, NULL, "hello"), NULL);
746  assert_ptr_equal(amxc_var_add(csv_string_t, NULL, "world"), NULL);
747  assert_ptr_equal(amxc_var_add(ssv_string_t, NULL, "."), NULL);
748 
749  list = amxc_var_constcast(amxc_llist_t, &var);
750  assert_int_equal(amxc_llist_size(list), 3);
751  amxc_var_clean(&var);
752 
753  assert_int_equal(amxc_var_init(&var), 0);
754  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_HTABLE), 0);
755  assert_ptr_not_equal(amxc_var_add_key(cstring_t, &var, "B1", "hello"), NULL);
756  assert_ptr_not_equal(amxc_var_add_key(csv_string_t, &var, "B2", "world"), NULL);
757  assert_ptr_not_equal(amxc_var_add_key(ssv_string_t, &var, "B3", "."), NULL);
758 
759  assert_ptr_equal(amxc_var_add_key(cstring_t, NULL, "B1", "hello"), NULL);
760  assert_ptr_equal(amxc_var_add_key(csv_string_t, NULL, "B2", "world"), NULL);
761  assert_ptr_equal(amxc_var_add_key(ssv_string_t, NULL, "B2", "."), NULL);
762 
763  table = amxc_var_constcast(amxc_htable_t, &var);
764  assert_int_equal(amxc_htable_size(table), 3);
765  amxc_var_clean(&var);
766 }
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_htable
The hash table structure.
Definition: amxc_htable.h:175
_amxc_llist
The linked list structure.
Definition: amxc_llist.h:228

◆ test_variant_ssv_char_convert_to_list()

void test_variant_ssv_char_convert_to_list ( UNUSED void **  state)

Definition at line 363 of file test_variant_char.c.

363  {
364  amxc_var_t var;
365  amxc_var_t copy_var;
366  amxc_llist_it_t* it = NULL;
367 
368  assert_int_equal(amxc_var_init(&var), 0);
369  assert_int_equal(amxc_var_init(&copy_var), 0);
370  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
371  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_SSV_STRING), 0);
372  assert_int_equal(var.type_id, AMXC_VAR_ID_SSV_STRING);
373 
374  var.data.s = NULL;
375  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
376  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_LIST);
377  var.data.s = strdup("");
378  amxc_var_clean(&copy_var);
379  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
380  assert_int_equal(amxc_var_type_of(&copy_var), AMXC_VAR_ID_LIST);
381  assert_int_equal(amxc_llist_size(&copy_var.data.vl), 0);
382  free(var.data.s);
383 
384  var.data.s = strdup("NULL");
385  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
386  assert_int_equal(amxc_llist_size(&copy_var.data.vl), 1);
387  it = amxc_llist_get_first(&copy_var.data.vl);
388  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
389  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "NULL");
390  amxc_llist_clean(&copy_var.data.vl, variant_list_it_free);
391  free(var.data.s);
392 
393  var.data.s = strdup("a b c d e");
394  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
395  assert_int_equal(amxc_llist_size(&copy_var.data.vl), 5);
396  it = amxc_llist_get_first(&copy_var.data.vl);
397  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
398  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "a");
399 
400  it = amxc_llist_it_get_next(it);
401  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
402  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "b");
403 
404  it = amxc_llist_it_get_next(it);
405  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
406  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "c");
407 
408  it = amxc_llist_it_get_next(it);
409  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
410  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "d");
411 
412  it = amxc_llist_it_get_next(it);
413  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
414  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "e");
415  amxc_llist_clean(&copy_var.data.vl, variant_list_it_free);
416  free(var.data.s);
417 
418  var.data.s = strdup("a b c d e");
419  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_LIST), 0);
420  assert_int_equal(amxc_llist_size(&copy_var.data.vl), 5);
421  it = amxc_llist_get_first(&copy_var.data.vl);
422  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
423  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "a");
424 
425  it = amxc_llist_it_get_next(it);
426  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
427  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "b");
428 
429  it = amxc_llist_it_get_next(it);
430  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
431  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "c");
432 
433  it = amxc_llist_it_get_next(it);
434  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
435  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "d");
436 
437  it = amxc_llist_it_get_next(it);
438  assert_ptr_not_equal(amxc_var_from_llist_it(it), NULL);
439  assert_string_equal(amxc_var_from_llist_it(it)->data.s, "e");
440 
441  amxc_llist_clean(&copy_var.data.vl, variant_list_it_free);
442  free(var.data.s);
443 
444  amxc_var_clean(&copy_var);
445 }