libamxb  4.8.2
Bus Agnostic C API
test_amxb_e2e.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/types.h>
56 #include <sys/stat.h>
57 #include <fcntl.h>
58 
59 #include <stdlib.h>
60 #include <stdio.h>
61 #include <dlfcn.h>
62 #include <stdarg.h>
63 #include <stddef.h>
64 #include <setjmp.h>
65 #include <cmocka.h>
66 #include <signal.h>
67 
68 #include <amxc/amxc.h>
69 #include <amxp/amxp.h>
70 
71 #include <amxd/amxd_dm.h>
72 #include <amxd/amxd_path.h>
73 
74 #include <amxb/amxb.h>
75 #include <amxb/amxb_register.h>
76 #include <amxb/amxb_be_intf.h>
77 
78 #include <amxo/amxo.h>
79 
80 #include "dummy_be.h"
81 #include "test_amxb_e2e.h"
82 
83 #include <amxc/amxc_macros.h>
84 static amxb_bus_ctx_t* bus_ctx = NULL;
85 static amxd_dm_t dm;
86 static amxo_parser_t parser;
87 
88 int test_amxb_e2e_setup(UNUSED void** state) {
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 }
103 
104 int test_amxb_e2e_teardown(UNUSED void** state) {
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 }
114 
115 void test_amxb_call(UNUSED void** state) {
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 }
132 
133 void test_amxb_get(UNUSED void** state) {
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 }
166 
167 void test_amxb_get_instances(UNUSED void** state) {
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 }
182 
183 void test_amxb_set(UNUSED void** state) {
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 }
216 
217 void test_amxb_set_multiple(UNUSED void** state) {
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 }
269 
270 void test_amxb_set_multiple_same_path(UNUSED void** state) {
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 }
314 
315 void test_amxb_set_multiple_allow_partial(UNUSED void** state) {
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 }
384 
385 void test_amxb_set_multiple_optional_params(UNUSED void** state) {
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 }
439 
440 void test_amxb_add(UNUSED void** state) {
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 }
466 
467 void test_amxb_del(UNUSED void** state) {
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 }
481 
482 void test_search_path_expr_func(UNUSED void** state) {
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 }
500 
501 void test_amxb_get_supported(UNUSED void** state) {
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 }
544 
545 void test_amxb_set_config(UNUSED void** state) {
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 }
557 
558 void test_amxb_resolve_failure(UNUSED void** state) {
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 }
570 
571 void test_amxb_who_has(UNUSED void** state) {
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 }
585 
586 void test_amxb_who_has_cache_set_size(UNUSED void** state) {
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 }
595 
596 void test_amxb_who_has_cache_remove_path(UNUSED void** state) {
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 }
602 
603 void test_amxb_cache_disable(UNUSED void** state) {
604  amxb_be_cache_set_size(0);
605  assert_ptr_equal(amxb_be_who_has("Device.Ethernet.Interface."), bus_ctx);
606 }
amxb.h
Ambiorix bus agnostic API header file.
amxb_be_intf.h
Ambiorix Bus Backend Interface.
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
config
config
Definition: test.odl:56
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
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_FLAG_PARTIAL
#define AMXB_FLAG_PARTIAL
Definition: amxb_operators.h:86
amxb_register.h
Ambiorix Bus Agnostic Data Model registration.
test_set_dummy_caps
void test_set_dummy_caps(uint32_t dummy_caps)
Definition: dummy_be.c:197
test_unregister_dummy_be
int test_unregister_dummy_be(void)
Definition: dummy_be.c:187
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
dummy_be.h
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
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
amxb_set_config
int amxb_set_config(amxc_var_t *const configuration)
Passes configuration options to the backends.
Definition: amxb_backend_mngr.c:707
amxb_connect
int amxb_connect(amxb_bus_ctx_t **ctx, const char *uri)
Create a bus connection.
Definition: amxb_ba_connect.c:235
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
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
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
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
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
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_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
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
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
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
_amxb_bus_ctx
Definition: amxb_types.h:115
test_amxb_set
void test_amxb_set(UNUSED void **state)
Definition: test_amxb_e2e.c:183
test_amxb_get_instances
void test_amxb_get_instances(UNUSED void **state)
Definition: test_amxb_e2e.c:167
test_amxb_del
void test_amxb_del(UNUSED void **state)
Definition: test_amxb_e2e.c:467
test_amxb_set_config
void test_amxb_set_config(UNUSED void **state)
Definition: test_amxb_e2e.c:545
dm
static amxd_dm_t dm
Definition: test_amxb_e2e.c:85
test_amxb_resolve_failure
void test_amxb_resolve_failure(UNUSED void **state)
Definition: test_amxb_e2e.c:558
test_amxb_who_has
void test_amxb_who_has(UNUSED void **state)
Definition: test_amxb_e2e.c:571
test_amxb_e2e_teardown
int test_amxb_e2e_teardown(UNUSED void **state)
Definition: test_amxb_e2e.c:104
test_amxb_set_multiple_optional_params
void test_amxb_set_multiple_optional_params(UNUSED void **state)
Definition: test_amxb_e2e.c:385
test_amxb_add
void test_amxb_add(UNUSED void **state)
Definition: test_amxb_e2e.c:440
parser
static amxo_parser_t parser
Definition: test_amxb_e2e.c:86
test_amxb_set_multiple
void test_amxb_set_multiple(UNUSED void **state)
Definition: test_amxb_e2e.c:217
test_amxb_set_multiple_allow_partial
void test_amxb_set_multiple_allow_partial(UNUSED void **state)
Definition: test_amxb_e2e.c:315
test_search_path_expr_func
void test_search_path_expr_func(UNUSED void **state)
Definition: test_amxb_e2e.c:482
bus_ctx
static amxb_bus_ctx_t * bus_ctx
Definition: test_amxb_e2e.c:84
test_amxb_who_has_cache_set_size
void test_amxb_who_has_cache_set_size(UNUSED void **state)
Definition: test_amxb_e2e.c:586
test_amxb_cache_disable
void test_amxb_cache_disable(UNUSED void **state)
Definition: test_amxb_e2e.c:603
test_amxb_call
void test_amxb_call(UNUSED void **state)
Definition: test_amxb_e2e.c:115
test_amxb_who_has_cache_remove_path
void test_amxb_who_has_cache_remove_path(UNUSED void **state)
Definition: test_amxb_e2e.c:596
test_amxb_get_supported
void test_amxb_get_supported(UNUSED void **state)
Definition: test_amxb_e2e.c:501
test_amxb_get
void test_amxb_get(UNUSED void **state)
Definition: test_amxb_e2e.c:133
test_amxb_e2e_setup
int test_amxb_e2e_setup(UNUSED void **state)
Definition: test_amxb_e2e.c:88
test_amxb_set_multiple_same_path
void test_amxb_set_multiple_same_path(UNUSED void **state)
Definition: test_amxb_e2e.c:270
test_amxb_e2e.h