libamxd  6.4.1
Data Model Manager
test_amxd_function_set.c
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** SPDX-License-Identifier: BSD-2-Clause-Patent
4 **
5 ** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome
6 **
7 ** Redistribution and use in source and binary forms, with or without modification,
8 ** are permitted provided that the following conditions are met:
9 **
10 ** 1. Redistributions of source code must retain the above copyright notice,
11 ** this list of conditions and the following disclaimer.
12 **
13 ** 2. Redistributions in binary form must reproduce the above copyright notice,
14 ** this list of conditions and the following disclaimer in the documentation
15 ** and/or other materials provided with the distribution.
16 **
17 ** Subject to the terms and conditions of this license, each copyright holder
18 ** and contributor hereby grants to those receiving rights under this license
19 ** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
20 ** (except for failure to satisfy the conditions of this license) patent license
21 ** to make, have made, use, offer to sell, sell, import, and otherwise transfer
22 ** this software, where such license applies only to those patent claims, already
23 ** acquired or hereafter acquired, licensable by such copyright holder or contributor
24 ** that are necessarily infringed by:
25 **
26 ** (a) their Contribution(s) (the licensed copyrights of copyright holders and
27 ** non-copyrightable additions of contributors, in source or binary form) alone;
28 ** or
29 **
30 ** (b) combination of their Contribution(s) with the work of authorship to which
31 ** such Contribution(s) was added by such copyright holder or contributor, if,
32 ** at the time the Contribution is added, such addition causes such combination
33 ** to be necessarily infringed. The patent license shall not apply to any other
34 ** combinations which include the Contribution.
35 **
36 ** Except as expressly stated above, no rights or licenses from any copyright
37 ** holder or contributor is granted under this license, whether expressly, by
38 ** implication, estoppel or otherwise.
39 **
40 ** DISCLAIMER
41 **
42 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
43 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
46 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
48 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
49 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50 ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
51 ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
52 **
53 ****************************************************************************/
54 
55 #include <stdlib.h>
56 #include <stdio.h>
57 #include <stdarg.h>
58 #include <stddef.h>
59 #include <setjmp.h>
60 #include <fcntl.h>
61 #include <unistd.h>
62 #include <signal.h>
63 #include <cmocka.h>
64 
65 #include <amxc/amxc.h>
66 #include <amxp/amxp_signal.h>
67 #include <amxp/amxp_slot.h>
68 #include <amxp/amxp_timer.h>
69 
70 #include <amxd/amxd_dm.h>
71 #include <amxd/amxd_object.h>
72 #include <amxd/amxd_object_event.h>
73 #include <amxd/amxd_transaction.h>
74 
75 #include "test_amxd_function_set.h"
76 
77 #include <amxc/amxc_macros.h>
78 static amxd_dm_t dm;
79 
80 int test_function_set_setup(UNUSED void** state) {
81  amxd_object_t* root = NULL;
82  amxd_object_t* singleton = NULL;
83  amxd_object_t* template = NULL;
84  amxd_object_t* sub = NULL;
85  amxd_object_t* instance = NULL;
86  amxd_param_t* param = NULL;
87  amxd_function_t* func = NULL;
88  amxc_var_t def_val;
89  amxc_var_t* param3_val = NULL;
90 
91  assert_int_equal(amxd_dm_init(&dm), 0);
92  amxc_var_init(&def_val);
93 
94  // object Main
95  assert_int_equal(amxd_object_new(&root, amxd_object_singleton, "Main"), 0);
96  assert_int_equal(amxd_dm_add_root_object(&dm, root), 0);
97 
98  // %persistent object Main.Template[]
99  assert_int_equal(amxd_object_new(&template, amxd_object_template, "Template"), 0);
100  amxd_object_set_attr(template, amxd_oattr_persistent, true);
101  assert_int_equal(amxd_object_add_object(root, template), 0);
102  // %unique %key string Alias
103  assert_int_equal(amxd_param_new(&param, "Alias", AMXC_VAR_ID_CSTRING), 0);
104  amxd_param_set_attr(param, amxd_pattr_key, true);
105  amxd_param_set_attr(param, amxd_pattr_unique, true);
106  assert_int_equal(amxd_object_add_param(template, param), 0);
107  // string param1
108  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
109  assert_int_equal(amxd_object_add_param(template, param), 0);
110  // %read-only uint32 param2
111  assert_int_equal(amxd_param_new(&param, "param2", AMXC_VAR_ID_UINT32), 0);
112  amxd_param_set_attr(param, amxd_pattr_read_only, true);
113  assert_int_equal(amxd_object_add_param(template, param), 0);
114  // %unique uint32 param3
115  assert_int_equal(amxd_param_new(&param, "param3", AMXC_VAR_ID_UINT32), 0);
116  amxd_param_set_attr(param, amxd_pattr_unique, true);
117  assert_int_equal(amxd_object_add_param(template, param), 0);
118  // htable func1(%mandatory %in string arg1, %in uint32 arg2 = 10)
119  assert_int_equal(amxd_function_new(&func, "func1", AMXC_VAR_ID_HTABLE, NULL), 0);
120  assert_int_equal(amxd_function_new_arg(func, "arg1", AMXC_VAR_ID_CSTRING, NULL), 0);
121  amxc_var_set(uint32_t, &def_val, 10);
122  assert_int_equal(amxd_function_new_arg(func, "arg2", AMXC_VAR_ID_UINT32, &def_val), 0);
123  assert_int_equal(amxd_object_add_function(template, func), 0);
124 
125  // object Main.Template[].Sub[]
126  assert_int_equal(amxd_object_new(&sub, amxd_object_template, "Sub"), 0);
127  assert_int_equal(amxd_object_add_object(template, sub), 0);
128  // %unique %key string Alias
129  assert_int_equal(amxd_param_new(&param, "Alias", AMXC_VAR_ID_CSTRING), 0);
130  amxd_param_set_attr(param, amxd_pattr_key, true);
131  amxd_param_set_attr(param, amxd_pattr_unique, true);
132  assert_int_equal(amxd_object_add_param(sub, param), 0);
133 
134  // %persistent object Main.Singleton
135  assert_int_equal(amxd_object_new(&singleton, amxd_object_singleton, "Singleton"), 0);
136  amxd_object_set_attr(singleton, amxd_oattr_persistent, true);
137  assert_int_equal(amxd_object_add_object(root, singleton), 0);
138  // string param1
139  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
140  assert_int_equal(amxd_object_add_param(singleton, param), 0);
141  // %read-only uint32 param2
142  assert_int_equal(amxd_param_new(&param, "param2", AMXC_VAR_ID_UINT32), 0);
143  amxd_param_set_attr(param, amxd_pattr_read_only, true);
144  assert_int_equal(amxd_object_add_param(singleton, param), 0);
145  // bool param3
146  assert_int_equal(amxd_param_new(&param, "param3", AMXC_VAR_ID_BOOL), 0);
147  assert_int_equal(amxd_object_add_param(singleton, param), 0);
148  // htable func1(%mandatory %in string arg1, %in uint32 arg2 = 10)
149  assert_int_equal(amxd_function_new(&func, "func1", AMXC_VAR_ID_HTABLE, NULL), 0);
150  assert_int_equal(amxd_function_new_arg(func, "arg1", AMXC_VAR_ID_CSTRING, NULL), 0);
151  amxc_var_set(uint32_t, &def_val, 10);
152  assert_int_equal(amxd_function_new_arg(func, "arg2", AMXC_VAR_ID_UINT32, &def_val), 0);
153  assert_int_equal(amxd_object_add_function(singleton, func), 0);
154 
155  amxc_var_set_type(&def_val, AMXC_VAR_ID_HTABLE);
156  param3_val = amxc_var_add_key(uint32_t, &def_val, "param3", 1);
157  assert_int_equal(amxd_object_add_instance(&instance, template, "Instance1", 0, &def_val), 0);
158  amxc_var_set(uint32_t, param3_val, 2);
159  assert_int_equal(amxd_object_add_instance(&instance, template, "Instance2", 0, &def_val), 0);
160  amxc_var_set(uint32_t, param3_val, 3);
161  assert_int_equal(amxd_object_add_instance(&instance, template, "Test1", 0, &def_val), 0);
162  amxc_var_set(uint32_t, param3_val, 4);
163  assert_int_equal(amxd_object_add_instance(&instance, template, "Test2", 0, &def_val), 0);
164  amxc_var_set(uint32_t, param3_val, 5);
165  assert_int_equal(amxd_object_add_instance(&instance, template, "YAI1", 0, &def_val), 0);
166  amxc_var_set(uint32_t, param3_val, 6);
167  assert_int_equal(amxd_object_add_instance(&instance, template, "YAI2", 0, &def_val), 0);
168  amxc_var_set(uint32_t, param3_val, 7);
169  assert_int_equal(amxd_object_add_instance(&instance, template, "YAI3", 0, &def_val), 0);
170  template = amxd_object_findf(instance, "Sub");
171  assert_int_equal(amxd_object_add_instance(&instance, template, "SUBINST", 0, NULL), 0);
172 
173  amxc_var_clean(&def_val);
174  return 0;
175 }
176 
177 int test_function_set_teardown(UNUSED void** state) {
178  amxd_dm_clean(&dm);
179 
180  return 0;
181 }
182 
183 void test_amxd_can_set_instance_object(UNUSED void** state) {
184  amxd_object_t* template = NULL;
185  amxc_var_t retval;
186  amxc_var_t args;
187  amxc_var_t* params = NULL;
188 
189  amxc_var_init(&args);
190  amxc_var_init(&retval);
191 
192  template = amxd_dm_findf(&dm, "Main.Template.1");
193  assert_non_null(template);
194 
195  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
196  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
197  amxc_var_add_key(cstring_t, params, "param1", "TEST");
198  assert_int_equal(amxd_object_invoke_function(template, "_set", &args, &retval), 0);
199 
200  amxc_var_dump(&retval, STDOUT_FILENO);
201  assert_non_null(GETP_ARG(&retval, "'Main.Template.1.'"));
202 
203  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
204 
205  amxc_var_clean(&retval);
206  amxc_var_clean(&args);
207 }
208 
209 void test_amxd_set_fails_if_unique_value_exists(UNUSED void** state) {
210  amxd_object_t* template = NULL;
211  amxc_var_t retval;
212  amxc_var_t args;
213  amxc_var_t* params = NULL;
214 
215  amxc_var_init(&args);
216  amxc_var_init(&retval);
217 
218  template = amxd_dm_findf(&dm, "Main.Template.1");
219  assert_non_null(template);
220 
221  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
222  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
223  amxc_var_add_key(uint32_t, params, "param3", 2);
224  assert_int_not_equal(amxd_object_invoke_function(template, "_set", &args, &retval), 0);
225 
226  amxc_var_dump(&retval, STDOUT_FILENO);
227  assert_non_null(GETP_ARG(&retval, "'Main.Template.1.'"));
228 
229  assert_int_equal(amxc_var_type_of(&retval), AMXC_VAR_ID_HTABLE);
230 
231  amxc_var_clean(&retval);
232  amxc_var_clean(&args);
233 }
234 
235 void test_amxd_set_can_use_rel_path(UNUSED void** state) {
236  amxd_object_t* root = NULL;
237  amxc_var_t retval;
238  amxc_var_t args;
239  amxc_var_t* params = NULL;
240 
241  amxc_var_init(&args);
242  amxc_var_init(&retval);
243 
244  root = amxd_dm_findf(&dm, "Main.");
245  assert_non_null(root);
246 
247  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
248  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
249  amxc_var_add_key(cstring_t, params, "param1", "TEST");
250  amxc_var_add_key(cstring_t, &args, "rel_path", "Template.*.");
251  assert_int_equal(amxd_object_invoke_function(root, "_set", &args, &retval), 0);
252 
253  amxc_var_dump(&retval, STDOUT_FILENO);
254  assert_non_null(GETP_ARG(&retval, "'Main.Template.1.'"));
255  assert_non_null(GETP_ARG(&retval, "'Main.Template.2.'"));
256  assert_non_null(GETP_ARG(&retval, "'Main.Template.3.'"));
257  assert_non_null(GETP_ARG(&retval, "'Main.Template.4.'"));
258  assert_non_null(GETP_ARG(&retval, "'Main.Template.5.'"));
259  assert_non_null(GETP_ARG(&retval, "'Main.Template.6.'"));
260  assert_non_null(GETP_ARG(&retval, "'Main.Template.7.'"));
261 
262  root = amxd_dm_findf(&dm, "Main.Template.");
263  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
264  amxc_var_add_key(cstring_t, params, "param1", "TEST");
265  amxc_var_add_key(cstring_t, &args, "rel_path", "[Alias == 'YAI1' || Alias == 'YAI2'].");
266  assert_int_equal(amxd_object_invoke_function(root, "_set", &args, &retval), 0);
267 
268  amxc_var_dump(&retval, STDOUT_FILENO);
269  assert_non_null(GETP_ARG(&retval, "'Main.Template.5.'"));
270  assert_non_null(GETP_ARG(&retval, "'Main.Template.6.'"));
271 
272  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
273  amxc_var_add_key(cstring_t, params, "param1", "TEST");
274  amxc_var_add_key(cstring_t, &args, "rel_path", "[Alias == 'FOO' || Alias == 'BAR'].");
275  assert_int_not_equal(amxd_object_invoke_function(root, "_set", &args, &retval), 0);
276  amxc_var_dump(&retval, STDOUT_FILENO);
277 
278  amxc_var_clean(&retval);
279 
280  root = amxd_dm_findf(&dm, "Main.");
281  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
282  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
283  amxc_var_add_key(cstring_t, params, "param1", "TEST2");
284  amxc_var_add_key(cstring_t, &args, "rel_path", "Template.YAI1.");
285  assert_int_equal(amxd_object_invoke_function(root, "_set", &args, &retval), 0);
286  amxc_var_dump(&retval, STDOUT_FILENO);
287  assert_non_null(GETP_ARG(&retval, "'Main.Template.5.'"));
288 
289  amxc_var_clean(&retval);
290  amxc_var_clean(&args);
291 }
292 
293 void test_amxd_set_fails_with_invalid_rel_path(UNUSED void** state) {
294  amxd_object_t* root = NULL;
295  amxc_var_t retval;
296  amxc_var_t args;
297  amxc_var_t* params = NULL;
298 
299  amxc_var_init(&args);
300  amxc_var_init(&retval);
301 
302  root = amxd_dm_findf(&dm, "Main.");
303  assert_non_null(root);
304 
305  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
306  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
307  amxc_var_add_key(cstring_t, params, "param1", "TEST");
308  amxc_var_add_key(cstring_t, &args, "rel_path", "NotExisting.Object.");
309  assert_int_not_equal(amxd_object_invoke_function(root, "_set", &args, &retval), 0);
310 
311  amxc_var_clean(&retval);
312  amxc_var_clean(&args);
313 }
314 
315 
316 void test_amxd_set_can_use_to_high_access(UNUSED void** state) {
317  amxd_object_t* obj = NULL;
318  amxc_var_t retval;
319  amxc_var_t args;
320  amxc_var_t* params = NULL;
321 
322  amxc_var_init(&args);
323  amxc_var_init(&retval);
324 
325  obj = amxd_dm_findf(&dm, "Main.Template.1.");
326  assert_non_null(obj);
327 
328  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
329  amxc_var_add_key(uint32_t, &args, "access", 100);
330  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
331  amxc_var_add_key(cstring_t, params, "param1", "TEST");
332  assert_int_equal(amxd_object_invoke_function(obj, "_set", &args, &retval), 0);
333 
334  amxc_var_clean(&retval);
335  amxc_var_clean(&args);
336 }
337 
338 void test_amxd_set_partial(UNUSED void** state) {
339  amxd_object_t* singleton = NULL;
340  amxc_var_t retval;
341  amxc_var_t args;
342  amxc_var_t* params = NULL;
343  amxc_var_t verify;
344 
345  amxc_var_init(&args);
346  amxc_var_init(&retval);
347  amxc_var_init(&verify);
348 
349  singleton = amxd_dm_findf(&dm, "Main.Singleton.");
350  assert_non_null(singleton);
351 
352  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
353  amxc_var_add_key(uint32_t, &args, "access", 100);
354  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
355  amxc_var_add_key(cstring_t, params, "param1", "TEST");
356  amxc_var_add_key(uint32_t, params, "param2", 1024);
357  assert_int_not_equal(amxd_object_invoke_function(singleton, "_set", &args, &retval), 0);
358  amxc_var_dump(&retval, STDOUT_FILENO);
359  assert_int_equal(amxc_var_type_of(GETP_ARG(&retval, "'Main.Singleton.'.param2")), AMXC_VAR_ID_HTABLE);
360  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.param2.error_code"), 15);
361  assert_true(GETP_BOOL(&retval, "'Main.Singleton.'.param2.required"));
362 
363  assert_int_equal(amxd_object_get_params(singleton, &verify, amxd_dm_access_protected), 0);
364  assert_int_equal(GET_UINT32(&verify, "param2"), 0);
365  assert_string_equal(GET_CHAR(&verify, "param1"), "");
366 
367  amxc_var_clean(&retval);
368  amxc_var_clean(&args);
369  amxc_var_clean(&verify);
370 }
371 
372 void test_amxd_set_fails_if_not_partial(UNUSED void** state) {
373  amxd_object_t* singleton = NULL;
374  amxc_var_t retval;
375  amxc_var_t args;
376  amxc_var_t* params = NULL;
377  amxc_var_t verify;
378 
379  amxc_var_init(&args);
380  amxc_var_init(&retval);
381  amxc_var_init(&verify);
382 
383  singleton = amxd_dm_findf(&dm, "Main.Singleton.");
384  assert_non_null(singleton);
385 
386  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
387  amxc_var_add_key(uint32_t, &args, "access", 100);
388  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
389  amxc_var_add_key(cstring_t, params, "param1", "TEST");
390  amxc_var_add_key(uint32_t, params, "param2", 1024);
391  assert_int_not_equal(amxd_object_invoke_function(singleton, "_set", &args, &retval), 0);
392  amxc_var_dump(&retval, STDOUT_FILENO);
393 
394  assert_int_equal(amxd_object_get_params(singleton, &verify, amxd_dm_access_protected), 0);
395  assert_int_equal(GET_UINT32(&verify, "param2"), 0);
396  assert_string_equal(GET_CHAR(&verify, "param1"), "");
397 
398  amxc_var_clean(&retval);
399  amxc_var_clean(&args);
400  amxc_var_clean(&verify);
401 }
402 
403 
404 void test_amxd_set_optional(UNUSED void** state) {
405  amxd_object_t* singleton = NULL;
406  amxc_var_t retval;
407  amxc_var_t args;
408  amxc_var_t* params = NULL;
409  amxc_var_t verify;
410 
411  amxc_var_init(&args);
412  amxc_var_init(&retval);
413  amxc_var_init(&verify);
414 
415  singleton = amxd_dm_findf(&dm, "Main.Singleton.");
416  assert_non_null(singleton);
417 
418  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
419  amxc_var_add_key(uint32_t, &args, "access", amxd_dm_access_protected);
420  params = amxc_var_add_key(amxc_htable_t, &args, "oparameters", NULL);
421  amxc_var_add_key(cstring_t, params, "param1", "TEST");
422  amxc_var_add_key(uint32_t, params, "param2", 1024);
423  amxc_var_add_key(cstring_t, params, "param3", "not valid value");
424  assert_int_equal(amxd_object_invoke_function(singleton, "_set", &args, &retval), 0);
425  amxc_var_dump(&retval, STDOUT_FILENO);
426  assert_int_equal(amxc_var_type_of(GETP_ARG(&retval, "'Main.Singleton.'.param2")), AMXC_VAR_ID_HTABLE);
427  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.param2.error_code"), 15);
428  assert_false(GETP_BOOL(&retval, "'Main.Singleton.'.param2.required"));
429 
430  assert_int_equal(amxd_object_get_params(singleton, &verify, amxd_dm_access_protected), 0);
431  amxc_var_dump(&verify, STDOUT_FILENO);
432  assert_int_equal(GET_UINT32(&verify, "param2"), 0);
433  assert_string_equal(GET_CHAR(&verify, "param1"), "TEST");
434 
435  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
436  amxc_var_add_key(uint32_t, &args, "access", amxd_dm_access_protected);
437  params = amxc_var_add_key(amxc_htable_t, &args, "parameters", NULL);
438  amxc_var_add_key(cstring_t, params, "param3", "not valid value");
439  params = amxc_var_add_key(amxc_htable_t, &args, "oparameters", NULL);
440  amxc_var_add_key(cstring_t, params, "param1", "TEST");
441  amxc_var_add_key(uint32_t, params, "param2", 1024);
442  assert_int_not_equal(amxd_object_invoke_function(singleton, "_set", &args, &retval), 0);
443  amxc_var_dump(&retval, STDOUT_FILENO);
444 
445  amxc_var_clean(&retval);
446  amxc_var_clean(&args);
447  amxc_var_clean(&verify);
448 }
amxd_dm.h
Ambiorix Data Model API header file.
amxd_dm_findf
amxd_object_t * amxd_dm_findf(amxd_dm_t *const dm, const char *abs_path,...) __attribute__((format(printf
amxd_object.h
Ambiorix Data Model API header file.
amxd_object_event.h
Ambiorix Data Model API header file.
amxd_param_new
amxd_status_t amxd_param_new(amxd_param_t **param, const char *name, const uint32_t type)
Definition: amxd_parameter.c:239
amxd_param_set_attr
amxd_status_t amxd_param_set_attr(amxd_param_t *param, const amxd_pattr_id_t attr, const bool enable)
Definition: amxd_parameter.c:326
amxd_transaction.h
Ambiorix Data Model API header file.
amxd_pattr_unique
@ amxd_pattr_unique
Definition: amxd_types.h:363
amxd_pattr_key
@ amxd_pattr_key
Definition: amxd_types.h:362
amxd_pattr_read_only
@ amxd_pattr_read_only
Definition: amxd_types.h:358
amxd_oattr_persistent
@ amxd_oattr_persistent
Definition: amxd_types.h:200
amxd_dm_access_protected
@ amxd_dm_access_protected
Definition: amxd_types.h:139
amxd_object_template
@ amxd_object_template
Definition: amxd_types.h:183
amxd_object_singleton
@ amxd_object_singleton
Definition: amxd_types.h:181
amxd_dm_add_root_object
amxd_status_t amxd_dm_add_root_object(amxd_dm_t *const dm, amxd_object_t *const object)
Adds an object to the root of the data model.
Definition: amxd_dm.c:418
amxd_dm_init
amxd_status_t amxd_dm_init(amxd_dm_t *dm)
Initializes a data model structure.
Definition: amxd_dm.c:334
amxd_dm_clean
void amxd_dm_clean(amxd_dm_t *dm)
Cleans a data model structure.
Definition: amxd_dm.c:365
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_add_object
amxd_status_t amxd_object_add_object(amxd_object_t *const parent, amxd_object_t *const child)
Adds an object in the data model tree.
Definition: amxd_object.c:207
amxd_object_get_params
amxd_status_t amxd_object_get_params(amxd_object_t *const object, amxc_var_t *const params, amxd_dm_access_t access)
Gets all parameter values of an object.
Definition: amxd_action_object_read.c:314
amxd_object_add_param
amxd_status_t amxd_object_add_param(amxd_object_t *const object, amxd_param_t *const param)
Adds a parameter definition to an object.
Definition: amxd_object_parameter.c:96
amxd_object_add_function
amxd_status_t amxd_object_add_function(amxd_object_t *const object, amxd_function_t *const func)
Adds an RPC method definition to the object definition.
Definition: amxd_object_function.c:140
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_set_attr
amxd_status_t amxd_object_set_attr(amxd_object_t *const object, const amxd_oattr_id_t attr, const bool enable)
Sets or unsets an object attribute.
Definition: amxd_object.c:269
amxd_object_new
amxd_status_t amxd_object_new(amxd_object_t **object, const amxd_object_type_t type, const char *name)
Data model object constructor function.
Definition: amxd_object.c:185
amxd_object_add_instance
amxd_status_t amxd_object_add_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_action_object_add_inst.c:301
amxd_function_new
amxd_status_t amxd_function_new(amxd_function_t **func, const char *name, const uint32_t ret_type, amxd_object_fn_t impl)
Data model RPC method constructor function.
Definition: amxd_function.c:146
amxd_function_new_arg
amxd_status_t amxd_function_new_arg(amxd_function_t *func, const char *name, const uint32_t type, amxc_var_t *default_value)
Adds an argument definition to a RPC method definition.
Definition: amxd_function_args.c:140
_amxd_dm
Definition: amxd_types.h:259
_amxd_function
RPC method structure.
Definition: amxd_types.h:341
_amxd_object
Definition: amxd_types.h:229
_amxd_parameter
Definition: amxd_types.h:386
test_amxd_set_fails_if_not_partial
void test_amxd_set_fails_if_not_partial(UNUSED void **state)
Definition: test_amxd_function_set.c:372
dm
static amxd_dm_t dm
Definition: test_amxd_function_set.c:78
test_amxd_set_fails_with_invalid_rel_path
void test_amxd_set_fails_with_invalid_rel_path(UNUSED void **state)
Definition: test_amxd_function_set.c:293
test_function_set_teardown
int test_function_set_teardown(UNUSED void **state)
Definition: test_amxd_function_set.c:177
test_amxd_set_optional
void test_amxd_set_optional(UNUSED void **state)
Definition: test_amxd_function_set.c:404
test_amxd_can_set_instance_object
void test_amxd_can_set_instance_object(UNUSED void **state)
Definition: test_amxd_function_set.c:183
test_amxd_set_can_use_rel_path
void test_amxd_set_can_use_rel_path(UNUSED void **state)
Definition: test_amxd_function_set.c:235
test_amxd_set_fails_if_unique_value_exists
void test_amxd_set_fails_if_unique_value_exists(UNUSED void **state)
Definition: test_amxd_function_set.c:209
test_function_set_setup
int test_function_set_setup(UNUSED void **state)
Definition: test_amxd_function_set.c:80
test_amxd_set_can_use_to_high_access
void test_amxd_set_can_use_to_high_access(UNUSED void **state)
Definition: test_amxd_function_set.c:316
test_amxd_set_partial
void test_amxd_set_partial(UNUSED void **state)
Definition: test_amxd_function_set.c:338
test_amxd_function_set.h