libamxd  6.4.1
Data Model Manager
test_amxd_function_get_supported.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_get_supported.h"
76 
77 #include <amxc/amxc_macros.h>
78 static amxd_dm_t dm;
79 
80 int test_function_get_supported_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* instance = NULL;
85  amxd_param_t* param = NULL;
86  amxd_function_t* func = NULL;
87  amxc_var_t def_val;
88 
89  assert_int_equal(amxd_dm_init(&dm), 0);
90  amxc_var_init(&def_val);
91 
92  // object Main
93  assert_int_equal(amxd_object_new(&root, amxd_object_singleton, "Main"), 0);
94  assert_int_equal(amxd_dm_add_root_object(&dm, root), 0);
95 
96  // %read-only object Main.Template[]
97  assert_int_equal(amxd_object_new(&template, amxd_object_template, "Template"), 0);
98  amxd_object_set_attr(template, amxd_oattr_read_only, true);
99  assert_int_equal(amxd_object_add_object(root, template), 0);
100  // string param1
101  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
102  assert_int_equal(amxd_object_add_param(template, param), 0);
103  // %read-only uint32 param2
104  assert_int_equal(amxd_param_new(&param, "param2", AMXC_VAR_ID_UINT32), 0);
105  amxd_param_set_attr(param, amxd_pattr_read_only, true);
106  assert_int_equal(amxd_object_add_param(template, param), 0);
107  // %key string param3
108  assert_int_equal(amxd_param_new(&param, "param3", AMXC_VAR_ID_CSTRING), 0);
109  amxd_param_set_attr(param, amxd_pattr_key, true);
110  assert_int_equal(amxd_object_add_param(template, param), 0);
111  // htable func1(%mandatory %in string arg1, %in uint32 arg2 = 10)
112  assert_int_equal(amxd_function_new(&func, "func1", AMXC_VAR_ID_HTABLE, NULL), 0);
113  assert_int_equal(amxd_function_new_arg(func, "arg1", AMXC_VAR_ID_CSTRING, NULL), 0);
114  amxc_var_set(uint32_t, &def_val, 10);
115  assert_int_equal(amxd_function_new_arg(func, "arg2", AMXC_VAR_ID_UINT32, &def_val), 0);
116  assert_int_equal(amxd_object_add_function(template, func), 0);
117 
118  assert_int_equal(amxd_object_add_event(template, "MyEvent!"), 0);
119 
120  assert_int_equal(amxd_object_new(&singleton, amxd_object_singleton, "SubObject"), 0);
121  amxd_object_set_attr(singleton, amxd_oattr_persistent, true);
122  assert_int_equal(amxd_object_add_object(template, singleton), 0);
123  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
124  assert_int_equal(amxd_object_add_param(singleton, param), 0);
125 
126  assert_int_equal(amxd_object_new(&singleton, amxd_object_singleton, "PrivateSubObject"), 0);
127  amxd_object_set_attr(singleton, amxd_oattr_private, true);
128  assert_int_equal(amxd_object_add_object(template, singleton), 0);
129  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
130  assert_int_equal(amxd_object_add_param(singleton, param), 0);
131 
132  assert_int_equal(amxd_object_new(&singleton, amxd_object_singleton, "ProtectedSubObject"), 0);
133  amxd_object_set_attr(singleton, amxd_oattr_protected, true);
134  assert_int_equal(amxd_object_add_object(template, singleton), 0);
135  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
136  assert_int_equal(amxd_object_add_param(singleton, param), 0);
137 
138  // %persistent object Main.Singleton
139  assert_int_equal(amxd_object_new(&singleton, amxd_object_singleton, "Singleton"), 0);
140  amxd_object_set_attr(singleton, amxd_oattr_persistent, true);
141  assert_int_equal(amxd_object_add_object(root, singleton), 0);
142  // string param1
143  assert_int_equal(amxd_param_new(&param, "param1", AMXC_VAR_ID_CSTRING), 0);
144  assert_int_equal(amxd_object_add_param(singleton, param), 0);
145  // %read-only uint32 param2
146  assert_int_equal(amxd_param_new(&param, "param2", AMXC_VAR_ID_UINT32), 0);
147  amxd_param_set_attr(param, amxd_pattr_read_only, true);
148  amxd_param_set_attr(param, amxd_pattr_variable, true);
149  assert_int_equal(amxd_object_add_param(singleton, param), 0);
150  // htable func1(%mandatory %in string arg1, %in uint32 arg2 = 10)
151  assert_int_equal(amxd_function_new(&func, "func1", AMXC_VAR_ID_HTABLE, NULL), 0);
152  assert_int_equal(amxd_function_new_arg(func, "arg1", AMXC_VAR_ID_CSTRING, NULL), 0);
153  amxc_var_set(uint32_t, &def_val, 10);
154  assert_int_equal(amxd_function_new_arg(func, "arg2", AMXC_VAR_ID_UINT32, &def_val), 0);
155  assert_int_equal(amxd_object_add_function(singleton, func), 0);
156 
157  amxc_var_set_type(&def_val, AMXC_VAR_ID_HTABLE);
158  amxc_var_add_key(cstring_t, &def_val, "param3", "Key1");
159  assert_int_equal(amxd_object_add_instance(&instance, template, "Instance1", 0, &def_val), 0);
160  amxc_var_set_type(&def_val, AMXC_VAR_ID_HTABLE);
161  amxc_var_add_key(cstring_t, &def_val, "param3", "Key2");
162  assert_int_equal(amxd_object_add_instance(&instance, template, "Instance2", 0, &def_val), 0);
163 
164  amxc_var_clean(&def_val);
165  return 0;
166 }
167 
168 int test_function_get_supported_teardown(UNUSED void** state) {
169  amxd_dm_clean(&dm);
170 
171  return 0;
172 }
173 
174 void test_amxd_can_get_supported_singleton_object(UNUSED void** state) {
175  amxd_object_t* singleton = NULL;
176  amxc_var_t retval;
177  amxc_var_t args;
178 
179  amxc_var_init(&args);
180  amxc_var_init(&retval);
181 
182  singleton = amxd_dm_findf(&dm, "Main.Singleton");
183  assert_non_null(singleton);
184 
185  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
186  assert_int_equal(amxd_object_invoke_function(singleton, "_get_supported", &args, &retval), 0);
187 
188  assert_non_null(GET_ARG(&retval, "Main.Singleton."));
189  amxc_var_dump(&retval, STDOUT_FILENO);
190 
191  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
192  amxc_var_add_key(bool, &args, "parameters", true);
193  assert_int_equal(amxd_object_invoke_function(singleton, "_get_supported", &args, &retval), 0);
194  assert_non_null(GET_ARG(&retval, "Main.Singleton."));
195  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.0.value_change"));
196  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.0.value_change"), 1);
197  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.0.access"));
198  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.0.access"), 1);
199  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.0.type"));
200  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.0.type"), 1);
201  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.1.value_change"));
202  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.1.value_change"), 2);
203  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.1.access"));
204  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.1.access"), 0);
205  assert_non_null(GETP_ARG(&retval, "'Main.Singleton.'.supported_params.1.type"));
206  assert_int_equal(GETP_UINT32(&retval, "'Main.Singleton.'.supported_params.1.type"), 8);
207  amxc_var_dump(&retval, STDOUT_FILENO);
208 
209  amxc_var_clean(&retval);
210  amxc_var_clean(&args);
211 }
212 
213 void test_amxd_can_get_supported_template_object(UNUSED void** state) {
214  amxd_object_t* templ = NULL;
215  amxc_var_t retval;
216  amxc_var_t args;
217 
218  amxc_var_init(&args);
219  amxc_var_init(&retval);
220 
221  templ = amxd_dm_findf(&dm, "Main.Template");
222  assert_non_null(templ);
223 
224  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
225  assert_int_equal(amxd_object_invoke_function(templ, "_get_supported", &args, &retval), 0);
226 
227  amxc_var_dump(&retval, STDOUT_FILENO);
228  assert_non_null(GET_ARG(&retval, "Main.Template.{i}."));
229  assert_true(GETP_BOOL(&retval, "'Main.Template.{i}.'.is_multi_instance"));
230  assert_int_equal(GETP_INT32(&retval, "'Main.Template.{i}.'.supported_params.2.access"), 0);
231  assert_non_null(GET_ARG(&retval, "Main.Template.{i}.SubObject."));
232  assert_false(GETP_BOOL(&retval, "'Main.Template.{i}.SubObject'.is_multi_instance"));
233 
234  amxc_var_clean(&retval);
235  amxc_var_clean(&args);
236 }
237 
238 void test_amxd_get_supported_instance_object_succeeds(UNUSED void** state) {
239  amxd_object_t* inst = NULL;
240  amxc_var_t retval;
241  amxc_var_t args;
242 
243  amxc_var_init(&args);
244  amxc_var_init(&retval);
245 
246  inst = amxd_dm_findf(&dm, "Main.Template.1.");
247  assert_non_null(inst);
248 
249  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
250  assert_int_equal(amxd_object_invoke_function(inst, "_get_supported", &args, &retval), 0);
251  amxc_var_dump(&retval, STDOUT_FILENO);
252 
253  inst = amxd_dm_findf(&dm, "Main.Template.1.SubObject");
254  assert_non_null(inst);
255 
256  assert_int_equal(amxd_object_invoke_function(inst, "_get_supported", &args, &retval), 0);
257  amxc_var_dump(&retval, STDOUT_FILENO);
258 
259  amxc_var_clean(&retval);
260  amxc_var_clean(&args);
261 }
262 
263 void test_amxd_can_get_supported_template_object_parameters(UNUSED void** state) {
264  amxd_object_t* templ = NULL;
265  amxc_var_t retval;
266  amxc_var_t args;
267 
268  amxc_var_init(&args);
269  amxc_var_init(&retval);
270 
271  templ = amxd_dm_findf(&dm, "Main.Template");
272  assert_non_null(templ);
273 
274  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
275  amxc_var_add_key(bool, &args, "first_level_only", false);
276  amxc_var_add_key(bool, &args, "parameters", true);
277  assert_int_equal(amxd_object_invoke_function(templ, "_get_supported", &args, &retval), 0);
278 
279  amxc_var_dump(&retval, STDOUT_FILENO);
280  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"));
281  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"), "param1");
282  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.type"));
283  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
284  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"));
285  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"), "param2");
286  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.type"));
287  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.1.type"), AMXC_VAR_ID_UINT32);
288  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.param_name"));
289  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.param_name"), "param1");
290  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.type"));
291  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
292  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.ProtectedSubObject.'.supported_params.0.type"));
293  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.ProtectedSubObject.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
294 
295  amxc_var_clean(&retval);
296  amxc_var_clean(&args);
297 }
298 
299 void test_amxd_can_get_supported_template_object_parameters_public_access(UNUSED void** state) {
300  amxd_object_t* templ = NULL;
301  amxc_var_t retval;
302  amxc_var_t args;
303 
304  amxc_var_init(&args);
305  amxc_var_init(&retval);
306 
307  templ = amxd_dm_findf(&dm, "Main.Template");
308  assert_non_null(templ);
309 
310  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
311  amxc_var_add_key(bool, &args, "first_level_only", false);
312  amxc_var_add_key(bool, &args, "parameters", true);
313  amxc_var_add_key(uint32_t, &args, "access", amxd_dm_access_public);
314  assert_int_equal(amxd_object_invoke_function(templ, "_get_supported", &args, &retval), 0);
315 
316  amxc_var_dump(&retval, STDOUT_FILENO);
317  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"));
318  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"), "param1");
319  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.type"));
320  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
321  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"));
322  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"), "param2");
323  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.type"));
324  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.1.type"), AMXC_VAR_ID_UINT32);
325  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.param_name"));
326  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.param_name"), "param1");
327  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.type"));
328  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.SubObject.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
329  assert_null(GETP_ARG(&retval, "'Main.Template.{i}.ProtectedSubObject.'.supported_params.0.type"));
330 
331  amxc_var_clean(&retval);
332  amxc_var_clean(&args);
333 }
334 
335 void test_amxd_can_get_supported_template_object_parameters_first_level(UNUSED void** state) {
336  amxd_object_t* templ = NULL;
337  amxc_var_t retval;
338  amxc_var_t args;
339 
340  amxc_var_init(&args);
341  amxc_var_init(&retval);
342 
343  templ = amxd_dm_findf(&dm, "Main.Template");
344  assert_non_null(templ);
345 
346  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
347  amxc_var_add_key(bool, &args, "first_level_only", true);
348  amxc_var_add_key(bool, &args, "parameters", true);
349  assert_int_equal(amxd_object_invoke_function(templ, "_get_supported", &args, &retval), 0);
350 
351  amxc_var_dump(&retval, STDOUT_FILENO);
352  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"));
353  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.0.param_name"), "param1");
354  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.0.type"));
355  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.0.type"), AMXC_VAR_ID_CSTRING);
356  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"));
357  assert_string_equal(GETP_CHAR(&retval, "'Main.Template.{i}.'.supported_params.1.param_name"), "param2");
358  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_params.1.type"));
359  assert_int_equal(GETP_UINT32(&retval, "'Main.Template.{i}.'.supported_params.1.type"), AMXC_VAR_ID_UINT32);
360  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'"));
361  assert_null(GETP_ARG(&retval, "'Main.Template.{i}.SubObject.'.supported_params"));
362 
363  amxc_var_clean(&retval);
364  amxc_var_clean(&args);
365 }
366 
367 void test_amxd_can_get_supported_template_object_events(UNUSED void** state) {
368  amxd_object_t* templ = NULL;
369  amxc_var_t retval;
370  amxc_var_t args;
371 
372  amxc_var_init(&args);
373  amxc_var_init(&retval);
374 
375  templ = amxd_dm_findf(&dm, "Main.Template");
376  assert_non_null(templ);
377 
378  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
379  amxc_var_add_key(bool, &args, "first_level_only", false);
380  amxc_var_add_key(bool, &args, "events", true);
381  assert_int_equal(amxd_object_invoke_function(templ, "_get_supported", &args, &retval), 0);
382 
383  amxc_var_dump(&retval, STDOUT_FILENO);
384  assert_non_null(GETP_ARG(&retval, "'Main.Template.{i}.'.supported_events.'MyEvent!'"));
385 
386  amxc_var_clean(&retval);
387  amxc_var_clean(&args);
388 }
389 
390 void test_amxd_get_supported_can_use_rel_path(UNUSED void** state) {
391  amxd_object_t* root = NULL;
392  amxc_var_t retval;
393  amxc_var_t args;
394 
395  amxc_var_init(&args);
396  amxc_var_init(&retval);
397 
398  root = amxd_dm_findf(&dm, "Main.");
399  assert_non_null(root);
400 
401  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
402  amxc_var_add_key(cstring_t, &args, "rel_path", "Singleton.");
403  assert_int_equal(amxd_object_invoke_function(root, "_get_supported", &args, &retval), 0);
404 
405  amxc_var_clean(&retval);
406  amxc_var_clean(&args);
407 }
408 
409 void test_amxd_get_supported_fails_with_invalid_rel_path(UNUSED void** state) {
410  amxd_object_t* root = NULL;
411  amxc_var_t retval;
412  amxc_var_t args;
413 
414  amxc_var_init(&args);
415  amxc_var_init(&retval);
416 
417  root = amxd_dm_findf(&dm, "Main.");
418  assert_non_null(root);
419 
420  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
421  amxc_var_add_key(cstring_t, &args, "rel_path", "NotExisting.Object.");
422  assert_int_not_equal(amxd_object_invoke_function(root, "_get_supported", &args, &retval), 0);
423 
424  amxc_var_clean(&retval);
425  amxc_var_clean(&args);
426 }
427 
428 
429 void test_amxd_get_supported_can_use_to_high_access(UNUSED void** state) {
430  amxd_object_t* singleton = NULL;
431  amxc_var_t retval;
432  amxc_var_t args;
433 
434  amxc_var_init(&args);
435  amxc_var_init(&retval);
436 
437  singleton = amxd_dm_findf(&dm, "Main.Singleton.");
438  assert_non_null(singleton);
439 
440  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
441  amxc_var_add_key(uint32_t, &args, "access", 100);
442  assert_int_equal(amxd_object_invoke_function(singleton, "_get_supported", &args, &retval), 0);
443  amxc_var_dump(&retval, STDOUT_FILENO);
444 
445  amxc_var_clean(&retval);
446  amxc_var_clean(&args);
447 }
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_variable
@ amxd_pattr_variable
Definition: amxd_types.h:360
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_read_only
@ amxd_oattr_read_only
Definition: amxd_types.h:199
amxd_oattr_protected
@ amxd_oattr_protected
Definition: amxd_types.h:210
amxd_oattr_persistent
@ amxd_oattr_persistent
Definition: amxd_types.h:200
amxd_oattr_private
@ amxd_oattr_private
Definition: amxd_types.h:202
amxd_dm_access_public
@ amxd_dm_access_public
Definition: amxd_types.h:136
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_add_event
amxd_status_t amxd_object_add_event(amxd_object_t *const object, const char *event_name)
Adds an event definition to the object.
Definition: amxd_object_event.c:411
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_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_function_get_supported_setup
int test_function_get_supported_setup(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:80
test_amxd_get_supported_can_use_rel_path
void test_amxd_get_supported_can_use_rel_path(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:390
test_amxd_get_supported_fails_with_invalid_rel_path
void test_amxd_get_supported_fails_with_invalid_rel_path(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:409
test_amxd_can_get_supported_template_object_parameters_public_access
void test_amxd_can_get_supported_template_object_parameters_public_access(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:299
dm
static amxd_dm_t dm
Definition: test_amxd_function_get_supported.c:78
test_amxd_can_get_supported_template_object
void test_amxd_can_get_supported_template_object(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:213
test_amxd_can_get_supported_template_object_parameters_first_level
void test_amxd_can_get_supported_template_object_parameters_first_level(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:335
test_amxd_can_get_supported_singleton_object
void test_amxd_can_get_supported_singleton_object(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:174
test_amxd_get_supported_can_use_to_high_access
void test_amxd_get_supported_can_use_to_high_access(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:429
test_amxd_get_supported_instance_object_succeeds
void test_amxd_get_supported_instance_object_succeeds(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:238
test_amxd_can_get_supported_template_object_parameters
void test_amxd_can_get_supported_template_object_parameters(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:263
test_function_get_supported_teardown
int test_function_get_supported_teardown(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:168
test_amxd_can_get_supported_template_object_events
void test_amxd_can_get_supported_template_object_events(UNUSED void **state)
Definition: test_amxd_function_get_supported.c:367
test_amxd_function_get_supported.h