libamxc  1.10.3
C Generic Data Containers
test_variant_int64.c
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** SPDX-License-Identifier: BSD-2-Clause-Patent
4 **
5 ** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome
6 **
7 ** Redistribution and use in source and binary forms, with or without modification,
8 ** are permitted provided that the following conditions are met:
9 **
10 ** 1. Redistributions of source code must retain the above copyright notice,
11 ** this list of conditions and the following disclaimer.
12 **
13 ** 2. Redistributions in binary form must reproduce the above copyright notice,
14 ** this list of conditions and the following disclaimer in the documentation
15 ** and/or other materials provided with the distribution.
16 **
17 ** Subject to the terms and conditions of this license, each copyright holder
18 ** and contributor hereby grants to those receiving rights under this license
19 ** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
20 ** (except for failure to satisfy the conditions of this license) patent license
21 ** to make, have made, use, offer to sell, sell, import, and otherwise transfer
22 ** this software, where such license applies only to those patent claims, already
23 ** acquired or hereafter acquired, licensable by such copyright holder or contributor
24 ** that are necessarily infringed by:
25 **
26 ** (a) their Contribution(s) (the licensed copyrights of copyright holders and
27 ** non-copyrightable additions of contributors, in source or binary form) alone;
28 ** or
29 **
30 ** (b) combination of their Contribution(s) with the work of authorship to which
31 ** such Contribution(s) was added by such copyright holder or contributor, if,
32 ** at the time the Contribution is added, such addition causes such combination
33 ** to be necessarily infringed. The patent license shall not apply to any other
34 ** combinations which include the Contribution.
35 **
36 ** Except as expressly stated above, no rights or licenses from any copyright
37 ** holder or contributor is granted under this license, whether expressly, by
38 ** implication, estoppel or otherwise.
39 **
40 ** DISCLAIMER
41 **
42 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
43 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
46 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
48 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
49 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50 ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
51 ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
52 **
53 ****************************************************************************/
54 
55 #include <sys/time.h>
56 #include <sys/resource.h>
57 
58 #include <stdlib.h>
59 #include <stdio.h>
60 #include <stdarg.h>
61 #include <stddef.h>
62 #include <setjmp.h>
63 #include <inttypes.h>
64 #include <limits.h>
65 #include <unistd.h>
66 #include <fcntl.h>
67 #include <cmocka.h>
68 
69 #include <amxc/amxc_variant.h>
70 #include <amxc_variant_priv.h>
71 
72 #include "test_variant_int64.h"
73 
74 #include <amxc/amxc_macros.h>
75 void test_variant_int64_copy(UNUSED void** state) {
76  amxc_var_t var;
77  amxc_var_t copy_var;
78 
79  assert_int_equal(amxc_var_init(&var), 0);
80  assert_int_equal(amxc_var_init(&copy_var), 0);
81  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
82  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_INT64), 0);
83  assert_int_equal(var.type_id, AMXC_VAR_ID_INT64);
84  var.data.i64 = 4026531840;
85 
86  assert_int_equal(amxc_var_copy(&copy_var, &var), 0);
87  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT64);
88  assert_int_equal(copy_var.data.i64, 4026531840);
89 }
90 
91 void test_variant_int64_convert_to(UNUSED void** state) {
92  amxc_var_t var;
93  amxc_var_t copy_var;
94 
95 
96  assert_int_equal(amxc_var_init(&var), 0);
97  assert_int_equal(amxc_var_init(&copy_var), 0);
98  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
99  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_INT64), 0);
100  assert_int_equal(var.type_id, AMXC_VAR_ID_INT64);
101 
102  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_NULL), 0);
103  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_NULL);
104  assert_ptr_equal(copy_var.data.data, NULL);
105  var.data.i64 = 0x00000000F0000000;
106  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CSTRING), 0);
107  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_CSTRING);
108  assert_string_equal(copy_var.data.s, "4026531840");
109  var.data.i64 = 0xFFFFFFFF10000001;
110  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CSTRING), 0);
111  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_CSTRING);
112  assert_string_equal(copy_var.data.s, "-4026531839");
113 
114  var.data.i64 = 0x00000000F0000000;
115  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);
116  var.data.i64 = 0xFFFFFFFF10000001;
117  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);
118  var.data.i64 = 127;
119  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);
120  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT8);
121  assert_int_equal(copy_var.data.i8, 127);
122  var.data.i64 = -128;
123  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);
124  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT8);
125  assert_int_equal(copy_var.data.i8, -128);
126 
127  var.data.i64 = 0x00000000F0000000;
128  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);
129  var.data.i64 = 0xFFFFFFFF10000001;
130  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);
131  var.data.i64 = 1024;
132  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);
133  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT16);
134  assert_int_equal(copy_var.data.i16, 1024);
135  var.data.i64 = -1024;
136  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);
137  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT16);
138  assert_int_equal(copy_var.data.i16, -1024);
139 
140  var.data.i64 = 0x00000000F0000000;
141  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);
142  var.data.i64 = 0xFFFFFFFF10000001;
143  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);
144  var.data.i64 = 32766;
145  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);
146  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT32);
147  assert_int_equal(copy_var.data.i32, 32766);
148  var.data.i64 = -32766;
149  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);
150  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_INT32);
151  assert_int_equal(copy_var.data.i32, -32766);
152 
153  var.data.i64 = 256;
154  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT8), 0);
155  var.data.i64 = 255;
156  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT8), 0);
157  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT8);
158  assert_int_equal(copy_var.data.ui8, 255);
159  var.data.i64 = -255;
160  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT8), 0);
161  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT8);
162  assert_int_equal(copy_var.data.ui8, 255);
163 
164  var.data.i64 = 65536;
165  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT16), 0);
166  var.data.i64 = 65535;
167  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT16), 0);
168  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT16);
169  assert_int_equal(copy_var.data.ui16, 65535);
170  var.data.i64 = -65535;
171  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT16), 0);
172  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT16);
173  assert_int_equal(copy_var.data.ui16, 65535);
174 
175  var.data.i64 = 4294967296;
176  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT32), 0);
177  var.data.i64 = 4294967295;
178  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT32), 0);
179  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT32);
180  assert_int_equal(copy_var.data.ui32, 4294967295);
181  var.data.i64 = -4294967295;
182  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT32), 0);
183  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT32);
184  assert_int_equal(copy_var.data.ui32, 4294967295);
185 
186  var.data.i64 = 4294967295;
187  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
188  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT64);
189  assert_int_equal(copy_var.data.ui64, 4294967295);
190  var.data.i64 = -4294967295;
191  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
192  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_UINT64);
193  assert_int_equal(copy_var.data.ui64, 4294967295);
194 
195  var.data.i64 = 1000;
196  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_TIMESTAMP), 0);
197  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_TIMESTAMP);
198  var.data.i64 = -1000;
199  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_TIMESTAMP), 0);
200  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_TIMESTAMP);
201 
202  var.data.i64 = 0x00000000F0000000;
203  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
204  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_BOOL);
205  assert_true(copy_var.data.b);
206  var.data.i64 = 0x00;
207  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_BOOL), 0);
208  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_BOOL);
209  assert_false(copy_var.data.b);
210 
211  var.data.i64 = 4294967295;
212  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FLOAT), 0);
213  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_FLOAT);
214  assert_true(copy_var.data.f == 4294967295);
215 
216  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
217  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_DOUBLE);
218  assert_true(copy_var.data.d == 4294967295);
219 
220  struct rlimit nofile = { 0, 0 };
221  assert_int_equal(getrlimit(RLIMIT_NOFILE, &nofile), 0);
222 
223  var.data.i64 = 0xE0;
224  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FD), 0);
225  var.data.i64 = nofile.rlim_max + 1;
226  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FD), 0);
227  var.data.i64 = -1;
228  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FD), 0);
229  var.data.i64 = STDIN_FILENO;
230  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_FD), 0);
231  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_FD);
232  assert_int_equal(copy_var.data.fd, STDIN_FILENO);
233 
234  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CUSTOM_BASE), 0);
235 
236 }
237 
238 void test_variant_int64_compare(UNUSED void** state) {
239  amxc_var_t var1;
240  amxc_var_t var2;
241  int result = 0;
242 
243 
244  assert_int_equal(amxc_var_init(&var1), 0);
245  assert_int_equal(amxc_var_init(&var2), 0);
246  assert_int_equal(amxc_var_set_type(&var1, AMXC_VAR_ID_INT64), 0);
247  assert_int_equal(var1.type_id, AMXC_VAR_ID_INT64);
248  var1.data.i64 = 4026531840;
249  assert_int_equal(amxc_var_set_type(&var2, AMXC_VAR_ID_INT64), 0);
250  assert_int_equal(var2.type_id, AMXC_VAR_ID_INT64);
251  var2.data.i64 = -4026531839;
252 
253  assert_int_equal(amxc_var_compare(&var1, &var2, &result), 0);
254  assert_true(result > 0);
255 
256  assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);
257  assert_true(result < 0);
258 
259  var2.data.i64 = 4026531840;
260  assert_int_equal(amxc_var_compare(&var2, &var1, &result), 0);
261  assert_true(result == 0);
262 
263 }
264 
265 void test_variant_int64_set_get(UNUSED void** state) {
266  amxc_var_t var1;
267 
268  assert_int_equal(amxc_var_init(&var1), 0);
269  assert_int_equal(amxc_var_set_int64_t(&var1, 1024), 0);
270  assert_int_equal(var1.type_id, AMXC_VAR_ID_INT64);
271  assert_true(var1.data.i64 = 1024);
272 
273  assert_true(amxc_var_get_int64_t(&var1) == 1024);
274  assert_true(amxc_var_dyncast(int64_t, &var1) == 1024);
275 
276  assert_int_not_equal(amxc_var_set_int64_t(NULL, 1024), 0);
277  assert_true(amxc_var_get_int64_t(NULL) == 0);
278 
279  assert_int_equal(amxc_var_constcast(int64_t, &var1), 1024);
280  assert_int_equal(amxc_var_constcast(uint64_t, &var1), 0);
281  assert_int_equal(amxc_var_constcast(int64_t, NULL), 0);
282 }
283 
284 void test_variant_int64_add(UNUSED void** state) {
285  amxc_var_t var;
286  const amxc_llist_t* list = NULL;
287  const amxc_htable_t* table = NULL;
288 
289  assert_int_equal(amxc_var_init(&var), 0);
290  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_LIST), 0);
291  assert_ptr_not_equal(amxc_var_add(int64_t, &var, 123), NULL);
292  assert_ptr_not_equal(amxc_var_add(int64_t, &var, 456), NULL);
293 
294  assert_ptr_equal(amxc_var_add(int64_t, NULL, 123), NULL);
295  assert_ptr_equal(amxc_var_add(int64_t, NULL, 456), NULL);
296 
297  list = amxc_var_constcast(amxc_llist_t, &var);
298  assert_int_equal(amxc_llist_size(list), 2);
299  amxc_var_clean(&var);
300 
301  assert_int_equal(amxc_var_init(&var), 0);
302  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_HTABLE), 0);
303  assert_ptr_not_equal(amxc_var_add_key(int64_t, &var, "B1", 123), NULL);
304  assert_ptr_not_equal(amxc_var_add_key(int64_t, &var, "B2", 456), NULL);
305 
306  assert_ptr_equal(amxc_var_add_key(int64_t, NULL, "B1", 123), NULL);
307  assert_ptr_equal(amxc_var_add_key(int64_t, NULL, "B2", 456), NULL);
308 
309  table = amxc_var_constcast(amxc_htable_t, &var);
310  assert_int_equal(amxc_htable_size(table), 2);
311  amxc_var_clean(&var);
312 }
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_int64_t
int64_t amxc_var_get_int64_t(const amxc_var_t *const var)
Conversion helper function.
Definition: variant_int64.c:316
amxc_var_set_int64_t
int amxc_var_set_int64_t(amxc_var_t *const var, int64_t val)
Setter helper function.
Definition: variant_int64.c:303
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_int64_compare
void test_variant_int64_compare(UNUSED void **state)
Definition: test_variant_int64.c:238
test_variant_int64_add
void test_variant_int64_add(UNUSED void **state)
Definition: test_variant_int64.c:284
test_variant_int64_convert_to
void test_variant_int64_convert_to(UNUSED void **state)
Definition: test_variant_int64.c:91
test_variant_int64_set_get
void test_variant_int64_set_get(UNUSED void **state)
Definition: test_variant_int64.c:265
test_variant_int64_copy
void test_variant_int64_copy(UNUSED void **state)
Definition: test_variant_int64.c:75
test_variant_int64.h