libamxd  6.4.1
Data Model Manager
test_amxd_get_function.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 <stdarg.h>
57 #include <stddef.h>
58 #include <setjmp.h>
59 #include <fcntl.h>
60 #include <unistd.h>
61 #include <signal.h>
62 #include <cmocka.h>
63 
64 #include <amxc/amxc.h>
65 #include <amxp/amxp_signal.h>
66 #include <amxp/amxp_slot.h>
67 
68 #include <amxd/amxd_common.h>
69 #include <amxd/amxd_dm.h>
70 #include <amxd/amxd_action.h>
71 #include <amxd/amxd_object.h>
72 #include <amxd/amxd_transaction.h>
73 #include <amxd/amxd_parameter.h>
74 #include <amxd/amxd_function.h>
75 
76 #include "test_amxd_default_functions.h"
77 
78 void test_amxd_get_function_all(UNUSED void** state) {
79  amxd_object_t* object = NULL;
80  amxd_object_t* template = NULL;
81  amxd_object_t* instance = NULL;
82  amxc_var_t retval;
83  amxc_var_t args;
84  amxc_var_t* value = NULL;
85  amxc_var_t* obj_params = NULL;
86 
87  amxc_var_init(&args);
88  amxc_var_init(&retval);
89 
90  template = test_build_dm();
91  object = amxd_object_get_child(template, "child");
92  assert_int_equal(amxd_object_new_instance(&instance, template, "Instance1", 0, NULL), 0);
93  assert_int_equal(amxd_object_new_instance(&instance, template, "Instance2", 0, NULL), 0);
94 
95  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
96  amxc_var_add_key(uint32_t, &args, "depth", 1);
97  amxc_var_add_key(uint32_t, &args, "access", amxd_dm_access_public);
98  assert_int_equal(amxd_object_invoke_function(template, "_get", &args, &retval), 0);
99  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
100  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 2);
101 
102  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
103  amxc_var_add_key(uint32_t, &args, "depth", 1);
104  amxc_var_add_key(uint32_t, &args, "access", amxd_dm_access_protected);
105  assert_int_equal(amxd_object_invoke_function(template, "_get", &args, &retval), 0);
106  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
107  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 3);
108 
109  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
110  assert_int_equal(amxd_object_invoke_function(instance, "_get", &args, &retval), 0);
111  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
112  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 1);
113  obj_params = amxc_var_get_key(&retval, "parent.2.", AMXC_VAR_FLAG_DEFAULT);
114  assert_int_equal(amxc_var_type_of(obj_params), AMXC_VAR_ID_HTABLE);
115  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, obj_params)), 3);
116  value = amxc_var_get_path(obj_params, "inst_param", AMXC_VAR_FLAG_DEFAULT);
117  assert_ptr_not_equal(value, NULL);
118  value = amxc_var_get_path(obj_params, "param", AMXC_VAR_FLAG_DEFAULT);
119  assert_ptr_not_equal(value, NULL);
120 
121  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
122  assert_int_not_equal(amxd_object_invoke_function(object, "_get", &args, &retval), 0);
123  amxc_var_dump(&retval, STDOUT_FILENO);
124 
125  object = amxd_object_get_child(instance, "child");
126  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
127  assert_int_equal(amxd_object_invoke_function(object, "_get", &args, &retval), 0);
128  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 1); // 1 object
129  obj_params = amxc_var_get_key(&retval, "parent.2.child.", AMXC_VAR_FLAG_DEFAULT);
130  assert_int_equal(amxc_var_type_of(obj_params), AMXC_VAR_ID_HTABLE);
131  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, obj_params)), 2); // 2 parameters
132  value = amxc_var_get_path(obj_params, "child_param2", AMXC_VAR_FLAG_DEFAULT);
133  assert_ptr_not_equal(value, NULL);
134  value = amxc_var_get_path(obj_params, "child_param3", AMXC_VAR_FLAG_DEFAULT);
135  assert_ptr_not_equal(value, NULL);
136  value = amxc_var_get_path(obj_params, "child_param", AMXC_VAR_FLAG_DEFAULT);
137  assert_ptr_equal(value, NULL);
138 
139  amxc_var_clean(&args);
140  amxc_var_clean(&retval);
141  test_clean_dm();
142 }
143 
144 void test_amxd_get_function_filtered(UNUSED void** state) {
145  amxd_object_t* object = NULL;
146  amxd_object_t* template = NULL;
147  amxd_object_t* instance = NULL;
148  amxc_var_t retval;
149  amxc_var_t args;
150  amxc_var_t* value = NULL;
151  amxc_var_t* params = NULL;
152  amxc_var_t* obj_params = NULL;
153 
154  amxc_var_init(&args);
155  amxc_var_init(&retval);
156 
157  template = test_build_dm();
158  assert_int_equal(amxd_object_new_instance(&instance, template, "Instance1", 0, NULL), 0);
159  assert_int_equal(amxd_object_new_instance(&instance, template, "Instance2", 0, NULL), 0);
160  object = amxd_object_get_child(instance, "child");
161 
162  assert_int_equal(amxd_object_new_instance(&instance, template, "test.dot.", 0, NULL), 0);
163 
164  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
165  params = amxc_var_add_key(amxc_llist_t, &args, "parameters", NULL);
166  amxc_var_add(cstring_t, params, "param");
167  amxc_var_add_key(uint32_t, &args, "depth", 1);
168  assert_int_not_equal(amxd_object_invoke_function(template, "_get", &args, &retval), 0);
169  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_NULL);
170 
171  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
172  params = amxc_var_add_key(amxc_llist_t, &args, "parameters", NULL);
173  amxc_var_add(cstring_t, params, "child_param2");
174  assert_int_equal(amxd_object_invoke_function(object, "_get", &args, &retval), 0);
175  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
176  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 1); // 1 object
177  obj_params = amxc_var_get_key(&retval, "parent.2.child.", AMXC_VAR_FLAG_DEFAULT);
178  assert_int_equal(amxc_var_type_of(obj_params), AMXC_VAR_ID_HTABLE);
179  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, obj_params)), 1); // 1 parameter
180  value = amxc_var_get_path(obj_params, "child_param2", AMXC_VAR_FLAG_DEFAULT);
181  assert_ptr_not_equal(value, NULL);
182  value = amxc_var_get_path(obj_params, "child_param3", AMXC_VAR_FLAG_DEFAULT);
183  assert_ptr_equal(value, NULL);
184  value = amxc_var_get_path(obj_params, "child_param", AMXC_VAR_FLAG_DEFAULT);
185  assert_ptr_equal(value, NULL);
186 
187  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
188  params = amxc_var_add_key(amxc_llist_t, &args, "parameters", NULL);
189  amxc_var_add(cstring_t, params, "inst_param");
190  assert_int_equal(amxd_object_invoke_function(instance, "_get", &args, &retval), 0);
191  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
192  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 1); // 1 object
193  obj_params = amxc_var_get_key(&retval, "parent.3.", AMXC_VAR_FLAG_DEFAULT);
194  assert_int_equal(amxc_var_type_of(obj_params), AMXC_VAR_ID_HTABLE);
195  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, obj_params)), 1); // 0 parameters
196  value = amxc_var_get_path(obj_params, "inst_param", AMXC_VAR_FLAG_DEFAULT);
197  assert_ptr_not_equal(value, NULL);
198 
199  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
200  params = amxc_var_add_key(amxc_llist_t, &args, "parameters", NULL);
201  amxc_var_add(cstring_t, params, "Alias");
202  assert_int_equal(amxd_object_invoke_function(instance, "_get", &args, &retval), 0);
203  amxc_var_dump(&retval, STDOUT_FILENO);
204 
205  object = amxd_object_findf(template, ".[Alias == 'test.dot.'].");
206  assert_non_null(object);
207  object = amxd_object_findf(template, ".[test.dot.].");
208  assert_non_null(object);
209  object = amxd_object_findf(template, ".test.dot.");
210  assert_null(object);
211 
212  amxc_var_clean(&args);
213  amxc_var_clean(&retval);
214  test_clean_dm();
215 }
216 
217 void test_amxd_get_function_filtered_invalid(UNUSED void** state) {
218  amxd_object_t* template = NULL;
219  amxd_object_t* instance = NULL;
220  amxc_var_t retval;
221  amxc_var_t args;
222  amxc_var_t* params = NULL;
223 
224  amxc_var_init(&args);
225  amxc_var_init(&retval);
226 
227  template = test_build_dm();
228  assert_int_equal(amxd_object_new_instance(&instance, template, "Instance1", 0, NULL), 0);
229  assert_int_equal(amxd_object_new_instance(&instance, template, "Instance2", 0, NULL), 0);
230 
231  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
232  params = amxc_var_add_key(amxc_llist_t, &args, "parameters", NULL);
233  amxc_var_add(uint32_t, params, 1234);
234  assert_int_not_equal(amxd_object_invoke_function(template, "_get", &args, &retval), 0);
235 
236  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
237  params = amxc_var_add_key(amxc_llist_t, &args, "parameters", NULL);
238  amxc_var_add(cstring_t, params, "invalid_name");
239  assert_int_not_equal(amxd_object_invoke_function(template, "_get", &args, &retval), 0);
240 
241  amxc_var_clean(&args);
242  amxc_var_clean(&retval);
243  test_clean_dm();
244 }
245 
246 void test_amxd_get_function_path(UNUSED void** state) {
247  amxd_object_t* parent = NULL;
248  amxc_var_t retval;
249  amxc_var_t args;
250  amxd_trans_t trans;
251  amxd_dm_t* dm = NULL;
252 
253  amxc_var_init(&args);
254  amxc_var_init(&retval);
255  amxd_trans_init(&trans);
256 
257  parent = test_build_dm();
258  dm = amxd_object_get_dm(parent);
259  amxd_trans_set_attr(&trans, amxd_tattr_change_priv, true);
260  amxd_trans_select_pathf(&trans, "parent");
261  amxd_trans_add_inst(&trans, 0, NULL);
262  amxd_trans_select_pathf(&trans, ".child");
263  amxd_trans_set_value(cstring_t, &trans, "child_param", "Test1");
264  amxd_trans_set_value(cstring_t, &trans, "child_param2", "true");
265  amxd_trans_set_value(cstring_t, &trans, "child_param3", "1111");
266  amxd_trans_select_pathf(&trans, "parent");
267  amxd_trans_add_inst(&trans, 0, NULL);
268  amxd_trans_select_pathf(&trans, ".child");
269  amxd_trans_set_value(cstring_t, &trans, "child_param", "Test2");
270  amxd_trans_set_value(cstring_t, &trans, "child_param2", "false");
271  amxd_trans_set_value(cstring_t, &trans, "child_param3", "1111");
272  assert_int_equal(amxd_trans_apply(&trans, dm), 0);
273 
274  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
275  amxc_var_add_key(cstring_t, &args, "rel_path", "[child.child_param2 == true].");
276  assert_int_equal(amxd_object_invoke_function(parent, "_get", &args, &retval), 0);
277  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
278  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 1); // 1 object
279 
280  amxc_var_add_key(cstring_t, &args, "rel_path", "[child.child_param3 > 100].");
281  assert_int_equal(amxd_object_invoke_function(parent, "_get", &args, &retval), 0);
282  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
283  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 2); // 2 objects
284 
285  amxc_var_add_key(cstring_t, &args, "rel_path", "[child.child_param3 > 100]");
286  assert_int_not_equal(amxd_object_invoke_function(parent, "_get", &args, &retval), 0);
287  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_NULL);
288 
289  amxc_var_add_key(cstring_t, &args, "rel_path", "[child.child_param3 < 100].");
290  assert_int_equal(amxd_object_invoke_function(parent, "_get", &args, &retval), amxd_status_ok);
291  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
292  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 0);
293 
294  amxc_var_add_key(cstring_t, &args, "rel_path", "1.");
295  assert_int_equal(amxd_object_invoke_function(parent, "_get", &args, &retval), 0);
296  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
297  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 1); // 1 objects
298 
299  amxc_var_add_key(cstring_t, &args, "rel_path", "1");
300  assert_int_not_equal(amxd_object_invoke_function(parent, "_get", &args, &retval), 0);
301  amxc_var_dump(&retval, STDOUT_FILENO);
302  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_NULL);
303 
304  amxc_var_add_key(cstring_t, &args, "rel_path", "1.child.child_param3");
305  assert_int_equal(amxd_object_invoke_function(parent, "_get", &args, &retval), 0);
306  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
307  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 1); // 1 objects
308 
309  amxc_var_clean(&args);
310  amxc_var_clean(&retval);
311  amxd_trans_clean(&trans);
312  test_clean_dm();
313 }
314 
315 void test_amxd_get_function_with_cb(UNUSED void** state) {
316  amxd_object_t* template = NULL;
317  amxd_object_t* instance = NULL;
318  amxc_var_t retval;
319  amxc_var_t args;
320  amxc_var_t* value = NULL;
321  amxc_var_t* obj_params = NULL;
322 
323  amxc_var_init(&args);
324  amxc_var_init(&retval);
325 
326  template = test_build_dm();
327  assert_int_equal(amxd_object_add_action_cb(template, action_object_read, amxd_action_object_read, NULL), 0);
328  assert_int_equal(amxd_object_new_instance(&instance, template, "Instance1", 0, NULL), 0);
329  assert_int_equal(amxd_object_new_instance(&instance, template, "Instance2", 0, NULL), 0);
330 
331  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
332  amxc_var_add_key(uint32_t, &args, "depth", 1);
333  amxc_var_add_key(uint32_t, &args, "access", amxd_dm_access_public);
334  assert_int_equal(amxd_object_invoke_function(template, "_get", &args, &retval), 0);
335  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
336  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 2);
337 
338  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
339  amxc_var_add_key(uint32_t, &args, "depth", 1);
340  amxc_var_add_key(uint32_t, &args, "access", amxd_dm_access_protected);
341  assert_int_equal(amxd_object_invoke_function(template, "_get", &args, &retval), 0);
342  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
343  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 3);
344 
345  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
346  assert_int_equal(amxd_object_invoke_function(instance, "_get", &args, &retval), 0);
347  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
348  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &retval)), 1);
349  obj_params = amxc_var_get_key(&retval, "parent.2.", AMXC_VAR_FLAG_DEFAULT);
350  assert_int_equal(amxc_var_type_of(obj_params), AMXC_VAR_ID_HTABLE);
351  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, obj_params)), 3);
352  value = amxc_var_get_path(obj_params, "inst_param", AMXC_VAR_FLAG_DEFAULT);
353  assert_ptr_not_equal(value, NULL);
354  value = amxc_var_get_path(obj_params, "param", AMXC_VAR_FLAG_DEFAULT);
355  assert_ptr_not_equal(value, NULL);
356 
357  amxc_var_clean(&args);
358  amxc_var_clean(&retval);
359  test_clean_dm();
360 }
361 
362 void test_amxd_get_function_recursive_singleton(UNUSED void** state) {
363  amxd_object_t* root = test_build_dm2();
364  amxc_var_t args;
365  amxc_var_t retval;
366  amxc_var_t* var_obj = NULL;
367  amxc_var_t* var_sub_obj = NULL;
368 
369  amxc_var_init(&args);
370  amxc_var_init(&retval);
371 
372  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
373  amxc_var_add_key(int32_t, &args, "depth", INT32_MAX);
374  assert_int_equal(amxd_object_invoke_function(root, "_get", &args, &retval), 0);
375  amxc_var_dump(&retval, STDOUT_FILENO);
376 
377  var_obj = amxc_var_get_key(&retval, "MyRoot.", AMXC_VAR_FLAG_DEFAULT);
378  assert_int_equal(amxc_var_type_of(var_obj), AMXC_VAR_ID_HTABLE);
379  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, var_obj)), 3); // 3 parameters
380 
381  var_sub_obj = amxc_var_get_key(&retval, "MyRoot.MyChild.1.", AMXC_VAR_FLAG_DEFAULT);
382  assert_int_equal(amxc_var_type_of(var_sub_obj), AMXC_VAR_ID_HTABLE);
383  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, var_sub_obj)), 4);
384  var_sub_obj = amxc_var_get_key(&retval, "MyRoot.MyChild.1.SubChild.", AMXC_VAR_FLAG_DEFAULT);
385  assert_int_equal(amxc_var_type_of(var_sub_obj), AMXC_VAR_ID_HTABLE);
386  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, var_sub_obj)), 3);
387  var_sub_obj = amxc_var_get_key(&retval, "MyRoot.MyChild.1.SubChild.SubTemplate.1.", AMXC_VAR_FLAG_DEFAULT);
388  assert_int_equal(amxc_var_type_of(var_sub_obj), AMXC_VAR_ID_HTABLE);
389  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, var_sub_obj)), 3);
390 
391  amxc_var_clean(&args);
392  amxc_var_clean(&retval);
393  test_clean_dm();
394 }
395 
396 void test_amxd_get_function_recursive_template(UNUSED void** state) {
397  amxd_object_t* root = test_build_dm2();
398  amxc_var_t args;
399  amxc_var_t retval;
400  amxc_var_t* var_obj = NULL;
401  amxc_var_t* var_sub_obj = NULL;
402 
403  amxc_var_init(&args);
404  amxc_var_init(&retval);
405 
406  root = amxd_object_get_child(root, "MyChild");
407  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
408  amxc_var_add_key(int32_t, &args, "depth", INT32_MAX);
409  assert_int_equal(amxd_object_invoke_function(root, "_get", &args, &retval), 0);
410  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
411 
412  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
413  amxc_var_add_key(int32_t, &args, "depth", INT32_MAX);
414  amxc_var_add_key(cstring_t, &args, "rel_path", "*.");
415  assert_int_equal(amxd_object_invoke_function(root, "_get", &args, &retval), 0);
416 
417  amxc_var_dump(&retval, STDOUT_FILENO);
418 
419  var_obj = amxc_var_get_key(&retval, "MyRoot.MyChild.1.", AMXC_VAR_FLAG_DEFAULT);
420  assert_int_equal(amxc_var_type_of(var_obj), AMXC_VAR_ID_HTABLE);
421  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, var_obj)), 4);
422 
423  var_sub_obj = amxc_var_get_key(&retval, "MyRoot.MyChild.1.SubChild.", AMXC_VAR_FLAG_DEFAULT);
424  assert_int_equal(amxc_var_type_of(var_sub_obj), AMXC_VAR_ID_HTABLE);
425  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, var_sub_obj)), 3);
426  var_sub_obj = amxc_var_get_key(&retval, "MyRoot.MyChild.1.SubChild.SubTemplate.1.", AMXC_VAR_FLAG_DEFAULT);
427  assert_int_equal(amxc_var_type_of(var_sub_obj), AMXC_VAR_ID_HTABLE);
428  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, var_sub_obj)), 3);
429 
430  amxc_var_clean(&args);
431  amxc_var_clean(&retval);
432  test_clean_dm();
433 }
amxd_action.h
Ambiorix Data Model Default actions header file.
amxd_action_object_read
amxd_status_t amxd_action_object_read(amxd_object_t *const object, amxd_param_t *const param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
amxd_common.h
amxd_dm.h
Ambiorix Data Model API header file.
amxd_function.h
Ambiorix Data Model RPC methods API header file.
amxd_object.h
Ambiorix Data Model API header file.
amxd_object_add_action_cb
amxd_status_t amxd_object_add_action_cb(amxd_object_t *const object, const amxd_action_t reason, amxd_action_fn_t fn, void *priv)
Definition: amxd_object_action.c:73
amxd_parameter.h
amxd_transaction.h
Ambiorix Data Model API header file.
action_object_read
@ action_object_read
Definition: amxd_types.h:117
amxd_status_ok
@ amxd_status_ok
Definition: amxd_types.h:78
amxd_dm_access_protected
@ amxd_dm_access_protected
Definition: amxd_types.h:139
amxd_dm_access_public
@ amxd_dm_access_public
Definition: amxd_types.h:136
amxd_object_get_child
amxd_object_t * amxd_object_get_child(const amxd_object_t *object, const char *name)
Get a child of the object.
Definition: amxd_object_hierarchy.c:299
amxd_object_findf
amxd_object_t * amxd_object_findf(amxd_object_t *object, const char *rel_path,...) __attribute__((format(printf
Find an object in the data model tree, starting from an object.
amxd_object_get_dm
amxd_dm_t * amxd_object_get_dm(const amxd_object_t *const object)
Get the data model.
Definition: amxd_object_hierarchy.c:265
amxd_object_invoke_function
amxd_status_t amxd_object_invoke_function(amxd_object_t *const object, const char *func_name, amxc_var_t *const args, amxc_var_t *const ret)
Calls an object RPC method.
Definition: amxd_object_function.c:245
amxd_object_new_instance
amxd_status_t amxd_object_new_instance(amxd_object_t **object, amxd_object_t *templ, const char *name, uint32_t index, amxc_var_t *values)
Data model object constructor function.
Definition: amxd_object_instance.c:350
amxd_trans_set_attr
amxd_status_t amxd_trans_set_attr(amxd_trans_t *trans, amxd_tattr_id_t attr, bool enable)
Set the transaction attributes.
Definition: amxd_transaction.c:570
amxd_trans_clean
void amxd_trans_clean(amxd_trans_t *const trans)
Cleans the transaction object.
Definition: amxd_transaction.c:529
amxd_trans_apply
amxd_status_t amxd_trans_apply(amxd_trans_t *const trans, amxd_dm_t *const dm)
Applies all previously added actions.
Definition: amxd_transaction.c:841
amxd_trans_set_value
#define amxd_trans_set_value(type, trans, name, value)
Helper macro for setting a value.
Definition: amxd_transaction.h:144
amxd_trans_add_inst
amxd_status_t amxd_trans_add_inst(amxd_trans_t *const trans, const uint32_t index, const char *name)
Adds an instance add action to a transaction.
Definition: amxd_transaction.c:738
amxd_trans_select_pathf
amxd_status_t amxd_trans_select_pathf(amxd_trans_t *const trans, const char *path,...) __attribute__((format(printf
Selects an object using a absolute or relative path.
amxd_trans_init
amxd_status_t amxd_trans_init(amxd_trans_t *const trans)
Initializes a transaction object.
Definition: amxd_transaction.c:507
amxd_tattr_change_priv
@ amxd_tattr_change_priv
Definition: amxd_transaction.h:106
_amxd_dm
Definition: amxd_types.h:259
_amxd_object
Definition: amxd_types.h:229
_amxd_transaction
Definition: amxd_transaction.h:119
dm
static amxd_dm_t dm
Definition: test_amxd_action_object_add.c:79
test_build_dm
static amxd_object_t * test_build_dm(void)
Definition: test_amxd_action_object_add.c:116
test_clean_dm
void test_clean_dm(void)
Definition: test_amxd_default_functions.c:204
test_build_dm2
amxd_object_t * test_build_dm2(void)
Definition: test_amxd_default_functions.c:141
test_amxd_default_functions.h
test_amxd_get_function_filtered
void test_amxd_get_function_filtered(UNUSED void **state)
Definition: test_amxd_get_function.c:144
test_amxd_get_function_recursive_singleton
void test_amxd_get_function_recursive_singleton(UNUSED void **state)
Definition: test_amxd_get_function.c:362
test_amxd_get_function_path
void test_amxd_get_function_path(UNUSED void **state)
Definition: test_amxd_get_function.c:246
test_amxd_get_function_with_cb
void test_amxd_get_function_with_cb(UNUSED void **state)
Definition: test_amxd_get_function.c:315
test_amxd_get_function_recursive_template
void test_amxd_get_function_recursive_template(UNUSED void **state)
Definition: test_amxd_get_function.c:396
test_amxd_get_function_all
void test_amxd_get_function_all(UNUSED void **state)
Definition: test_amxd_get_function.c:78
test_amxd_get_function_filtered_invalid
void test_amxd_get_function_filtered_invalid(UNUSED void **state)
Definition: test_amxd_get_function.c:217