libamxc/test__variant__uint64_8c_source.html

 /****************************************************************************

 **

 ** SPDX-License-Identifier: BSD-2-Clause-Patent

 **

 ** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome

 **

 ** Redistribution and use in source and binary forms, with or without modification,

 ** are permitted provided that the following conditions are met:

 **

 ** 1. Redistributions of source code must retain the above copyright notice,

 ** this list of conditions and the following disclaimer.

 **

 ** 2. Redistributions in binary form must reproduce the above copyright notice,

 ** this list of conditions and the following disclaimer in the documentation

 ** and/or other materials provided with the distribution.

 **

 ** Subject to the terms and conditions of this license, each copyright holder

 ** and contributor hereby grants to those receiving rights under this license

 ** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable

 ** (except for failure to satisfy the conditions of this license) patent license

 ** to make, have made, use, offer to sell, sell, import, and otherwise transfer

 ** this software, where such license applies only to those patent claims, already

 ** acquired or hereafter acquired, licensable by such copyright holder or contributor

 ** that are necessarily infringed by:

 **

 ** (a) their Contribution(s) (the licensed copyrights of copyright holders and

 ** non-copyrightable additions of contributors, in source or binary form) alone;

 ** or

 **

 ** (b) combination of their Contribution(s) with the work of authorship to which

 ** such Contribution(s) was added by such copyright holder or contributor, if,

 ** at the time the Contribution is added, such addition causes such combination

 ** to be necessarily infringed. The patent license shall not apply to any other

 ** combinations which include the Contribution.

 **

 ** Except as expressly stated above, no rights or licenses from any copyright

 ** holder or contributor is granted under this license, whether expressly, by

 ** implication, estoppel or otherwise.

 **

 ** DISCLAIMER

 **

 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE

 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

 ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 **

 ****************************************************************************/


 #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 <amxc/amxc_variant.h>

 #include <amxc_variant_priv.h>


 #include "test_variant_uint64.h"


 #include <amxc/amxc_macros.h>

 void test_variant_uint64_copy(UNUSED void** state) {

     amxc_var_t var;

     amxc_var_t copy_var;


     assert_int_equal(amxc_var_init(&var), 0);

     assert_int_equal(amxc_var_init(&copy_var), 0);

     assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);

     assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_UINT64), 0);

     assert_int_equal(var.type_id, AMXC_VAR_ID_UINT64);

     var.data.ui64 = 4026531840;


     assert_int_equal(amxc_var_copy(&copy_var, &var), 0);

     var.data.ui64 = 4026531840;

 }


 void test_variant_uint64_convert_to(UNUSED void** state) {

     amxc_var_t var;

     amxc_var_t copy_var;


     assert_int_equal(amxc_var_init(&var), 0);

     assert_int_equal(amxc_var_init(&copy_var), 0);

     assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);

     assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_UINT64), 0);

     assert_int_equal(var.type_id, AMXC_VAR_ID_UINT64);


     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_NULL), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_NULL);

     assert_ptr_equal(copy_var.data.data, NULL);

     var.data.ui64 = 0x00000000F0000000;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CSTRING), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_CSTRING);

     assert_string_equal(copy_var.data.s, "4026531840");


     var.data.ui64 = 0x00000000F0000000;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);

     var.data.ui64 = 0xFFFFFFFF10000001;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);

     var.data.ui64 = 127;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT8);

     assert_int_equal(copy_var.data.i8, 127);


     var.data.ui64 = 0x00000000F0000000;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);

     var.data.ui64 = 0xFFFFFFFF10000001;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);

     var.data.ui64 = 1024;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT16);

     assert_int_equal(copy_var.data.i16, 1024);


     var.data.ui64 = 32766;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT64);

     assert_int_equal(copy_var.data.i64, 32766);


     var.data.ui64 = 0x00000000F0000000;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);

     var.data.ui64 = 0xFFFFFFFF10000001;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);

     var.data.ui64 = 32766;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT32);

     assert_int_equal(copy_var.data.i32, 32766);


     var.data.ui64 = 256;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT8), 0);

     var.data.ui64 = 255;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT8), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT8);

     assert_int_equal(copy_var.data.ui8, 255);


     var.data.ui64 = 65536;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT16), 0);

     var.data.ui64 = 65535;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT16), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT16);

     assert_int_equal(copy_var.data.ui16, 65535);


     var.data.ui64 = 4294967296;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT32), 0);

     var.data.ui64 = 4294967295;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT32), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT32);

     assert_int_equal(copy_var.data.ui32, 4294967295);


     var.data.ui64 = 4294967295;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT64);

     assert_int_equal(copy_var.data.ui64, 4294967295);


     var.data.ui64 = 1000;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_TIMESTAMP), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_TIMESTAMP);

     var.data.ui64 = -1000;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_TIMESTAMP), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_TIMESTAMP);


     var.data.ui64 = 0x00000000F0000000;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_BOOL);

     assert_true(copy_var.data.b);

     var.data.ui64 = 0x00;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_BOOL);

     assert_false(copy_var.data.b);


     var.data.ui64 = 4294967295;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_FLOAT);

     assert_true(copy_var.data.f == 4294967295);


     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_DOUBLE);

     assert_true(copy_var.data.d == 4294967295);


     struct rlimit nofile = { 0, 0 };

     assert_int_equal(getrlimit(RLIMIT_NOFILE, &nofile), 0);


     var.data.ui64 = 0xE0;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FD), 0);

     var.data.ui64 = nofile.rlim_max + 1;

     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FD), 0);

     var.data.ui64 = STDIN_FILENO;

     assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FD), 0);

     assert_int_equal(copy_var.type_id, AMXC_VAR_ID_FD);

     assert_int_equal(copy_var.data.fd, STDIN_FILENO);


     assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CUSTOM_BASE), 0);


 }


 void test_variant_uint64_compare(UNUSED void** state) {

     amxc_var_t var1;

     amxc_var_t var2;

     int result = 0;


     assert_int_equal(amxc_var_init(&var1), 0);

     assert_int_equal(amxc_var_init(&var2), 0);

     assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_UINT64), 0);

     assert_int_equal(var1.type_id, AMXC_VAR_ID_UINT64);

     var1.data.ui64 = 4026531840;

     assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_UINT64), 0);

     assert_int_equal(var2.type_id, AMXC_VAR_ID_UINT64);

     var2.data.ui64 = 10;


     assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);

     assert_true(result > 0);


     assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);

     assert_true(result < 0);


     var2.data.ui64 = 4026531840;

     assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);

     assert_true(result == 0);


 }


 void test_variant_uint64_set_get(UNUSED void** state) {

     amxc_var_t var1;


     assert_int_equal(amxc_var_init(&var1), 0);

     assert_int_equal(amxc_var_set_uint64_t(&var1, 1024), 0);

     assert_int_equal(var1.type_id, AMXC_VAR_ID_UINT64);

     assert_true(var1.data.ui64 = 1024);


     assert_true(amxc_var_get_uint64_t(&var1) == 1024);

     assert_true(amxc_var_dyncast(uint64_t, &var1) == 1024);


     assert_int_not_equal(amxc_var_set_uint64_t(NULL, 512), 0);

     assert_true(amxc_var_get_uint64_t(NULL) == 0);


     assert_int_equal(amxc_var_constcast(uint64_t, &var1), 1024);

     assert_int_equal(amxc_var_constcast(int64_t, &var1), 0);

     assert_int_equal(amxc_var_constcast(uint64_t, NULL), 0);

 }


 void test_variant_uint64_add(UNUSED void** state) {

     amxc_var_t var;

     const amxc_llist_t* list = NULL;

     const amxc_htable_t* table = NULL;


     assert_int_equal(amxc_var_init(&var), 0);

     assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_LIST), 0);

     assert_ptr_not_equal(amxc_var_add(uint64_t, &var, 123), NULL);

     assert_ptr_not_equal(amxc_var_add(uint64_t, &var, 456), NULL);


     assert_ptr_equal(amxc_var_add(uint64_t, NULL, 123), NULL);

     assert_ptr_equal(amxc_var_add(uint64_t, NULL, 456), NULL);


     list = amxc_var_constcast(amxc_llist_t, &var);

     assert_int_equal(amxc_llist_size(list), 2);

     amxc_var_clean(&var);


     assert_int_equal(amxc_var_init(&var), 0);

     assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_HTABLE), 0);

     assert_ptr_not_equal(amxc_var_add_key(uint64_t, &var, "B1", 123), NULL);

     assert_ptr_not_equal(amxc_var_add_key(uint64_t, &var, "B2", 456), NULL);


     assert_ptr_equal(amxc_var_add_key(uint64_t, NULL, "B1", 123), NULL);

     assert_ptr_equal(amxc_var_add_key(uint64_t, NULL, "B2", 456), NULL);


     table = amxc_var_constcast(amxc_htable_t, &var);

     assert_int_equal(amxc_htable_size(table), 2);

     amxc_var_clean(&var);

 }

amxc_macros.h

UNUSED
#define UNUSED
Definition: amxc_macros.h:70

amxc_variant.h
Ambiorix variant API header file.

amxc_variant_priv.h

amxc_htable_size
AMXC_INLINE size_t amxc_htable_size(const amxc_htable_t *const htable)
Calculates the size of the hash table.
Definition: amxc_htable.h:334

amxc_llist_size
size_t amxc_llist_size(const amxc_llist_t *const llist)
Calculates the size of the linked list.
Definition: amxc_llist.c:151

amxc_var_get_uint64_t
uint64_t amxc_var_get_uint64_t(const amxc_var_t *const var)
Conversion helper function.
Definition: variant_uint64.c:323

amxc_var_set_uint64_t
int amxc_var_set_uint64_t(amxc_var_t *const var, uint64_t val)
Setter helper function.
Definition: variant_uint64.c:310

AMXC_VAR_ID_UINT32
#define AMXC_VAR_ID_UINT32
Unsigned 32 bit integer variant id.
Definition: amxc_variant.h:176

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_INT16
#define AMXC_VAR_ID_INT16
Signed 16 bit integer variant id.
Definition: amxc_variant.h:146

AMXC_VAR_ID_NULL
#define AMXC_VAR_ID_NULL
Null variant type id (aka void)
Definition: amxc_variant.h:128

AMXC_VAR_ID_CSTRING
#define AMXC_VAR_ID_CSTRING
C-string variant id (aka char *), null terminated string.
Definition: amxc_variant.h:134

AMXC_VAR_ID_UINT8
#define AMXC_VAR_ID_UINT8
Unsigned 8 bit integer variant id.
Definition: amxc_variant.h:164

AMXC_VAR_ID_UINT64
#define AMXC_VAR_ID_UINT64
Unsigned 64 bit integer variant id.
Definition: amxc_variant.h:182

AMXC_VAR_ID_DOUBLE
#define AMXC_VAR_ID_DOUBLE
Double variant id.
Definition: amxc_variant.h:194

AMXC_VAR_ID_UINT16
#define AMXC_VAR_ID_UINT16
Unsigned 16 bit integer variant id.
Definition: amxc_variant.h:170

AMXC_VAR_ID_FD
#define AMXC_VAR_ID_FD
File descriptor variant id.
Definition: amxc_variant.h:218

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_TIMESTAMP
#define AMXC_VAR_ID_TIMESTAMP
Ambiorix timestamp variant id.
Definition: amxc_variant.h:224

AMXC_VAR_ID_FLOAT
#define AMXC_VAR_ID_FLOAT
Float variant id.
Definition: amxc_variant.h:188

AMXC_VAR_ID_LIST
#define AMXC_VAR_ID_LIST
Ambiorix Linked List variant id.
Definition: amxc_variant.h:206

AMXC_VAR_ID_HTABLE
#define AMXC_VAR_ID_HTABLE
Ambiorix Hash Table variant id.
Definition: amxc_variant.h:212

AMXC_VAR_ID_INT8
#define AMXC_VAR_ID_INT8
Signed 8 bit integer variant id.
Definition: amxc_variant.h:140

AMXC_VAR_ID_INT64
#define AMXC_VAR_ID_INT64
Signed 64 bit integer variant id.
Definition: amxc_variant.h:158

amxc_var_add_key
#define amxc_var_add_key(type, var, key, data)
Convenience macro for adding a variant to composite variant type.
Definition: amxc_variant.h:627

amxc_var_add
#define amxc_var_add(type, var, data)
Convenience macro for adding a variant to composite variant type.
Definition: amxc_variant.h:618

amxc_var_set_type
int amxc_var_set_type(amxc_var_t *const var, const uint32_t type)
Change the variant data type.
Definition: amxc_variant.c:261

amxc_var_dyncast
#define amxc_var_dyncast(type, var)
Dynamic cast a variant to a certain type.
Definition: amxc_variant.h:678

amxc_var_init
int amxc_var_init(amxc_var_t *const var)
Initializes a variant.
Definition: amxc_variant.c:223

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_clean
void amxc_var_clean(amxc_var_t *const var)
Clean-up and reset variant.
Definition: amxc_variant.c:237

amxc_var_convert
int amxc_var_convert(amxc_var_t *const dest, const amxc_var_t *src, const uint32_t type_id)
Converts one variant (source) to another variant(destination) using the specified variant type id.
Definition: amxc_variant.c:333

amxc_var_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_constcast
#define amxc_var_constcast(type, var)
Takes the content from a variant.
Definition: amxc_variant.h:722

_amxc_htable
The hash table structure.
Definition: amxc_htable.h:175

_amxc_llist
The linked list structure.
Definition: amxc_llist.h:228

_amxc_var
The variant struct definition.
Definition: amxc_variant.h:861

_amxc_var::data
void * data
Definition: amxc_variant.h:883

_amxc_var::type_id
uint32_t type_id
Definition: amxc_variant.h:864

var
static amxc_var_t * var
Definition: test_issue_58.c:77

test_variant_uint64_compare
void test_variant_uint64_compare(UNUSED void **state)
Definition: test_variant_uint64.c:208

test_variant_uint64_convert_to
void test_variant_uint64_convert_to(UNUSED void **state)
Definition: test_variant_uint64.c:90

test_variant_uint64_add
void test_variant_uint64_add(UNUSED void **state)
Definition: test_variant_uint64.c:254

test_variant_uint64_copy
void test_variant_uint64_copy(UNUSED void **state)
Definition: test_variant_uint64.c:75

test_variant_uint64_set_get
void test_variant_uint64_set_get(UNUSED void **state)
Definition: test_variant_uint64.c:235

test_variant_uint64.h