libamxb  4.8.2
Bus Agnostic C API
Functions | Variables
test_amxb_e2e.c File Reference
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <dlfcn.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <signal.h>
#include <amxc/amxc.h>
#include <amxp/amxp.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_path.h>
#include <amxb/amxb.h>
#include <amxb/amxb_register.h>
#include <amxb/amxb_be_intf.h>
#include <amxo/amxo.h>
#include "dummy_be.h"
#include "test_amxb_e2e.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

int test_amxb_e2e_setup (UNUSED void **state)
 
int test_amxb_e2e_teardown (UNUSED void **state)
 
void test_amxb_call (UNUSED void **state)
 
void test_amxb_get (UNUSED void **state)
 
void test_amxb_get_instances (UNUSED void **state)
 
void test_amxb_set (UNUSED void **state)
 
void test_amxb_set_multiple (UNUSED void **state)
 
void test_amxb_set_multiple_same_path (UNUSED void **state)
 
void test_amxb_set_multiple_allow_partial (UNUSED void **state)
 
void test_amxb_set_multiple_optional_params (UNUSED void **state)
 
void test_amxb_add (UNUSED void **state)
 
void test_amxb_del (UNUSED void **state)
 
void test_search_path_expr_func (UNUSED void **state)
 
void test_amxb_get_supported (UNUSED void **state)
 
void test_amxb_set_config (UNUSED void **state)
 
void test_amxb_resolve_failure (UNUSED void **state)
 
void test_amxb_who_has (UNUSED void **state)
 
void test_amxb_who_has_cache_set_size (UNUSED void **state)
 
void test_amxb_who_has_cache_remove_path (UNUSED void **state)
 
void test_amxb_cache_disable (UNUSED void **state)
 

Variables

static amxb_bus_ctx_t * bus_ctx = NULL
 
static amxd_dm_t dm
 
static amxo_parser_t parser
 

Function Documentation

◆ test_amxb_add()

void test_amxb_add ( UNUSED void **  state)

Definition at line 440 of file test_amxb_e2e.c.

440  {
441  amxc_var_t values;
442  amxc_var_t ret;
443  amxc_var_t* results = NULL;
444  amxc_var_init(&ret);
445  amxc_var_init(&values);
446 
447  amxc_var_set_type(&values, AMXC_VAR_ID_HTABLE);
448  amxc_var_add_key(bool, &values, "Enable", false);
449  amxc_var_add_key(cstring_t, &values, "Status", "Unknown");
450 
451  assert_int_equal(amxb_add(bus_ctx, "Device.Ethernet.Interface", 0, NULL, &values, &ret, 5), 0);
452  assert_int_equal(amxb_get(bus_ctx, "Device.Ethernet.Interface.6.", 0, &values, 5), 0);
453  assert_int_equal(amxc_var_type_of(&values), AMXC_VAR_ID_LIST);
454  assert_int_equal(amxc_llist_size(&values.data.vl), 1);
455  amxc_var_dump(&values, STDOUT_FILENO);
456  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
457  results = amxc_var_get_key(results, "Device.Ethernet.Interface.6.", AMXC_VAR_FLAG_DEFAULT);
458  results = amxc_var_get_key(results, "Status", AMXC_VAR_FLAG_DEFAULT);
459  assert_string_equal(amxc_var_constcast(cstring_t, results), "Unknown");
460 
461  assert_int_not_equal(amxb_add(bus_ctx, "Device.Ethernet.Link", 0, NULL, NULL, NULL, 5), 0);
462 
463  amxc_var_clean(&ret);
464  amxc_var_clean(&values);
465 }
amxb_get
int amxb_get(amxb_bus_ctx_t *const bus_ctx, const char *object, int32_t depth, amxc_var_t *ret, int timeout)
Fetches one or more objects or a single parameter.
Definition: amxb_ba_op_get.c:114
amxb_add
int amxb_add(amxb_bus_ctx_t *const bus_ctx, const char *object, uint32_t index, const char *name, amxc_var_t *values, amxc_var_t *ret, int timeout)
Adds an instance to a multi-instance object.
Definition: amxb_ba_op_add.c:115
bus_ctx
static amxb_bus_ctx_t * bus_ctx
Definition: test_amxb_e2e.c:84

◆ test_amxb_cache_disable()

void test_amxb_cache_disable ( UNUSED void **  state)

Definition at line 603 of file test_amxb_e2e.c.

603  {
604  amxb_be_cache_set_size(0);
605  assert_ptr_equal(amxb_be_who_has("Device.Ethernet.Interface."), bus_ctx);
606 }
amxb_be_who_has
amxb_bus_ctx_t * amxb_be_who_has(const char *object_path)
Searches a bus context that can provide a certain object.
Definition: amxb_backend_mngr.c:650
amxb_be_cache_set_size
void amxb_be_cache_set_size(uint32_t size)
Changes the size of the lookup cache.
Definition: amxb_backend_mngr.c:689

◆ test_amxb_call()

void test_amxb_call ( UNUSED void **  state)

Definition at line 115 of file test_amxb_e2e.c.

115  {
116  amxc_var_t values;
117  amxc_var_t* results = NULL;
118  amxc_var_init(&values);
119 
120  assert_int_equal(amxb_call(bus_ctx, "Device.Ethernet.Interface.1", "_get", NULL, NULL, 5), 0);
121 
122  assert_int_equal(amxb_call(bus_ctx, "Device.Ethernet.Interface.1", "_get", NULL, &values, 5), 0);
123  amxc_var_dump(&values, STDOUT_FILENO);
124  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
125  assert_int_equal(amxc_var_type_of(results), AMXC_VAR_ID_HTABLE);
126  assert_int_equal(amxc_htable_size(&results->data.vm), 1);
127 
128  assert_int_not_equal(amxb_call(bus_ctx, "Device.Link.Interface.1", "_get", NULL, NULL, 5), 0);
129 
130  amxc_var_clean(&values);
131 }
amxb_call
int amxb_call(amxb_bus_ctx_t *const bus_ctx, const char *object, const char *method, amxc_var_t *args, amxc_var_t *ret, int timeout)
Invokes a data model function.
Definition: amxb_ba_op_call.c:78

◆ test_amxb_del()

void test_amxb_del ( UNUSED void **  state)

Definition at line 467 of file test_amxb_e2e.c.

467  {
468  amxc_var_t values;
469  amxc_var_t ret;
470  amxc_var_init(&values);
471  amxc_var_init(&ret);
472 
473  assert_int_equal(amxb_del(bus_ctx, "Device.Ethernet.Interface", 5, NULL, &ret, 5), 0);
474  assert_int_not_equal(amxb_get(bus_ctx, "Device.Ethernet.Interface.5.", 0, &values, 5), 0);
475 
476  assert_int_not_equal(amxb_del(bus_ctx, "Device.Ethernet.Interface", 5, NULL, &ret, 5), 0);
477 
478  amxc_var_clean(&ret);
479  amxc_var_clean(&values);
480 }
amxb_del
int amxb_del(amxb_bus_ctx_t *const bus_ctx, const char *object, uint32_t index, const char *name, amxc_var_t *ret, int timeout)
Deletes one or more instances of a multi-instance object.
Definition: amxb_ba_op_del.c:117

◆ test_amxb_e2e_setup()

int test_amxb_e2e_setup ( UNUSED void **  state)

Definition at line 88 of file test_amxb_e2e.c.

88  {
89  amxd_dm_init(&dm);
90  amxo_parser_init(&parser);
91 
92  test_register_dummy_be();
93 
94  assert_int_equal(amxb_connect(&bus_ctx, "dummy:/tmp/dummy.sock"), 0);
95 
96  test_load_dummy_remote("./test.odl");
97  amxo_parser_parse_file(&parser, "./local.odl", amxd_dm_get_root(&dm));
98 
99  assert_int_equal(amxb_register(bus_ctx, &dm), 0);
100 
101  return 0;
102 }
test_load_dummy_remote
int test_load_dummy_remote(const char *odl)
Definition: dummy_be.c:191
test_register_dummy_be
int test_register_dummy_be(void)
Definition: dummy_be.c:183
amxb_connect
int amxb_connect(amxb_bus_ctx_t **ctx, const char *uri)
Create a bus connection.
Definition: amxb_ba_connect.c:235
amxb_register
int amxb_register(amxb_bus_ctx_t *const ctx, amxd_dm_t *const dm)
Registers a data model to a certain bus context (connection).
Definition: amxb_ba_register.c:75
dm
static amxd_dm_t dm
Definition: test_amxb_e2e.c:85
parser
static amxo_parser_t parser
Definition: test_amxb_e2e.c:86

◆ test_amxb_e2e_teardown()

int test_amxb_e2e_teardown ( UNUSED void **  state)

Definition at line 104 of file test_amxb_e2e.c.

104  {
105  amxb_disconnect(bus_ctx);
106  amxb_free(&bus_ctx);
107 
108  amxo_parser_clean(&parser);
109  amxd_dm_clean(&dm);
110 
111  test_unregister_dummy_be();
112  return 0;
113 }
test_unregister_dummy_be
int test_unregister_dummy_be(void)
Definition: dummy_be.c:187
amxb_free
void amxb_free(amxb_bus_ctx_t **ctx)
Frees allocated memory.
Definition: amxb_ba_connect.c:339
amxb_disconnect
int amxb_disconnect(amxb_bus_ctx_t *ctx)
Disconnects a bus connection.
Definition: amxb_ba_connect.c:303

◆ test_amxb_get()

void test_amxb_get ( UNUSED void **  state)

Definition at line 133 of file test_amxb_e2e.c.

133  {
134  amxc_var_t values;
135  amxc_var_t* results = NULL;
136  amxc_var_init(&values);
137 
138  assert_int_equal(amxb_get(bus_ctx, "Device.Ethernet.Interface.1.Status", 0, &values, 5), 0);
139  assert_int_equal(amxc_var_type_of(&values), AMXC_VAR_ID_LIST);
140  assert_int_equal(amxc_llist_size(&values.data.vl), 1);
141  amxc_var_dump(&values, STDOUT_FILENO);
142  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
143  assert_int_equal(amxc_var_type_of(results), AMXC_VAR_ID_HTABLE);
144  assert_int_equal(amxc_htable_size(&results->data.vm), 1);
145 
146  assert_int_equal(amxb_get(bus_ctx, "Device.Ethernet.Interface.*.Status", 0, &values, 5), 0);
147  assert_int_equal(amxc_var_type_of(&values), AMXC_VAR_ID_LIST);
148  assert_int_equal(amxc_llist_size(&values.data.vl), 1);
149  amxc_var_dump(&values, STDOUT_FILENO);
150  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
151  assert_int_equal(amxc_var_type_of(results), AMXC_VAR_ID_HTABLE);
152  assert_int_equal(amxc_htable_size(&results->data.vm), 5);
153 
154  assert_int_equal(amxb_get(bus_ctx, "Device.Ethernet.Interface.[Enable == true].Status", 0, &values, 5), 0);
155  assert_int_equal(amxc_var_type_of(&values), AMXC_VAR_ID_LIST);
156  assert_int_equal(amxc_llist_size(&values.data.vl), 1);
157  amxc_var_dump(&values, STDOUT_FILENO);
158  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
159  assert_int_equal(amxc_var_type_of(results), AMXC_VAR_ID_HTABLE);
160  assert_int_equal(amxc_htable_size(&results->data.vm), 3);
161 
162  assert_int_not_equal(amxb_get(bus_ctx, "Device.Ethernet.Link.[Enable == true].Status", 0, &values, 5), 0);
163 
164  amxc_var_clean(&values);
165 }

◆ test_amxb_get_instances()

void test_amxb_get_instances ( UNUSED void **  state)

Definition at line 167 of file test_amxb_e2e.c.

167  {
168  amxc_var_t values;
169  amxc_var_t* results = NULL;
170  amxc_var_init(&values);
171 
172  assert_int_equal(amxb_get_instances(bus_ctx, "MQTT.Client.", 0, &values, 1), 0);
173  assert_int_equal(amxc_var_type_of(&values), AMXC_VAR_ID_LIST);
174  assert_int_equal(amxc_llist_size(&values.data.vl), 1);
175  amxc_var_dump(&values, STDOUT_FILENO);
176  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
177  assert_int_equal(amxc_var_type_of(results), AMXC_VAR_ID_HTABLE);
178  assert_int_equal(amxc_htable_size(&results->data.vm), 2);
179 
180  amxc_var_clean(&values);
181 }
amxb_get_instances
int amxb_get_instances(amxb_bus_ctx_t *const bus_ctx, const char *search_path, int32_t depth, amxc_var_t *ret, int timeout)
Fetches the instances and the unique keys of a multi-instance object.
Definition: amxb_ba_op_get_instances.c:121

◆ test_amxb_get_supported()

void test_amxb_get_supported ( UNUSED void **  state)

Definition at line 501 of file test_amxb_e2e.c.

501  {
502  uint32_t flags = AMXB_FLAG_FUNCTIONS | AMXB_FLAG_PARAMETERS | AMXB_FLAG_EVENTS;
503  amxc_var_t values;
504  amxc_var_t* results = NULL;
505  amxc_var_init(&values);
506 
507 
508  assert_int_equal(amxb_get_supported(bus_ctx, "Device", flags, &values, 5), 0);
509  assert_int_equal(amxc_var_type_of(&values), AMXC_VAR_ID_LIST);
510  assert_int_equal(amxc_llist_size(&values.data.vl), 1);
511  amxc_var_dump(&values, STDOUT_FILENO);
512  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
513  assert_int_equal(amxc_var_type_of(results), AMXC_VAR_ID_HTABLE);
514  assert_int_equal(amxc_htable_size(&results->data.vm), 4);
515 
516  assert_int_equal(amxb_get_supported(bus_ctx, "Device.Ethernet.Interface.", flags, &values, 5), 0);
517  assert_int_equal(amxc_var_type_of(&values), AMXC_VAR_ID_LIST);
518  assert_int_equal(amxc_llist_size(&values.data.vl), 1);
519  amxc_var_dump(&values, STDOUT_FILENO);
520  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
521  assert_int_equal(amxc_var_type_of(results), AMXC_VAR_ID_HTABLE);
522  assert_int_equal(amxc_htable_size(&results->data.vm), 2);
523 
524  assert_int_equal(amxb_get_supported(bus_ctx, "Device.Ethernet.Interface.{i}.", flags, &values, 5), 0);
525  assert_int_equal(amxc_var_type_of(&values), AMXC_VAR_ID_LIST);
526  assert_int_equal(amxc_llist_size(&values.data.vl), 1);
527  amxc_var_dump(&values, STDOUT_FILENO);
528  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
529  assert_int_equal(amxc_var_type_of(results), AMXC_VAR_ID_HTABLE);
530  assert_int_equal(amxc_htable_size(&results->data.vm), 2);
531 
532  assert_int_equal(amxb_get_supported(bus_ctx, "Device.Ethernet.Interface.{i}", flags, &values, 5), 0);
533  assert_int_equal(amxc_var_type_of(&values), AMXC_VAR_ID_LIST);
534  assert_int_equal(amxc_llist_size(&values.data.vl), 1);
535  amxc_var_dump(&values, STDOUT_FILENO);
536  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
537  assert_int_equal(amxc_var_type_of(results), AMXC_VAR_ID_HTABLE);
538  assert_int_equal(amxc_htable_size(&results->data.vm), 2);
539 
540  assert_int_not_equal(amxb_get_supported(bus_ctx, "Device.Ethernet.Link", flags, &values, 5), 0);
541 
542  amxc_var_clean(&values);
543 }
AMXB_FLAG_FUNCTIONS
#define AMXB_FLAG_FUNCTIONS
Definition: amxb_operators.h:78
AMXB_FLAG_PARAMETERS
#define AMXB_FLAG_PARAMETERS
Definition: amxb_operators.h:77
AMXB_FLAG_EVENTS
#define AMXB_FLAG_EVENTS
Definition: amxb_operators.h:79
amxb_get_supported
int amxb_get_supported(amxb_bus_ctx_t *const bus_ctx, const char *object, uint32_t flags, amxc_var_t *ret, int timeout)
Gets the supported data model.
Definition: amxb_ba_op_get_sup.c:113

◆ test_amxb_resolve_failure()

void test_amxb_resolve_failure ( UNUSED void **  state)

Definition at line 558 of file test_amxb_e2e.c.

558  {
559  amxc_var_t resolved;
560  amxc_var_init(&resolved);
561  amxd_path_t path;
562  amxd_path_init(&path, "Device.Ethernet.Interface.[Status == \"foo\"].");
563 
564  assert_int_equal(amxb_resolve(bus_ctx, &path, &resolved), 0);
565  assert_true(amxc_var_type_of(&resolved) == AMXC_VAR_ID_NULL);
566 
567  amxc_var_clean(&resolved);
568  amxd_path_clean(&path);
569 }
amxb_resolve
int amxb_resolve(amxb_bus_ctx_t *bus_ctx, amxd_path_t *obj_path, amxc_var_t *ret_val)
Definition: amxb_ba_op_resolve.c:78

◆ test_amxb_set()

void test_amxb_set ( UNUSED void **  state)

Definition at line 183 of file test_amxb_e2e.c.

183  {
184  amxc_var_t values;
185  amxc_var_t ret;
186  amxc_var_t* results = NULL;
187  amxc_var_init(&ret);
188  amxc_var_init(&values);
189 
190  amxc_var_set_type(&values, AMXC_VAR_ID_HTABLE);
191  amxc_var_add_key(bool, &values, "Enable", false);
192  amxc_var_add_key(cstring_t, &values, "Status", "Dormant");
193  assert_int_equal(amxb_set(bus_ctx, "Device.Ethernet.Interface.1", &values, &ret, 5), 0);
194  amxc_var_dump(&ret, STDOUT_FILENO);
195  assert_int_equal(amxc_var_type_of(&ret), AMXC_VAR_ID_LIST);
196  assert_int_equal(amxc_var_type_of(GETI_ARG(&ret, 0)), AMXC_VAR_ID_HTABLE);
197  results = GETP_ARG(&ret, "0.'Device.Ethernet.Interface.1.'");
198  assert_non_null(results);
199  assert_non_null(GET_ARG(results, "Enable"));
200  assert_non_null(GET_ARG(results, "Status"));
201 
202  assert_int_equal(amxb_get(bus_ctx, "Device.Ethernet.Interface.1.", 0, &values, 5), 0);
203  assert_int_equal(amxc_var_type_of(&values), AMXC_VAR_ID_LIST);
204  assert_int_equal(amxc_llist_size(&values.data.vl), 1);
205  amxc_var_dump(&values, STDOUT_FILENO);
206  results = amxc_var_get_index(&values, 0, AMXC_VAR_FLAG_DEFAULT);
207  results = amxc_var_get_key(results, "Device.Ethernet.Interface.1.", AMXC_VAR_FLAG_DEFAULT);
208  results = amxc_var_get_key(results, "Status", AMXC_VAR_FLAG_DEFAULT);
209  assert_string_equal(amxc_var_constcast(cstring_t, results), "Dormant");
210 
211  assert_int_not_equal(amxb_set(bus_ctx, "Device.Link.Interface.1", &values, &ret, 5), 0);
212 
213  amxc_var_clean(&ret);
214  amxc_var_clean(&values);
215 }
amxb_set
int amxb_set(amxb_bus_ctx_t *const bus_ctx, const char *object, amxc_var_t *values, amxc_var_t *ret, int timeout)
Sets parameter values of one single object or of multiple instance objects.
Definition: amxb_ba_op_set.c:172

◆ test_amxb_set_config()

void test_amxb_set_config ( UNUSED void **  state)

Definition at line 545 of file test_amxb_e2e.c.

545  {
546  amxc_var_t config;
547 
548  amxc_var_init(&config);
549  amxc_var_set_type(&config, AMXC_VAR_ID_HTABLE);
550 
551  amxc_var_add_key(amxc_htable_t, &config, "dummy", NULL);
552  assert_int_equal(amxb_set_config(&config), 0);
553  assert_int_equal(amxb_set_config(NULL), 0);
554 
555  amxc_var_clean(&config);
556 }
config
config
Definition: test.odl:56
amxb_set_config
int amxb_set_config(amxc_var_t *const configuration)
Passes configuration options to the backends.
Definition: amxb_backend_mngr.c:707

◆ test_amxb_set_multiple()

void test_amxb_set_multiple ( UNUSED void **  state)

Definition at line 217 of file test_amxb_e2e.c.

217  {
218  amxc_var_t req_paths;
219  amxc_var_t ret;
220  amxc_var_t* req_path = NULL;
221  amxc_var_t* params = NULL;
222  amxc_var_t* results = NULL;
223  amxc_var_init(&ret);
224  amxc_var_init(&req_paths);
225 
226  amxc_var_set_type(&req_paths, AMXC_VAR_ID_LIST);
227  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
228  amxc_var_add_key(cstring_t, req_path, "path", "Device.Ethernet.Interface.2.");
229  params = amxc_var_add_key(amxc_htable_t, req_path, "parameters", NULL);
230  amxc_var_add_key(cstring_t, params, "Status", "dummy-invalid");
231 
232  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
233  amxc_var_add_key(cstring_t, req_path, "path", "Device.Ethernet.Interface.[Status == 'Dormant'].");
234  params = amxc_var_add_key(amxc_htable_t, req_path, "parameters", NULL);
235  amxc_var_add_key(bool, params, "Enable", false);
236 
237  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
238  amxc_var_add_key(cstring_t, req_path, "path", "MQTT.Client.*.");
239  params = amxc_var_add_key(amxc_htable_t, req_path, "parameters", NULL);
240  amxc_var_add_key(bool, params, "Enable", true);
241  amxc_var_add_key(cstring_t, params, "TransportProtocol", "TLS");
242 
243  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
244  amxc_var_add_key(cstring_t, req_path, "path", "MQTT.Client.1.");
245  params = amxc_var_add_key(amxc_htable_t, req_path, "parameters", NULL);
246  amxc_var_add_key(bool, params, "Enable", true);
247  amxc_var_add_key(cstring_t, params, "TransportProtocol", "TLS");
248 
249  amxc_var_dump(&req_paths, STDOUT_FILENO);
250 
251  assert_int_not_equal(amxb_set_multiple(bus_ctx, 0, &req_paths, &ret, 5), 0);
252  amxc_var_dump(&ret, STDOUT_FILENO);
253 
254  assert_int_equal(amxc_var_type_of(&ret), AMXC_VAR_ID_LIST);
255  assert_int_equal(amxc_llist_size(amxc_var_constcast(amxc_llist_t, &ret)), 1);
256  results = GETI_ARG(&ret, 0);
257  assert_non_null(results);
258  assert_non_null(GETP_ARG(results, "result.'Device.Ethernet.Interface.2.'.Status"));
259  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'Device.Ethernet.Interface.2.'.Status")), AMXC_VAR_ID_HTABLE);
260 
261  amxc_var_clean(&ret);
262  assert_int_equal(amxb_get(bus_ctx, "MQTT.Client.*.Enable", 0, &ret, 5), 0);
263  assert_false(GETP_BOOL(&ret, "0.'MQTT.Client.1.'.Enable"));
264  assert_false(GETP_BOOL(&ret, "0.'MQTT.Client.2.'.Enable"));
265 
266  amxc_var_clean(&ret);
267  amxc_var_clean(&req_paths);
268 }
amxb_set_multiple
int amxb_set_multiple(amxb_bus_ctx_t *const bus_ctx, uint32_t flags, amxc_var_t *req_paths, amxc_var_t *ret, int timeout)
Sets parameter values for multiple objects (request paths)
Definition: amxb_ba_op_set_multiple.c:141

◆ test_amxb_set_multiple_allow_partial()

void test_amxb_set_multiple_allow_partial ( UNUSED void **  state)

Definition at line 315 of file test_amxb_e2e.c.

315  {
316  amxc_var_t req_paths;
317  amxc_var_t ret;
318  amxc_var_t* req_path = NULL;
319  amxc_var_t* params = NULL;
320  amxc_var_t* results = NULL;
321  amxc_var_init(&ret);
322  amxc_var_init(&req_paths);
323 
324  amxc_var_set_type(&req_paths, AMXC_VAR_ID_LIST);
325  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
326  amxc_var_add_key(cstring_t, req_path, "path", "Device.Ethernet.Interface.2.");
327  params = amxc_var_add_key(amxc_htable_t, req_path, "parameters", NULL);
328  amxc_var_add_key(cstring_t, params, "Status", "dummy-invalid");
329 
330  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
331  amxc_var_add_key(cstring_t, req_path, "path", "Device.Ethernet.Interface.[Status == 'Dormant'].");
332  params = amxc_var_add_key(amxc_htable_t, req_path, "parameters", NULL);
333  amxc_var_add_key(bool, params, "Enable", false);
334 
335  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
336  amxc_var_add_key(cstring_t, req_path, "path", "MQTT.Client.*.");
337  params = amxc_var_add_key(amxc_htable_t, req_path, "parameters", NULL);
338  amxc_var_add_key(bool, params, "Enable", true);
339  amxc_var_add_key(cstring_t, params, "TransportProtocol", "TLS");
340 
341  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
342  amxc_var_add_key(cstring_t, req_path, "path", "MQTT.Client.[Alias == 'cpe-mybroker'].");
343  params = amxc_var_add_key(amxc_htable_t, req_path, "parameters", NULL);
344  amxc_var_add_key(bool, params, "Enable", true);
345  amxc_var_add_key(cstring_t, params, "TransportProtocol", "TLS");
346 
347  amxc_var_dump(&req_paths, STDOUT_FILENO);
348 
349  assert_int_equal(amxb_set_multiple(bus_ctx, AMXB_FLAG_PARTIAL, &req_paths, &ret, 5), 0);
350  amxc_var_dump(&ret, STDOUT_FILENO);
351 
352  assert_int_equal(amxc_var_type_of(&ret), AMXC_VAR_ID_LIST);
353  assert_int_equal(amxc_llist_size(amxc_var_constcast(amxc_llist_t, &ret)), 4);
354  results = GETI_ARG(&ret, 0);
355  assert_non_null(results);
356  assert_non_null(GETP_ARG(results, "result.'Device.Ethernet.Interface.2.'.Status"));
357  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'Device.Ethernet.Interface.2.'.Status")), AMXC_VAR_ID_HTABLE);
358 
359  results = GETI_ARG(&ret, 1);
360  assert_non_null(results);
361  assert_non_null(GETP_ARG(results, "result.'Device.Ethernet.Interface.1.'.Enable"));
362  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'Device.Ethernet.Interface.1.'.Enable")), AMXC_VAR_ID_BOOL);
363  assert_non_null(GETP_ARG(results, "result.'Device.Ethernet.Interface.5.'.Enable"));
364  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'Device.Ethernet.Interface.5.'.Enable")), AMXC_VAR_ID_BOOL);
365 
366  results = GETI_ARG(&ret, 2);
367  assert_non_null(results);
368  assert_non_null(GETP_ARG(results, "result.'MQTT.Client.1.'.Enable"));
369  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'MQTT.Client.1.'.Enable")), AMXC_VAR_ID_BOOL);
370  assert_non_null(GETP_ARG(results, "result.'MQTT.Client.2.'.Enable"));
371  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'MQTT.Client.2.'.Enable")), AMXC_VAR_ID_BOOL);
372 
373  results = GETI_ARG(&ret, 3);
374  assert_non_null(results);
375 
376  amxc_var_clean(&ret);
377  assert_int_equal(amxb_get(bus_ctx, "MQTT.Client.*.Enable", 0, &ret, 5), 0);
378  assert_true(GETP_BOOL(&ret, "0.'MQTT.Client.1.'.Enable"));
379  assert_true(GETP_BOOL(&ret, "0.'MQTT.Client.2.'.Enable"));
380 
381  amxc_var_clean(&ret);
382  amxc_var_clean(&req_paths);
383 }
AMXB_FLAG_PARTIAL
#define AMXB_FLAG_PARTIAL
Definition: amxb_operators.h:86

◆ test_amxb_set_multiple_optional_params()

void test_amxb_set_multiple_optional_params ( UNUSED void **  state)

Definition at line 385 of file test_amxb_e2e.c.

385  {
386  amxc_var_t req_paths;
387  amxc_var_t ret;
388  amxc_var_t* req_path = NULL;
389  amxc_var_t* params = NULL;
390  amxc_var_t* results = NULL;
391  amxc_var_init(&ret);
392  amxc_var_init(&req_paths);
393 
394  amxc_var_set_type(&req_paths, AMXC_VAR_ID_LIST);
395  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
396  amxc_var_add_key(cstring_t, req_path, "path", "Device.Ethernet.Interface.2.");
397  params = amxc_var_add_key(amxc_htable_t, req_path, "oparameters", NULL);
398  amxc_var_add_key(cstring_t, params, "Status", "dummy-invalid");
399 
400  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
401  amxc_var_add_key(cstring_t, req_path, "path", "Device.Ethernet.Interface.[Status == 'Dormant'].");
402  params = amxc_var_add_key(amxc_htable_t, req_path, "oparameters", NULL);
403  amxc_var_add_key(bool, params, "Enable", false);
404 
405  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
406  amxc_var_add_key(cstring_t, req_path, "path", "MQTT.Client.*.");
407  params = amxc_var_add_key(amxc_htable_t, req_path, "oparameters", NULL);
408  amxc_var_add_key(bool, params, "Enable", true);
409  amxc_var_add_key(cstring_t, params, "TransportProtocol", "TLS");
410  amxc_var_dump(&req_paths, STDOUT_FILENO);
411 
412  assert_int_equal(amxb_set_multiple(bus_ctx, AMXB_FLAG_PARTIAL, &req_paths, &ret, 5), 0);
413  amxc_var_dump(&ret, STDOUT_FILENO);
414 
415  assert_int_equal(amxc_var_type_of(&ret), AMXC_VAR_ID_LIST);
416  assert_int_equal(amxc_llist_size(amxc_var_constcast(amxc_llist_t, &ret)), 3);
417  results = GETI_ARG(&ret, 0);
418  assert_non_null(results);
419  assert_non_null(GETP_ARG(results, "result.'Device.Ethernet.Interface.2.'.Status"));
420  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'Device.Ethernet.Interface.2.'.Status")), AMXC_VAR_ID_HTABLE);
421 
422  results = GETI_ARG(&ret, 1);
423  assert_non_null(results);
424  assert_non_null(GETP_ARG(results, "result.'Device.Ethernet.Interface.1.'.Enable"));
425  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'Device.Ethernet.Interface.1.'.Enable")), AMXC_VAR_ID_BOOL);
426  assert_non_null(GETP_ARG(results, "result.'Device.Ethernet.Interface.5.'.Enable"));
427  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'Device.Ethernet.Interface.5.'.Enable")), AMXC_VAR_ID_BOOL);
428 
429  results = GETI_ARG(&ret, 2);
430  assert_non_null(results);
431  assert_non_null(GETP_ARG(results, "result.'MQTT.Client.1.'.Enable"));
432  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'MQTT.Client.1.'.Enable")), AMXC_VAR_ID_BOOL);
433  assert_non_null(GETP_ARG(results, "result.'MQTT.Client.2.'.Enable"));
434  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'MQTT.Client.2.'.Enable")), AMXC_VAR_ID_BOOL);
435 
436  amxc_var_clean(&ret);
437  amxc_var_clean(&req_paths);
438 }

◆ test_amxb_set_multiple_same_path()

void test_amxb_set_multiple_same_path ( UNUSED void **  state)

Definition at line 270 of file test_amxb_e2e.c.

270  {
271  amxc_var_t req_paths;
272  amxc_var_t ret;
273  amxc_var_t* req_path = NULL;
274  amxc_var_t* params = NULL;
275  amxc_var_t* results = NULL;
276  amxc_var_init(&ret);
277  amxc_var_init(&req_paths);
278 
279  amxc_var_set_type(&req_paths, AMXC_VAR_ID_LIST);
280  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
281  amxc_var_add_key(cstring_t, req_path, "path", "Device.Ethernet.Interface.2.");
282  params = amxc_var_add_key(amxc_htable_t, req_path, "parameters", NULL);
283  amxc_var_add_key(cstring_t, params, "Status", "Down");
284 
285  req_path = amxc_var_add(amxc_htable_t, &req_paths, NULL);
286  amxc_var_add_key(cstring_t, req_path, "path", "Device.Ethernet.Interface.2.");
287  params = amxc_var_add_key(amxc_htable_t, req_path, "parameters", NULL);
288  amxc_var_add_key(bool, params, "Enable", false);
289  amxc_var_dump(&req_paths, STDOUT_FILENO);
290 
291  assert_int_equal(amxb_set_multiple(bus_ctx, 0, &req_paths, &ret, 5), 0);
292  amxc_var_dump(&ret, STDOUT_FILENO);
293 
294  assert_int_equal(amxc_var_type_of(&ret), AMXC_VAR_ID_LIST);
295  assert_int_equal(amxc_llist_size(amxc_var_constcast(amxc_llist_t, &ret)), 2);
296  results = GETI_ARG(&ret, 0);
297  assert_non_null(results);
298  assert_non_null(GETP_ARG(results, "result.'Device.Ethernet.Interface.2.'.Status"));
299  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'Device.Ethernet.Interface.2.'")), AMXC_VAR_ID_HTABLE);
300 
301  results = GETI_ARG(&ret, 1);
302  assert_non_null(results);
303  assert_non_null(GETP_ARG(results, "result.'Device.Ethernet.Interface.2.'.Enable"));
304  assert_int_equal(amxc_var_type_of(GETP_ARG(results, "result.'Device.Ethernet.Interface.2.'")), AMXC_VAR_ID_HTABLE);
305 
306  amxc_var_clean(&ret);
307  assert_int_equal(amxb_get(bus_ctx, "MQTT.Client.*.Enable", 0, &ret, 5), 0);
308  assert_false(GETP_BOOL(&ret, "0.'MQTT.Client.1.'.Enable"));
309  assert_false(GETP_BOOL(&ret, "0.'MQTT.Client.2.'.Enable"));
310 
311  amxc_var_clean(&ret);
312  amxc_var_clean(&req_paths);
313 }

◆ test_amxb_who_has()

void test_amxb_who_has ( UNUSED void **  state)

Definition at line 571 of file test_amxb_e2e.c.

571  {
572  assert_ptr_equal(amxb_be_who_has("Device.Ethernet.Interface."), bus_ctx);
573  test_set_dummy_caps(AMXB_BE_DISCOVER_DESCRIBE);
574  assert_ptr_equal(amxb_be_who_has("Device.Ethernet.Interface."), bus_ctx);
575  test_set_dummy_caps(AMXB_BE_DISCOVER_LIST);
576  assert_ptr_equal(amxb_be_who_has("Device.Ethernet.Interface."), bus_ctx);
577  test_set_dummy_caps(AMXB_BE_DISCOVER_DESCRIBE | AMXB_BE_DISCOVER_LIST | AMXB_BE_DISCOVER);
578 
579  assert_ptr_equal(amxb_be_who_has("Device."), bus_ctx);
580  assert_ptr_equal(amxb_be_who_has("Local.TestObject."), bus_ctx);
581 
582  assert_null(amxb_be_who_has(""));
583  assert_null(amxb_be_who_has(NULL));
584 }
AMXB_BE_DISCOVER
#define AMXB_BE_DISCOVER
Definition: amxb_be_intf.h:343
AMXB_BE_DISCOVER_DESCRIBE
#define AMXB_BE_DISCOVER_DESCRIBE
Definition: amxb_be_intf.h:341
AMXB_BE_DISCOVER_LIST
#define AMXB_BE_DISCOVER_LIST
Definition: amxb_be_intf.h:342
test_set_dummy_caps
void test_set_dummy_caps(uint32_t dummy_caps)
Definition: dummy_be.c:197

◆ test_amxb_who_has_cache_remove_path()

void test_amxb_who_has_cache_remove_path ( UNUSED void **  state)

Definition at line 596 of file test_amxb_e2e.c.

596  {
597  amxb_be_cache_remove_path("Device.");
598  assert_ptr_equal(amxb_be_who_has("Device."), bus_ctx);
599  assert_null(amxb_be_who_has(""));
600  assert_null(amxb_be_who_has(NULL));
601 }
amxb_be_cache_remove_path
void amxb_be_cache_remove_path(const char *object_path)
Removes an object path and its corresponding bus context from the lookup cache.
Definition: amxb_backend_mngr.c:670

◆ test_amxb_who_has_cache_set_size()

void test_amxb_who_has_cache_set_size ( UNUSED void **  state)

Definition at line 586 of file test_amxb_e2e.c.

586  {
587  amxb_be_cache_set_size(2);
588  assert_ptr_equal(amxb_be_who_has("Device.Ethernet.Interface."), bus_ctx);
589  assert_ptr_equal(amxb_be_who_has("Local.TestObject."), bus_ctx);
590  assert_ptr_equal(amxb_be_who_has("Device.Ethernet."), bus_ctx);
591  assert_ptr_equal(amxb_be_who_has("Device."), bus_ctx);
592  assert_null(amxb_be_who_has(""));
593  assert_null(amxb_be_who_has(NULL));
594 }

◆ test_search_path_expr_func()

void test_search_path_expr_func ( UNUSED void **  state)

Definition at line 482 of file test_amxb_e2e.c.

482  {
483  amxp_expr_t expr;
484  const char* expression1 = "'Device.Ethernet.Interface.3.Stats.' in search_path('Device.Ethernet.Interface.*.Stats.')";
485  const char* expression2 = "'Device.Ethernet.Interface.3.Stats.' in search_path('Device.Ethernet.Interface.3.Stats.')";
486  const char* expression3 = "'Device.Ethernet.Interface.3.Stats.' in search_path('Device.Ethernet.Interface.[Enable == 1].Stats.')";
487 
488  amxp_expr_init(&expr, expression1);
489  assert_true(amxp_expr_evaluate(&expr, NULL, NULL, NULL));
490  amxp_expr_clean(&expr);
491 
492  amxp_expr_init(&expr, expression2);
493  assert_true(amxp_expr_evaluate(&expr, NULL, NULL, NULL));
494  amxp_expr_clean(&expr);
495 
496  amxp_expr_init(&expr, expression3);
497  assert_false(amxp_expr_evaluate(&expr, NULL, NULL, NULL));
498  amxp_expr_clean(&expr);
499 }

Variable Documentation

◆ bus_ctx

amxb_bus_ctx_t* bus_ctx = NULL
static

Definition at line 84 of file test_amxb_e2e.c.

◆ dm

amxd_dm_t dm
static

Definition at line 85 of file test_amxb_e2e.c.

◆ parser

amxo_parser_t parser
static

Definition at line 86 of file test_amxb_e2e.c.