libamxp  1.4.0
Patterns C Implementation
Functions
test_expression_node.c File Reference
#include <sys/signalfd.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <fcntl.h>
#include <cmocka.h>
#include <amxc/amxc_macros.h>
#include <amxc/amxc.h>
#include <amxp/amxp_expression.h>
#include "../../include_priv/amxp_expr_priv.h"
#include "test_expression_node.h"

Go to the source code of this file.

Functions

void test_node_tree_and (UNUSED void **state)
 
void test_node_tree_or (UNUSED void **state)
 
void test_node_tree_not (UNUSED void **state)
 
void test_node_tree_compop (UNUSED void **state)
 
void test_node_tree_field (UNUSED void **state)
 
void test_node_tree_value_list (UNUSED void **state)
 
void test_node_tree_bool_func (UNUSED void **state)
 
void test_node_tree_value_func (UNUSED void **state)
 

Function Documentation

◆ test_node_tree_and()

void test_node_tree_and ( UNUSED void **  state)

Definition at line 74 of file test_expression_node.c.

74  {
75  amxp_expr_node_t* node = NULL;
76  amxp_expr_node_t* left = NULL;
77  amxp_expr_node_t* right = NULL;
78  amxc_var_t* b1 = NULL;
79  amxc_var_t* b2 = NULL;
80  amxp_expr_t expression;
81 
82  assert_int_equal(amxp_expr_init(&expression, ""), 0);
83 
84  amxp_expr_node_new(&node, amxp_expr_and);
85  amxp_expr_node_new(&left, amxp_expr_value);
86  amxp_expr_node_new(&right, amxp_expr_value);
87  amxp_expr_node_set_left(node, left);
88  amxp_expr_node_set_right(node, right);
89 
90  amxc_var_new(&b1);
91  amxc_var_new(&b2);
92 
93  amxc_var_set(bool, b1, true);
94  amxc_var_set(bool, b2, true);
95 
96  amxp_expr_node_set_value(left, b1);
97  amxp_expr_node_set_value(right, b2);
98 
99  assert_true(amxp_expr_node_eval(&expression, node));
100 
101  amxc_var_set(bool, b1, false);
102 
103  assert_false(amxp_expr_node_eval(&expression, node));
104 
105  amxc_var_set(bool, b1, true);
106  amxc_var_set(bool, b2, false);
107 
108  assert_false(amxp_expr_node_eval(&expression, node));
109 
110  amxp_expr_node_delete(&node);
111  amxp_expr_clean(&expression);
112 }
amxp_expr_node_new
PRIVATE void amxp_expr_node_new(amxp_expr_node_t **node, amxp_expr_node_type_t type)
Definition: amxp_expression_node.c:99
amxp_expr_node_set_left
PRIVATE void amxp_expr_node_set_left(amxp_expr_node_t *node, amxp_expr_node_t *left)
Definition: amxp_expression_node.c:159
amxp_expr_node_set_right
PRIVATE void amxp_expr_node_set_right(amxp_expr_node_t *node, amxp_expr_node_t *right)
Definition: amxp_expression_node.c:164
amxp_expr_node_delete
PRIVATE void amxp_expr_node_delete(amxp_expr_node_t **node)
Definition: amxp_expression_node.c:104
amxp_expr_value
@ amxp_expr_value
Definition: amxp_expr_priv.h:77
amxp_expr_and
@ amxp_expr_and
Definition: amxp_expr_priv.h:82
amxp_expr_node_set_value
PRIVATE void amxp_expr_node_set_value(amxp_expr_node_t *node, amxc_var_t *value)
Definition: amxp_expression_node.c:169
amxp_expr_node_eval
PRIVATE bool amxp_expr_node_eval(amxp_expr_t *expr, amxp_expr_node_t *node)
Definition: amxp_expression_node.c:247
amxp_expr_clean
void amxp_expr_clean(amxp_expr_t *expr)
Clean-up the expression structure.
Definition: amxp_expression_main.c:766
amxp_expr_init
amxp_expr_status_t amxp_expr_init(amxp_expr_t *expr, const char *expression)
Initializes an expression structure.
Definition: amxp_expression_main.c:696
_amxp_expr_node
Definition: amxp_expr_priv.h:101
_amxp_expr
Definition: amxp_expression.h:245

◆ test_node_tree_bool_func()

void test_node_tree_bool_func ( UNUSED void **  state)

Definition at line 337 of file test_expression_node.c.

337  {
338  amxp_expr_node_t* node = NULL;
339  amxp_expr_node_t* value = NULL;
340  amxp_expr_t expression;
341  amxc_var_t* data = NULL;
342  amxc_var_t* list = NULL;
343 
344  amxc_var_new(&data);
345  amxc_var_set_type(data, AMXC_VAR_ID_HTABLE);
346  list = amxc_var_add_key(amxc_llist_t, data, "list", NULL);
347 
348  assert_int_equal(amxp_expr_init(&expression, ""), 0);
349  expression.priv = data;
350  expression.get_field = amxp_expr_get_field_var;
351 
352  amxp_expr_node_new(&node, amxp_expr_bool_func);
353  amxp_expr_node_set_function(node, strdup("is_empty"));
354 
355  amxp_expr_node_new(&value, amxp_expr_field);
356  amxp_expr_node_set_field(value, strdup("list"));
357  amxp_expr_node_add_value(node, value);
358 
359  assert_true(amxp_expr_node_eval(&expression, node));
360 
361  amxc_var_add(cstring_t, list, "123");
362 
363  assert_false(amxp_expr_node_eval(&expression, node));
364 
365  amxp_expr_node_delete(&node);
366  amxp_expr_clean(&expression);
367  amxc_var_delete(&data);
368 }
amxp_expr_node_set_field
PRIVATE void amxp_expr_node_set_field(amxp_expr_node_t *node, char *field)
Definition: amxp_expression_node.c:177
amxp_expr_bool_func
@ amxp_expr_bool_func
Definition: amxp_expr_priv.h:79
amxp_expr_field
@ amxp_expr_field
Definition: amxp_expr_priv.h:80
amxp_expr_node_set_function
PRIVATE void amxp_expr_node_set_function(amxp_expr_node_t *node, char *func_name)
Definition: amxp_expression_node.c:173
amxp_expr_node_add_value
PRIVATE void amxp_expr_node_add_value(amxp_expr_node_t *node, amxp_expr_node_t *value)
Definition: amxp_expression_node.c:185
amxp_expr_get_field_var
amxp_expr_status_t amxp_expr_get_field_var(amxp_expr_t *expr, amxc_var_t *value, const char *path, void *priv)
Variant field fetcher implementation.
_amxp_expr::get_field
amxp_expr_get_field_t get_field
Definition: amxp_expression.h:257
_amxp_expr::priv
void * priv
Definition: amxp_expression.h:258

◆ test_node_tree_compop()

void test_node_tree_compop ( UNUSED void **  state)

Definition at line 186 of file test_expression_node.c.

186  {
187  amxp_expr_node_t* node = NULL;
188  amxp_expr_node_t* left = NULL;
189  amxp_expr_node_t* right = NULL;
190  amxc_var_t* b1 = NULL;
191  amxc_var_t* b2 = NULL;
192  amxp_expr_t expression;
193 
194  assert_int_equal(amxp_expr_init(&expression, ""), 0);
195 
196  amxp_expr_node_new(&node, amxp_expr_compare_oper);
197  amxp_expr_node_new(&left, amxp_expr_value);
198  amxp_expr_node_new(&right, amxp_expr_value);
199  amxp_expr_node_set_left(node, left);
200  amxp_expr_node_set_right(node, right);
201 
202  amxc_var_new(&b1);
203  amxc_var_new(&b2);
204 
205  amxc_var_set(int32_t, b1, 1);
206  amxc_var_set(int32_t, b2, 10);
207 
208  amxp_expr_node_set_value(left, b1);
209  amxp_expr_node_set_value(right, b2);
210  amxp_expr_node_set_compop(node, amxp_expr_comp_equal);
211 
212  assert_false(amxp_expr_node_eval(&expression, node));
213 
214  amxp_expr_node_set_compop(node, amxp_expr_comp_not_equal);
215 
216  assert_true(amxp_expr_node_eval(&expression, node));
217 
218  amxp_expr_node_set_compop(node, amxp_expr_comp_lesser);
219 
220  assert_true(amxp_expr_node_eval(&expression, node));
221 
222  amxp_expr_node_set_compop(node, amxp_expr_comp_bigger);
223 
224  assert_false(amxp_expr_node_eval(&expression, node));
225 
226  amxp_expr_node_delete(&node);
227  amxp_expr_clean(&expression);
228 }
amxp_expr_node_set_compop
PRIVATE void amxp_expr_node_set_compop(amxp_expr_node_t *node, amxp_expr_comp_t comop)
Definition: amxp_expression_node.c:181
amxp_expr_compare_oper
@ amxp_expr_compare_oper
Definition: amxp_expr_priv.h:76
amxp_expr_comp_lesser
@ amxp_expr_comp_lesser
Definition: amxp_expr_priv.h:89
amxp_expr_comp_equal
@ amxp_expr_comp_equal
Definition: amxp_expr_priv.h:87
amxp_expr_comp_bigger
@ amxp_expr_comp_bigger
Definition: amxp_expr_priv.h:90
amxp_expr_comp_not_equal
@ amxp_expr_comp_not_equal
Definition: amxp_expr_priv.h:88

◆ test_node_tree_field()

void test_node_tree_field ( UNUSED void **  state)

Definition at line 230 of file test_expression_node.c.

230  {
231  amxp_expr_node_t* node = NULL;
232  amxp_expr_node_t* left = NULL;
233  amxp_expr_node_t* right = NULL;
234  amxc_var_t* b1 = NULL;
235  amxc_var_t* b2 = NULL;
236  amxc_var_t* t = NULL;
237  amxp_expr_t expression;
238 
239  amxc_var_new(&b1);
240  amxc_var_new(&b2);
241 
242  assert_int_equal(amxp_expr_init(&expression, ""), 0);
243  expression.priv = b1;
244  expression.get_field = amxp_expr_get_field_var;
245 
246  amxp_expr_node_new(&node, amxp_expr_compare_oper);
247  amxp_expr_node_new(&left, amxp_expr_field);
248  amxp_expr_node_new(&right, amxp_expr_value);
249  amxp_expr_node_set_left(node, left);
250  amxp_expr_node_set_right(node, right);
251 
252  amxc_var_set_type(b1, AMXC_VAR_ID_HTABLE);
253  t = amxc_var_add_key(amxc_htable_t, b1, "test", NULL);
254  amxc_var_add_key(int32_t, t, "value", 1);
255  amxc_var_set(int32_t, b2, 10);
256 
257  amxp_expr_node_set_field(left, strdup("test.value"));
258  amxp_expr_node_set_value(right, b2);
259  amxp_expr_node_set_compop(node, amxp_expr_comp_equal);
260 
261  assert_false(amxp_expr_node_eval(&expression, node));
262 
263  amxp_expr_node_set_compop(node, amxp_expr_comp_not_equal);
264 
265  assert_true(amxp_expr_node_eval(&expression, node));
266 
267  amxp_expr_node_set_compop(node, amxp_expr_comp_lesser);
268 
269  assert_true(amxp_expr_node_eval(&expression, node));
270 
271  amxp_expr_node_set_compop(node, amxp_expr_comp_bigger);
272 
273  assert_false(amxp_expr_node_eval(&expression, node));
274 
275  amxp_expr_node_delete(&node);
276  amxp_expr_clean(&expression);
277  amxc_var_delete(&b1);
278 }

◆ test_node_tree_not()

void test_node_tree_not ( UNUSED void **  state)

Definition at line 158 of file test_expression_node.c.

158  {
159  amxp_expr_node_t* node = NULL;
160  amxp_expr_node_t* left = NULL;
161  amxc_var_t* b1 = NULL;
162  amxp_expr_t expression;
163 
164  assert_int_equal(amxp_expr_init(&expression, ""), 0);
165 
166  amxp_expr_node_new(&node, amxp_expr_not);
167  amxp_expr_node_new(&left, amxp_expr_value);
168  amxp_expr_node_set_left(node, left);
169 
170  amxc_var_new(&b1);
171 
172  amxc_var_set(bool, b1, true);
173 
174  amxp_expr_node_set_value(left, b1);
175 
176  assert_false(amxp_expr_node_eval(&expression, node));
177 
178  amxc_var_set(bool, b1, false);
179 
180  assert_true(amxp_expr_node_eval(&expression, node));
181 
182  amxp_expr_node_delete(&node);
183  amxp_expr_clean(&expression);
184 }
amxp_expr_not
@ amxp_expr_not
Definition: amxp_expr_priv.h:81

◆ test_node_tree_or()

void test_node_tree_or ( UNUSED void **  state)

Definition at line 114 of file test_expression_node.c.

114  {
115  amxp_expr_node_t* node = NULL;
116  amxp_expr_node_t* left = NULL;
117  amxp_expr_node_t* right = NULL;
118  amxc_var_t* b1 = NULL;
119  amxc_var_t* b2 = NULL;
120  amxp_expr_t expression;
121 
122  assert_int_equal(amxp_expr_init(&expression, ""), 0);
123 
124  amxp_expr_node_new(&node, amxp_expr_or);
125  amxp_expr_node_new(&left, amxp_expr_value);
126  amxp_expr_node_new(&right, amxp_expr_value);
127  amxp_expr_node_set_left(node, left);
128  amxp_expr_node_set_right(node, right);
129 
130  amxc_var_new(&b1);
131  amxc_var_new(&b2);
132 
133  amxc_var_set(bool, b1, true);
134  amxc_var_set(bool, b2, true);
135 
136  amxp_expr_node_set_value(left, b1);
137  amxp_expr_node_set_value(right, b2);
138 
139  assert_true(amxp_expr_node_eval(&expression, node));
140 
141  amxc_var_set(bool, b1, false);
142 
143  assert_true(amxp_expr_node_eval(&expression, node));
144 
145  amxc_var_set(bool, b1, true);
146  amxc_var_set(bool, b2, false);
147 
148  assert_true(amxp_expr_node_eval(&expression, node));
149 
150  amxc_var_set(bool, b1, false);
151 
152  assert_false(amxp_expr_node_eval(&expression, node));
153 
154  amxp_expr_node_delete(&node);
155  amxp_expr_clean(&expression);
156 }
amxp_expr_or
@ amxp_expr_or
Definition: amxp_expr_priv.h:83

◆ test_node_tree_value_func()

void test_node_tree_value_func ( UNUSED void **  state)

Definition at line 370 of file test_expression_node.c.

370  {
371  amxp_expr_node_t* node = NULL;
372  amxp_expr_node_t* left = NULL;
373  amxp_expr_node_t* right = NULL;
374  amxp_expr_node_t* value = NULL;
375  amxp_expr_t expression;
376  amxc_var_t* data = NULL;
377  amxc_var_t* number = NULL;
378 
379  amxc_var_new(&data);
380  amxc_var_set_type(data, AMXC_VAR_ID_HTABLE);
381  amxc_var_add_key(int32_t, data, "key1", 10);
382 
383  assert_int_equal(amxp_expr_init(&expression, ""), 0);
384  expression.priv = data;
385  expression.get_field = amxp_expr_get_field_var;
386 
387  amxp_expr_node_new(&node, amxp_expr_compare_oper);
388  amxp_expr_node_new(&left, amxp_expr_value);
389  amxp_expr_node_new(&right, amxp_expr_value_func);
390  amxp_expr_node_set_left(node, left);
391  amxp_expr_node_set_right(node, right);
392 
393  amxp_expr_node_set_function(right, strdup("first_existing"));
394 
395  amxc_var_new(&number);
396  amxc_var_set(int32_t, number, 10);
397  amxp_expr_node_set_value(left, number);
398 
399  amxp_expr_node_new(&value, amxp_expr_field);
400  amxp_expr_node_set_field(value, strdup("key1"));
401  amxp_expr_node_add_value(right, value);
402  amxp_expr_node_new(&value, amxp_expr_field);
403  amxp_expr_node_set_field(value, strdup("key2"));
404  amxp_expr_node_add_value(right, value);
405 
406  amxp_expr_node_set_compop(node, amxp_expr_comp_equal);
407 
408  assert_true(amxp_expr_node_eval(&expression, node));
409 
410  amxp_expr_node_delete(&node);
411  amxp_expr_clean(&expression);
412  amxc_var_delete(&data);
413 }
amxp_expr_value_func
@ amxp_expr_value_func
Definition: amxp_expr_priv.h:78

◆ test_node_tree_value_list()

void test_node_tree_value_list ( UNUSED void **  state)

Definition at line 281 of file test_expression_node.c.

281  {
282  amxp_expr_node_t* node = NULL;
283  amxp_expr_node_t* left = NULL;
284  amxp_expr_node_t* right = NULL;
285  amxp_expr_node_t* value = NULL;
286  amxp_expr_t expression;
287 
288  amxc_var_t* b1 = NULL;
289  amxc_var_t* b2 = NULL;
290 
291  assert_int_equal(amxp_expr_init(&expression, ""), 0);
292 
293  amxp_expr_node_new(&node, amxp_expr_compare_oper);
294  amxp_expr_node_new(&left, amxp_expr_value);
295  amxp_expr_node_new(&right, amxp_expr_value);
296  amxp_expr_node_set_left(node, left);
297  amxp_expr_node_set_right(node, right);
298 
299  amxc_var_new(&b1);
300  amxc_var_set(int32_t, b1, 1);
301  amxp_expr_node_set_value(left, b1);
302 
303  amxc_var_new(&b2);
304  amxp_expr_node_new(&value, amxp_expr_value);
305  amxc_var_set(int32_t, b2, 1);
306  amxp_expr_node_set_value(value, b2);
307  amxp_expr_node_add_value(right, value);
308 
309  amxc_var_new(&b2);
310  amxp_expr_node_new(&value, amxp_expr_value);
311  amxc_var_set(int32_t, b2, 2);
312  amxp_expr_node_set_value(value, b2);
313  amxp_expr_node_add_value(right, value);
314 
315  amxc_var_new(&b2);
316  amxp_expr_node_new(&value, amxp_expr_value);
317  amxc_var_set(int32_t, b2, 3);
318  amxp_expr_node_set_value(value, b2);
319  amxp_expr_node_add_value(right, value);
320 
321  amxp_expr_node_set_compop(node, amxp_expr_comp_in);
322 
323  assert_true(amxp_expr_node_eval(&expression, node));
324 
325  amxc_var_set(int32_t, b1, 10);
326 
327  assert_false(amxp_expr_node_eval(&expression, node));
328 
329  amxc_var_set(int32_t, b1, 3);
330 
331  assert_true(amxp_expr_node_eval(&expression, node));
332 
333  amxp_expr_node_delete(&node);
334  amxp_expr_clean(&expression);
335 }
amxp_expr_comp_in
@ amxp_expr_comp_in
Definition: amxp_expr_priv.h:95