libamxc  1.10.3
C Generic Data Containers
test_variant_timestamp.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 <stdlib.h>
56 #include <stdio.h>
57 #include <stdarg.h>
58 #include <stddef.h>
59 #include <setjmp.h>
60 #include <cmocka.h>
61 #include <unistd.h>
62 
63 #include <amxc/amxc_variant.h>
64 #include <amxc_variant_priv.h>
65 
66 #include "test_variant_timestamp.h"
67 
68 #include <amxc/amxc_macros.h>
69 void test_variant_ts_copy(UNUSED void** state) {
70  amxc_var_t var;
71  amxc_var_t copy_var;
72  amxc_ts_t now;
73 
74  amxc_ts_now(&now);
75 
76  assert_int_equal(amxc_var_init(&var), 0);
77  assert_int_equal(amxc_var_init(&copy_var), 0);
78  assert_int_equal(var.type_id, AMXC_VAR_ID_NULL);
79  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_TIMESTAMP), 0);
80  assert_int_equal(var.type_id, AMXC_VAR_ID_TIMESTAMP);
81  assert_int_equal(amxc_var_set(amxc_ts_t, &var, &now), 0);
82 
83  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_NULL);
84  assert_int_equal(amxc_var_copy(&copy_var, &var), 0);
85  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_TIMESTAMP);
86  assert_int_equal(copy_var.data.ts.sec, now.sec);
87 
88  amxc_var_clean(&var);
89  amxc_var_clean(&copy_var);
90 }
91 
92 void test_variant_ts_convert_to_string(UNUSED void** state) {
93  amxc_var_t var;
94  amxc_var_t copy_var;
95 
96  assert_int_equal(amxc_var_init(&var), 0);
97  assert_int_equal(amxc_var_init(&copy_var), 0);
98  assert_int_equal(amxc_var_set_type(&var, AMXC_VAR_ID_TIMESTAMP), 0);
99  amxc_var_dump(&var, STDOUT_FILENO);
100 
101  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_CSTRING), 0);
102  assert_string_equal(copy_var.data.s, "0001-01-01T00:00:00Z");
103  amxc_var_dump(&copy_var, STDOUT_FILENO);
104  amxc_var_clean(&var);
105  amxc_var_clean(&copy_var);
106 }
107 
108 void test_variant_ts_convert_to_int64(UNUSED void** state) {
109  amxc_var_t var;
110  amxc_var_t copy_var;
111  amxc_ts_t now;
112 
113  amxc_ts_now(&now);
114 
115  assert_int_equal(amxc_var_init(&var), 0);
116  assert_int_equal(amxc_var_init(&copy_var), 0);
117  assert_int_equal(amxc_var_set(amxc_ts_t, &var, &now), 0);
118  assert_int_equal(var.type_id, AMXC_VAR_ID_TIMESTAMP);
119 
120  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT64), 0);
121  assert_int_equal(copy_var.data.i64, now.sec);
122 
123  amxc_var_clean(&var);
124  amxc_var_clean(&copy_var);
125 }
126 
127 void test_variant_ts_convert_to_other_int(UNUSED void** state) {
128  amxc_var_t var;
129  amxc_var_t copy_var;
130  amxc_ts_t now;
131 
132  amxc_ts_now(&now);
133 
134  assert_int_equal(amxc_var_init(&var), 0);
135  assert_int_equal(amxc_var_init(&copy_var), 0);
136  assert_int_equal(amxc_var_set(amxc_ts_t, &var, &now), 0);
137  assert_int_equal(var.type_id, AMXC_VAR_ID_TIMESTAMP);
138 
139  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT8), 0);
140  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT16), 0);
141  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_INT32), 0);
142  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT8), 0);
143  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT16), 0);
144  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT32), 0);
145  assert_int_not_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_UINT64), 0);
146 
147  amxc_var_clean(&var);
148  amxc_var_clean(&copy_var);
149 }
150 
151 void test_variant_ts_convert_to_double(UNUSED void** state) {
152  amxc_var_t var;
153  amxc_var_t copy_var;
154  amxc_ts_t now;
155 
156  amxc_ts_now(&now);
157 
158  assert_int_equal(amxc_var_init(&var), 0);
159  assert_int_equal(amxc_var_init(&copy_var), 0);
160  assert_int_equal(amxc_var_set(amxc_ts_t, &var, &now), 0);
161  assert_int_equal(var.type_id, AMXC_VAR_ID_TIMESTAMP);
162 
163  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_DOUBLE), 0);
164  assert_true(copy_var.data.d == var.data.ts.sec);
165 
166  amxc_var_clean(&var);
167  amxc_var_clean(&copy_var);
168 }
169 
170 void test_variant_ts_convert_to_any(UNUSED void** state) {
171  amxc_var_t var;
172  amxc_var_t copy_var;
173  amxc_ts_t now;
174 
175  amxc_ts_now(&now);
176 
177  assert_int_equal(amxc_var_init(&var), 0);
178  assert_int_equal(amxc_var_init(&copy_var), 0);
179  assert_int_equal(amxc_var_set(amxc_ts_t, &var, &now), 0);
180  assert_int_equal(var.type_id, AMXC_VAR_ID_TIMESTAMP);
181 
182  assert_int_equal(amxc_var_convert(&copy_var, &var, AMXC_VAR_ID_ANY), 0);
183  assert_int_equal(copy_var.type_id, AMXC_VAR_ID_TIMESTAMP);
184 
185  amxc_var_clean(&var);
186  amxc_var_clean(&copy_var);
187 }
188 
189 
190 void test_variant_ts_compare(UNUSED void** state) {
191  amxc_var_t var1;
192  amxc_var_t var2;
193  amxc_var_t var3;
194  int result = 0;
195 
196  assert_int_equal(amxc_var_init(&var1), 0);
197  assert_int_equal(amxc_var_init(&var2), 0);
198  assert_int_equal(amxc_var_init(&var3), 0);
199 
200  assert_int_equal(amxc_var_set(cstring_t, &var1, "2020-06-19T09:08:16Z"), 0);
201  assert_int_equal(amxc_var_set(cstring_t, &var2, "2020-06-19T09:08:17Z"), 0);
202  assert_int_equal(amxc_var_convert(&var3, &var1, AMXC_VAR_ID_TIMESTAMP), 0);
203 
204  assert_int_equal(amxc_var_compare(&var1, &var3, &result), 0);
205  assert_true(result == 0);
206  assert_int_equal(amxc_var_compare(&var2, &var3, &result), 0);
207  assert_true(result > 0);
208  assert_int_equal(amxc_var_compare(&var3, &var2, &result), 0);
209  assert_true(result < 0);
210 
211  amxc_var_clean(&var1);
212  amxc_var_clean(&var2);
213  amxc_var_clean(&var3);
214 }
215 
216 void test_variant_ts_get(UNUSED void** state) {
217  amxc_var_t var1;
218  amxc_var_t var2;
219  amxc_ts_t* ts = NULL;
220  const amxc_ts_t* cts = NULL;
221 
222  assert_int_equal(amxc_var_init(&var1), 0);
223  assert_int_equal(amxc_var_init(&var2), 0);
224 
225  assert_int_equal(amxc_var_set(cstring_t, &var1, "2020-06-19T09:08:16Z"), 0);
226  ts = amxc_var_dyncast(amxc_ts_t, &var1);
227  assert_ptr_not_equal(ts, NULL);
228  assert_int_equal(amxc_var_set(amxc_ts_t, &var2, ts), 0);
229  cts = amxc_var_constcast(amxc_ts_t, &var2);
230  assert_ptr_not_equal(cts, NULL);
231  cts = amxc_var_constcast(amxc_ts_t, &var1);
232  assert_ptr_equal(cts, NULL);
233 
234  assert_int_not_equal(amxc_var_set(amxc_ts_t, NULL, ts), 0);
235  assert_int_not_equal(amxc_var_set(amxc_ts_t, &var2, NULL), 0);
236 
237  assert_ptr_equal(amxc_var_dyncast(amxc_ts_t, NULL), NULL);
238  assert_ptr_equal(amxc_var_constcast(amxc_ts_t, NULL), NULL);
239  free(ts);
240 
241  assert_int_equal(amxc_var_set(cstring_t, &var1, "THIS is NOT a TIMESTAMP"), 0);
242  ts = amxc_var_dyncast(amxc_ts_t, &var1);
243  assert_ptr_equal(ts, NULL);
244 
245  amxc_var_clean(&var1);
246  amxc_var_clean(&var2);
247  free(ts);
248 }
249 
250 void test_variant_ts_add_to_composite_types(UNUSED void** state) {
251  amxc_var_t var1;
252  amxc_var_t var2;
253  amxc_ts_t now;
254 
255  amxc_ts_now(&now);
256 
257  assert_int_equal(amxc_var_init(&var1), 0);
258  assert_int_equal(amxc_var_init(&var2), 0);
259 
260  amxc_var_set_type(&var1, AMXC_VAR_ID_LIST);
261  assert_ptr_not_equal(amxc_var_add(amxc_ts_t, &var1, &now), NULL);
262  assert_ptr_not_equal(amxc_var_add(amxc_ts_t, &var1, NULL), NULL);
263 
264  amxc_var_set_type(&var2, AMXC_VAR_ID_HTABLE);
265  assert_ptr_not_equal(amxc_var_add_key(amxc_ts_t, &var2, "current_time", &now), NULL);
266  assert_ptr_not_equal(amxc_var_add_key(amxc_ts_t, &var2, "uknown_time", NULL), NULL);
267 
268  assert_ptr_equal(amxc_var_add(amxc_ts_t, NULL, &now), NULL);
269  assert_ptr_equal(amxc_var_add_key(amxc_ts_t, NULL, "current_time", &now), NULL);
270 
271  amxc_var_clean(&var1);
272  amxc_var_clean(&var2);
273 }
amxc_macros.h
UNUSED
#define UNUSED
Definition: amxc_macros.h:70
amxc_variant.h
Ambiorix variant API header file.
cstring_t
#define cstring_t
Convenience macro.
Definition: amxc_variant.h:584
amxc_variant_priv.h
amxc_ts_now
int amxc_ts_now(amxc_ts_t *tsp)
Takes current time as unix epoch time.
Definition: amxc_timestamp.c:301
AMXC_VAR_ID_UINT32
#define AMXC_VAR_ID_UINT32
Unsigned 32 bit integer variant id.
Definition: amxc_variant.h:176
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_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_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_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
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_set
#define amxc_var_set(type, var, data)
Convenience macro for setting a value in a variant.
Definition: amxc_variant.h:609
amxc_var_convert
int amxc_var_convert(amxc_var_t *const dest, const amxc_var_t *src, const uint32_t type_id)
Converts one variant (source) to another variant(destination) using the specified variant type id.
Definition: amxc_variant.c:333
amxc_var_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_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
_timestamp
The timestamp structure (unix epoch time).
Definition: amxc_timestamp.h:108
_timestamp::sec
int64_t sec
Definition: amxc_timestamp.h:109
var
static amxc_var_t * var
Definition: test_issue_58.c:77
test_variant_ts_convert_to_double
void test_variant_ts_convert_to_double(UNUSED void **state)
Definition: test_variant_timestamp.c:151
test_variant_ts_get
void test_variant_ts_get(UNUSED void **state)
Definition: test_variant_timestamp.c:216
test_variant_ts_add_to_composite_types
void test_variant_ts_add_to_composite_types(UNUSED void **state)
Definition: test_variant_timestamp.c:250
test_variant_ts_convert_to_string
void test_variant_ts_convert_to_string(UNUSED void **state)
Definition: test_variant_timestamp.c:92
test_variant_ts_convert_to_int64
void test_variant_ts_convert_to_int64(UNUSED void **state)
Definition: test_variant_timestamp.c:108
test_variant_ts_compare
void test_variant_ts_compare(UNUSED void **state)
Definition: test_variant_timestamp.c:190
test_variant_ts_copy
void test_variant_ts_copy(UNUSED void **state)
Definition: test_variant_timestamp.c:69
test_variant_ts_convert_to_any
void test_variant_ts_convert_to_any(UNUSED void **state)
Definition: test_variant_timestamp.c:170
test_variant_ts_convert_to_other_int
void test_variant_ts_convert_to_other_int(UNUSED void **state)
Definition: test_variant_timestamp.c:127
test_variant_timestamp.h