libamxd  6.4.1
Data Model Manager
test_amxd_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_object.h>
71 #include <amxd/amxd_function.h>
72 
73 #include "test_amxd_function.h"
74 
75 #include <amxc/amxc_macros.h>
76 static amxd_status_t test_func(amxd_object_t* object,
77  amxd_function_t* func,
78  amxc_var_t* args,
79  amxc_var_t* ret) {
80  assert_ptr_not_equal(object, NULL);
81  assert_ptr_not_equal(func, NULL);
82  assert_ptr_not_equal(args, NULL);
83  assert_ptr_not_equal(ret, NULL);
84  assert_int_equal(amxc_var_type_of(args), AMXC_VAR_ID_HTABLE);
85 
86  return 0;
87 }
88 
89 static amxd_status_t test_func2(amxd_object_t* object,
90  amxd_function_t* func,
91  amxc_var_t* args,
92  amxc_var_t* ret) {
93  assert_ptr_not_equal(object, NULL);
94  assert_ptr_not_equal(func, NULL);
95  assert_ptr_not_equal(args, NULL);
96  assert_ptr_not_equal(ret, NULL);
97  assert_int_equal(amxc_var_type_of(args), AMXC_VAR_ID_HTABLE);
98 
99  return 0;
100 }
101 
102 static amxd_status_t test_func3(amxd_object_t* object,
103  amxd_function_t* func,
104  amxc_var_t* args,
105  amxc_var_t* ret) {
106  assert_ptr_not_equal(object, NULL);
107  assert_ptr_not_equal(func, NULL);
108  assert_ptr_not_equal(args, NULL);
109  assert_ptr_not_equal(ret, NULL);
110  assert_int_equal(amxc_var_type_of(args), AMXC_VAR_ID_HTABLE);
111 
112  return amxd_function_call_base(func, object, args, ret);
113 }
114 
115 void test_amxd_function_new_delete(UNUSED void** state) {
116  amxd_function_t* function = NULL;
117 
118  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_ANY, test_func), 0);
119  assert_ptr_not_equal(function, NULL);
120  assert_ptr_equal(function->impl, test_func);
121  assert_int_equal(function->ret_type, AMXC_VAR_ID_ANY);
122  assert_string_equal(function->name, "test_func");
123  assert_int_equal(function->attr.instance, 0);
124  assert_int_equal(function->attr.priv, 0);
125  assert_int_equal(function->attr.templ, 0);
126 
127  amxd_function_delete(&function);
128  assert_ptr_equal(function, NULL);
129  amxd_function_delete(&function);
130 
131 
132  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
133  amxd_function_delete(&function);
134  assert_ptr_equal(function, NULL);
135 }
136 
137 void test_amxd_function_new_delete_invalid_args(UNUSED void** state) {
138  amxd_function_t* function = NULL;
139 
140  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, NULL), 0);
141  assert_ptr_not_equal(function, NULL);
142  amxd_function_delete(&function);
143 
144  assert_int_not_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CUSTOM_BASE + 100, test_func), 0);
145  assert_ptr_equal(function, NULL);
146 
147  assert_int_not_equal(amxd_function_new(NULL, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
148  assert_ptr_equal(function, NULL);
149 
150  assert_int_not_equal(amxd_function_new(&function, "123", AMXC_VAR_ID_CSTRING, test_func), 0);
151  assert_ptr_equal(function, NULL);
152  assert_int_not_equal(amxd_function_new(&function, "test@func", AMXC_VAR_ID_CSTRING, test_func), 0);
153  assert_ptr_equal(function, NULL);
154  assert_int_not_equal(amxd_function_new(&function, "", AMXC_VAR_ID_CSTRING, test_func), 0);
155  assert_ptr_equal(function, NULL);
156  assert_int_not_equal(amxd_function_new(&function, NULL, AMXC_VAR_ID_CSTRING, test_func), 0);
157  assert_ptr_equal(function, NULL);
158 
159  amxd_function_delete(&function);
160 }
161 
162 void test_amxd_function_copy(UNUSED void** state) {
163  amxd_function_t* function = NULL;
164  amxd_function_t* cfunction = NULL;
165 
166  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
167  assert_int_equal(amxd_function_copy(&cfunction, function), 0);
168  assert_ptr_equal(cfunction->impl, test_func);
169  assert_int_equal(cfunction->ret_type, AMXC_VAR_ID_CSTRING);
170  assert_string_equal(cfunction->name, "test_func");
171  assert_int_equal(cfunction->attr.instance, 0);
172  assert_int_equal(cfunction->attr.priv, 0);
173  assert_int_equal(cfunction->attr.templ, 0);
174  amxd_function_delete(&function);
175  amxd_function_delete(&cfunction);
176 }
177 
178 void test_amxd_function_copy_with_args(UNUSED void** state) {
179  amxd_function_t* function = NULL;
180  amxd_function_t* cfunction = NULL;
181 
182  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
183  assert_int_equal(amxd_function_new_arg(function, "arg1", AMXC_VAR_ID_UINT32, NULL), 0);
184  assert_int_equal(amxd_function_new_arg(function, "arg2", AMXC_VAR_ID_UINT32, NULL), 0);
185  assert_int_equal(amxd_function_copy(&cfunction, function), 0);
186  assert_int_equal(amxc_llist_size(&cfunction->args), 2);
187  amxd_function_delete(&function);
188  amxd_function_delete(&cfunction);
189 }
190 
191 void test_amxd_function_copy_with_attributes(UNUSED void** state) {
192  amxd_function_t* function = NULL;
193  amxd_function_t* cfunction = NULL;
194 
195  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
196  assert_int_equal(amxd_function_new_arg(function, "arg1", AMXC_VAR_ID_UINT32, NULL), 0);
197  assert_int_equal(amxd_function_new_arg(function, "arg2", AMXC_VAR_ID_UINT32, NULL), 0);
198  amxd_function_set_attr(function, amxd_fattr_private, true);
199  assert_int_equal(amxd_function_copy(&cfunction, function), 0);
200  assert_int_equal(cfunction->attr.priv, 1);
201  assert_int_equal(amxc_llist_size(&cfunction->args), 2);
202  amxd_function_delete(&function);
203  amxd_function_delete(&cfunction);
204 }
205 
206 void test_amxd_function_copy_invalid(UNUSED void** state) {
207  amxd_function_t* function = NULL;
208  amxd_function_t* cfunction = NULL;
209 
210  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
211  assert_int_equal(amxd_function_new_arg(function, "arg1", AMXC_VAR_ID_UINT32, NULL), 0);
212  assert_int_equal(amxd_function_new_arg(function, "arg2", AMXC_VAR_ID_UINT32, NULL), 0);
213  amxd_function_set_attr(function, amxd_fattr_private, true);
214 
215  assert_int_not_equal(amxd_function_copy(NULL, function), 0);
216  assert_int_not_equal(amxd_function_copy(&cfunction, NULL), 0);
217  assert_ptr_equal(cfunction, NULL);
218 
219  amxd_function_delete(&function);
220  amxd_function_delete(&function);
221 }
222 
223 void test_amxd_function_get_owner_invalid(UNUSED void** state) {
224  amxd_function_t* function = NULL;
225 
226  assert_int_equal(amxd_function_new(&function, "templ_func", AMXC_VAR_ID_CSTRING, test_func), 0);
227  assert_ptr_equal(amxd_function_get_owner(NULL), NULL);
228  assert_ptr_equal(amxd_function_get_owner(function), NULL);
229 
230  amxd_function_delete(&function);
231 }
232 
233 void test_amxd_function_get_base(UNUSED void** state) {
234  amxd_object_t* template = NULL;
235  amxd_object_t* object = NULL;
236  amxd_object_t* instance = NULL;
237  amxd_object_t* instance_object = NULL;
238  amxd_function_t* function = NULL;
239  amxd_function_t* base_function = NULL;
240  amxd_dm_t dm;
241 
242  assert_int_equal(amxd_dm_init(&dm), 0);
243 
244  assert_int_equal(amxd_object_new(&template, amxd_object_template, "parent"), 0);
245  assert_int_equal(amxd_dm_add_root_object(&dm, template), 0);
246  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
247  assert_int_equal(amxd_object_add_object(template, object), 0);
248  assert_int_equal(amxd_function_new(&function, "templ_func", AMXC_VAR_ID_CSTRING, test_func), 0);
249  assert_int_equal(amxd_object_add_function(template, function), 0);
250  assert_int_equal(amxd_function_new(&function, "child_func", AMXC_VAR_ID_CSTRING, test_func2), 0);
251  assert_int_equal(amxd_object_add_function(object, function), 0);
252 
253  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
254  function = amxd_object_get_function(instance, "templ_func");
255  assert_ptr_not_equal(function, NULL);
256  assert_ptr_equal(amxd_function_get_owner(function), template);
257 
258  instance_object = amxd_object_get(instance, "child");
259  assert_ptr_not_equal(instance_object, NULL);
260  assert_ptr_equal(amxd_object_get_parent(instance_object), instance);
261  assert_ptr_equal(instance_object->derived_from.llist, &object->derived_objects);
262  assert_ptr_equal(instance_object->type, amxd_object_singleton);
263  function = amxd_object_get_function(instance_object, "child_func");
264  assert_ptr_not_equal(function, NULL);
265  assert_ptr_equal(amxd_function_get_owner(function), object);
266 
267  assert_int_equal(amxd_object_change_function(instance_object, "child_func", test_func), 0);
268  function = amxd_object_get_function(instance_object, "child_func");
269  base_function = amxd_function_get_base(function);
270  assert_ptr_not_equal(function, base_function);
271  assert_ptr_equal(amxd_function_get_owner(base_function), object);
272  assert_ptr_equal(amxd_function_get_owner(function), instance_object);
273 
274  function = amxd_object_get_function(instance, "templ_func");
275  base_function = amxd_function_get_base(function);
276  assert_ptr_equal(base_function, NULL);
277  assert_ptr_not_equal(function, NULL);
278  assert_ptr_equal(amxd_function_get_owner(function), template);
279 
280  assert_int_equal(amxd_object_change_function(instance, "templ_func", test_func2), 0);
281  function = amxd_object_get_function(instance, "templ_func");
282  base_function = amxd_function_get_base(function);
283  assert_ptr_not_equal(base_function, NULL);
284  assert_ptr_not_equal(function, NULL);
285  assert_ptr_not_equal(function, base_function);
286  assert_ptr_equal(amxd_function_get_owner(function), instance);
287  assert_ptr_equal(amxd_function_get_owner(base_function), template);
288 
289  amxd_dm_clean(&dm);
290 }
291 
292 void test_amxd_function_get_base_invalid(UNUSED void** state) {
293  amxd_function_t* function = NULL;
294  amxd_object_t* object = NULL;
295 
296  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
297  assert_int_equal(amxd_function_new(&function, "templ_func", AMXC_VAR_ID_CSTRING, test_func), 0);
298  assert_int_equal(amxd_object_add_function(object, function), 0);
299 
300  amxc_llist_it_take(&object->derived_from);
301 
302  assert_ptr_equal(amxd_function_get_base(NULL), NULL);
303  assert_ptr_equal(amxd_function_get_base(function), NULL);
304 
305  amxd_function_delete(&function);
306  amxd_object_delete(&object);
307 }
308 
309 void test_amxd_can_call_base(UNUSED void** state) {
310  amxd_dm_t dm;
311  amxd_function_t* function = NULL;
312  amxd_object_t* object = NULL;
313  amxd_object_t* base_object = NULL;
314  amxc_var_t args;
315  amxc_var_t ret;
316 
317  amxc_var_init(&args);
318  amxc_var_init(&ret);
319 
320  assert_int_equal(amxd_dm_init(&dm), 0);
321 
322  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
323  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
324  assert_int_equal(amxd_function_new(&function, "_get", AMXC_VAR_ID_CSTRING, test_func3), 0);
325  assert_int_equal(amxd_object_add_function(object, function), 0);
326 
327  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
328  assert_int_equal(amxd_object_invoke_function(object, "_get", &args, &ret), 0);
329 
330  base_object = amxd_object_get_base(object);
331  function = amxd_object_get_function(base_object, "_get");
332  assert_int_equal(amxd_function_set_impl(function, NULL), 0);
333  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
334  assert_int_not_equal(amxd_object_invoke_function(object, "_get()", &args, &ret), 0);
335 
336  function = amxd_object_get_function(object, "_set");
337  assert_non_null(function);
338 
339  assert_int_equal(amxd_function_set_impl(function, test_func3), 0);
340  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
341  assert_int_not_equal(amxd_object_invoke_function(object, "_set()", &args, &ret), 0);
342 
343  amxc_var_clean(&args);
344  amxc_var_clean(&ret);
345  amxd_dm_clean(&dm);
346 }
347 
348 void test_amxd_function_get_name_invalid(UNUSED void** state) {
349  assert_ptr_equal(amxd_function_get_name(NULL), NULL);
350 }
351 
352 void test_amxd_function_attributes(UNUSED void** state) {
353  amxd_function_t* function = NULL;
354 
355  assert_int_equal(amxd_function_new(&function, "templ_func", AMXC_VAR_ID_CSTRING, test_func), 0);
356  assert_false(amxd_function_is_attr_set(function, amxd_fattr_template));
357  assert_false(amxd_function_is_attr_set(function, amxd_fattr_instance));
358  assert_false(amxd_function_is_attr_set(function, amxd_fattr_private));
359 
360  assert_int_equal(amxd_function_set_attr(function, amxd_fattr_template, true), 0);
361  assert_true(amxd_function_is_attr_set(function, amxd_fattr_template));
362  assert_int_equal(amxd_function_set_attr(function, amxd_fattr_template, false), 0);
363  assert_false(amxd_function_is_attr_set(function, amxd_fattr_template));
364 
365  assert_int_equal(amxd_function_set_attr(function, amxd_fattr_instance, true), 0);
366  assert_true(amxd_function_is_attr_set(function, amxd_fattr_instance));
367  assert_int_equal(amxd_function_set_attr(function, amxd_fattr_instance, false), 0);
368  assert_false(amxd_function_is_attr_set(function, amxd_fattr_instance));
369 
370  assert_int_equal(amxd_function_set_attr(function, amxd_fattr_private, true), 0);
371  assert_true(amxd_function_is_attr_set(function, amxd_fattr_private));
372  assert_int_equal(amxd_function_set_attr(function, amxd_fattr_private, false), 0);
373  assert_false(amxd_function_is_attr_set(function, amxd_fattr_private));
374 
375  assert_int_not_equal(amxd_function_set_attr(NULL, amxd_fattr_private, true), 0);
376  assert_false(amxd_function_is_attr_set(NULL, amxd_fattr_private));
377 
378  assert_int_equal(amxd_function_set_attrs(function, SET_BIT(amxd_fattr_template) |
379  SET_BIT(amxd_fattr_instance) |
380  SET_BIT(amxd_fattr_private) |
381  SET_BIT(amxd_fattr_async), false), 0);
382  assert_false(amxd_function_is_attr_set(function, amxd_fattr_template));
383  assert_false(amxd_function_is_attr_set(function, amxd_fattr_instance));
384  assert_false(amxd_function_is_attr_set(function, amxd_fattr_private));
385  assert_false(amxd_function_is_attr_set(function, amxd_fattr_async));
386 
387  assert_int_equal(amxd_function_set_attrs(function, SET_BIT(amxd_fattr_template) |
388  SET_BIT(amxd_fattr_instance) |
389  SET_BIT(amxd_fattr_private) |
390  SET_BIT(amxd_fattr_async), true), 0);
391  assert_true(amxd_function_is_attr_set(function, amxd_fattr_template));
392  assert_true(amxd_function_is_attr_set(function, amxd_fattr_instance));
393  assert_true(amxd_function_is_attr_set(function, amxd_fattr_private));
394  assert_true(amxd_function_is_attr_set(function, amxd_fattr_async));
395 
396  assert_int_equal(amxd_function_set_attrs(function, SET_BIT(amxd_fattr_template) |
397  SET_BIT(amxd_fattr_instance) |
398  SET_BIT(amxd_fattr_private), false), 0);
399  assert_false(amxd_function_is_attr_set(function, amxd_fattr_template));
400  assert_false(amxd_function_is_attr_set(function, amxd_fattr_instance));
401  assert_false(amxd_function_is_attr_set(function, amxd_fattr_private));
402 
403  assert_int_not_equal(amxd_function_set_attrs(function, SET_BIT(amxd_fattr_template) |
404  SET_BIT(amxd_fattr_instance) |
405  SET_BIT(amxd_fattr_private) |
406  SET_BIT(5), false), 0);
407  assert_int_not_equal(amxd_function_set_attrs(NULL, SET_BIT(amxd_fattr_template) |
408  SET_BIT(amxd_fattr_instance) |
409  SET_BIT(amxd_fattr_private), true), 0);
410 
411  amxd_function_delete(&function);
412 }
413 
414 void test_amxd_function_are_args_valid(UNUSED void** state) {
415  amxd_function_t* function = NULL;
416  amxd_object_t* object = NULL;
417 
418  amxc_var_t def_val;
419  amxc_var_t args;
420  amxc_var_t ret;
421  amxc_var_init(&def_val);
422  amxc_var_init(&args);
423  amxc_var_init(&ret);
424  amxc_var_set(uint32_t, &def_val, 10);
425 
426  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "test_object"), 0);
427 
428  assert_int_equal(amxd_function_new(&function, "my_func", AMXC_VAR_ID_CSTRING, test_func), 0);
429  assert_int_equal(amxd_function_new_arg(function, "arg1", AMXC_VAR_ID_UINT32, NULL), 0);
430  amxd_function_arg_set_attr(function, "arg1", amxd_aattr_mandatory, true);
431  amxd_function_arg_set_attr(function, "arg1", amxd_aattr_in, true);
432  assert_int_equal(amxd_function_new_arg(function, "arg2", AMXC_VAR_ID_UINT32, &def_val), 0);
433  amxd_function_arg_set_attr(function, "arg2", amxd_aattr_strict, true);
434  amxd_function_arg_set_attr(function, "arg2", amxd_aattr_in, true);
435  amxc_var_set(cstring_t, &def_val, "Hello");
436  assert_int_equal(amxd_function_new_arg(function, "arg3", AMXC_VAR_ID_CSTRING, &def_val), 0);
437  amxd_function_arg_set_attr(function, "arg3", amxd_aattr_in, true);
438  assert_int_equal(amxd_function_new_arg(function, "arg4", AMXC_VAR_ID_BOOL, NULL), 0);
439  amxd_function_arg_set_attr(function, "arg4", amxd_aattr_out, true);
440  amxd_function_arg_set_attr(function, "arg4", amxd_aattr_in, false);
441 
442  assert_int_equal(amxd_object_add_function(object, function), 0);
443 
444  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
445  amxc_var_add_key(cstring_t, &args, "arg1", "0xFF");
446  amxc_var_add_key(uint32_t, &args, "arg2", 123);
447  amxc_var_add_key(cstring_t, &args, "arg3", "test test");
448  assert_int_equal(amxd_object_invoke_function(object, "my_func", &args, &ret), 0);
449  amxc_var_clean(&args);
450 
451  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
452  amxc_var_add_key(cstring_t, &args, "arg1", "0xFF");
453  amxc_var_add_key(bool, &args, "arg2", true);
454  amxc_var_add_key(cstring_t, &args, "arg3", "test test");
455  assert_int_not_equal(amxd_object_invoke_function(object, "my_func", &args, &ret), 0);
456  amxc_var_clean(&args);
457 
458  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
459  amxc_var_add_key(cstring_t, &args, "arg1", "0xFF");
460  amxc_var_add_key(uint32_t, &args, "arg2", 999);
461  assert_int_equal(amxd_object_invoke_function(object, "my_func", &args, &ret), 0);
462  amxc_var_clean(&args);
463 
464  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
465  amxc_var_add_key(uint32_t, &args, "arg2", 999);
466  assert_int_not_equal(amxd_object_invoke_function(object, "my_func", &args, &ret), 0);
467  amxc_var_clean(&args);
468 
469  amxc_var_set_type(&args, AMXC_VAR_ID_LIST);
470  amxc_var_add(cstring_t, &args, "0xFF");
471  amxc_var_add(uint32_t, &args, 123);
472  amxc_var_add(cstring_t, &args, "test test");
473  assert_int_not_equal(amxd_object_invoke_function(object, "my_func", &args, &ret), 0);
474  amxc_var_clean(&args);
475 
476  amxd_function_delete(&function);
477 
478  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
479  assert_int_equal(amxd_function_new(&function, "my_func", AMXC_VAR_ID_CSTRING, test_func), 0);
480  assert_int_equal(amxd_object_add_function(object, function), 0);
481 
482  amxc_var_add_key(cstring_t, &args, "arg1", "0xFF");
483  amxc_var_add_key(uint32_t, &args, "arg2", 123);
484  amxc_var_add_key(cstring_t, &args, "arg3", "test test");
485  assert_int_equal(amxd_object_invoke_function(object, "my_func", &args, &ret), 0);
486  amxc_var_clean(&args);
487 
488  assert_int_equal(amxd_function_new(&function, "my_func", AMXC_VAR_ID_CSTRING, test_func), 0);
489  assert_int_equal(amxd_function_new_arg(function, "arg1", AMXC_VAR_ID_ANY, NULL), 0);
490  assert_int_not_equal(amxd_function_arg_set_attr(function, "arg1", amxd_aattr_strict, true), 0);
491  assert_int_not_equal(amxd_function_arg_set_attrs(function, "arg1", SET_BIT(amxd_aattr_strict), true), 0);
492  assert_int_not_equal(amxd_function_new_arg(function, "arg2", AMXC_VAR_ID_CUSTOM_BASE + 20, NULL), 0);
493  amxd_function_delete(&function);
494 
495  amxd_object_delete(&object);
496  amxc_var_clean(&def_val);
497 }
498 
499 void test_amxd_function_flags(UNUSED void** state) {
500  amxd_function_t* function = NULL;
501  amxd_object_t* object = NULL;
502 
503  amxc_var_t def_val;
504  amxc_var_t args;
505  amxc_var_t ret;
506  amxc_var_init(&def_val);
507  amxc_var_init(&args);
508  amxc_var_init(&ret);
509  amxc_var_set(uint32_t, &def_val, 10);
510 
511  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "test_object"), 0);
512 
513  assert_int_equal(amxd_function_new(&function, "my_func", AMXC_VAR_ID_CSTRING, test_func), 0);
514  assert_int_equal(amxd_function_new_arg(function, "arg1", AMXC_VAR_ID_UINT32, NULL), 0);
515  amxd_function_arg_set_attr(function, "arg1", amxd_aattr_mandatory, true);
516  amxd_function_arg_set_attr(function, "arg1", amxd_aattr_in, true);
517  assert_int_equal(amxd_function_new_arg(function, "arg2", AMXC_VAR_ID_UINT32, &def_val), 0);
518  amxd_function_arg_set_attr(function, "arg2", amxd_aattr_strict, true);
519  amxd_function_arg_set_attr(function, "arg2", amxd_aattr_in, true);
520  amxc_var_set(cstring_t, &def_val, "Hello");
521  assert_int_equal(amxd_function_new_arg(function, "arg3", AMXC_VAR_ID_CSTRING, &def_val), 0);
522  amxd_function_arg_set_attr(function, "arg3", amxd_aattr_in, true);
523  assert_int_equal(amxd_function_new_arg(function, "arg4", AMXC_VAR_ID_BOOL, NULL), 0);
524  amxd_function_arg_set_attr(function, "arg4", amxd_aattr_out, true);
525  amxd_function_arg_set_attr(function, "arg4", amxd_aattr_in, false);
526 
527  assert_int_equal(amxd_object_add_function(object, function), 0);
528 
529  amxd_function_set_flag(function, "async");
530  assert_true(amxd_function_has_flag(function, "async"));
531  assert_false(amxd_function_has_flag(function, "storage"));
532 
533  assert_int_equal(amxd_function_describe(function, &ret), 0);
534  assert_non_null(GETP_ARG(&ret, "flags.0"));
535 
536  amxd_function_unset_flag(function, "async");
537  assert_false(amxd_function_has_flag(function, "async"));
538 
539  amxc_var_clean(&args);
540  amxc_var_clean(&ret);
541  amxd_object_delete(&object);
542  amxc_var_clean(&def_val);
543 }
amxd_common.h
SET_BIT
#define SET_BIT(x)
Definition: amxd_common.h:65
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_get_base
amxd_object_t * amxd_object_get_base(const amxd_object_t *const object)
Definition: amxd_object.c:389
amxd_status_t
enum _amxd_status amxd_status_t
amxd_fattr_template
@ amxd_fattr_template
Definition: amxd_types.h:311
amxd_fattr_async
@ amxd_fattr_async
Definition: amxd_types.h:321
amxd_fattr_private
@ amxd_fattr_private
Definition: amxd_types.h:313
amxd_fattr_instance
@ amxd_fattr_instance
Definition: amxd_types.h:312
amxd_aattr_strict
@ amxd_aattr_strict
Definition: amxd_types.h:286
amxd_aattr_in
@ amxd_aattr_in
Definition: amxd_types.h:283
amxd_aattr_mandatory
@ amxd_aattr_mandatory
Definition: amxd_types.h:285
amxd_aattr_out
@ amxd_aattr_out
Definition: amxd_types.h:284
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_get_parent
amxd_object_t * amxd_object_get_parent(const amxd_object_t *const object)
Get the parent object.
Definition: amxd_object_hierarchy.c:227
amxd_object_get
amxd_object_t * amxd_object_get(const amxd_object_t *object, const char *name)
Get an instance or child of an object.
Definition: amxd_object_hierarchy.c:373
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_change_function
amxd_status_t amxd_object_change_function(amxd_object_t *const object, const char *name, amxd_object_fn_t impl)
Changes the implementation of an object's RPC method.
Definition: amxd_object_function.c:182
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_get_function
amxd_function_t * amxd_object_get_function(const amxd_object_t *const object, const char *name)
Get the definition of a RPC method from an object.
Definition: amxd_object_function.c:210
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_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_delete
void amxd_object_delete(amxd_object_t **object)
Invokes the destroy handler(s) of the object.
Definition: amxd_action_object_destroy.c:80
amxd_function_set_attr
amxd_status_t amxd_function_set_attr(amxd_function_t *func, const amxd_fattr_id_t attr, const bool enable)
Sets or unsets a method attribute.
Definition: amxd_function.c:283
amxd_function_describe
amxd_status_t amxd_function_describe(amxd_function_t *const func, amxc_var_t *const value)
Fetches the full RPC method definition in a variant.
Definition: amxd_function.c:413
amxd_function_get_name
const char * amxd_function_get_name(const amxd_function_t *const func)
Get the name of a method.
Definition: amxd_function.c:279
amxd_function_delete
void amxd_function_delete(amxd_function_t **func)
Data model RPC method destructor function.
Definition: amxd_function.c:169
amxd_function_arg_set_attr
amxd_status_t amxd_function_arg_set_attr(amxd_function_t *const func, const char *name, const amxd_aattr_id_t attr, const bool enable)
Sets or unsets a method argument attribute.
Definition: amxd_function_args.c:183
amxd_function_get_owner
amxd_object_t * amxd_function_get_owner(const amxd_function_t *const func)
Get the object pointer of the object containing the function definition.
Definition: amxd_function.c:226
amxd_function_unset_flag
void amxd_function_unset_flag(amxd_function_t *func, const char *flag)
Removes a flag from a function.
Definition: amxd_function.c:378
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_call_base
amxd_status_t amxd_function_call_base(const amxd_function_t *const func, amxd_object_t *const object, amxc_var_t *const args, amxc_var_t *const ret)
Call the base function of an overridden function.
Definition: amxd_function.c:260
amxd_function_set_attrs
amxd_status_t amxd_function_set_attrs(amxd_function_t *func, const uint32_t bitmask, bool enable)
Sets or unsets method attributes using a bitmap.
Definition: amxd_function.c:310
amxd_function_copy
amxd_status_t amxd_function_copy(amxd_function_t **dest, const amxd_function_t *const source)
Data model RPC method copy constructor function.
Definition: amxd_function.c:181
amxd_function_is_attr_set
bool amxd_function_is_attr_set(const amxd_function_t *const func, const amxd_fattr_id_t attr)
Checks if a method attribute is set.
Definition: amxd_function.c:353
amxd_function_has_flag
bool amxd_function_has_flag(const amxd_function_t *const func, const char *flag)
Checks if a flag is set.
Definition: amxd_function.c:389
amxd_function_set_flag
void amxd_function_set_flag(amxd_function_t *func, const char *flag)
Sets a flag on a function.
Definition: amxd_function.c:367
amxd_function_get_base
amxd_function_t * amxd_function_get_base(const amxd_function_t *const func)
Get the base function definition of an overridden function.
Definition: amxd_function.c:237
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_function_arg_set_attrs
amxd_status_t amxd_function_arg_set_attrs(amxd_function_t *func, const char *name, const uint32_t bitmask, bool enable)
Sets or unsets method argument attributes using a bitmap.
Definition: amxd_function_args.c:220
amxd_function_set_impl
amxd_status_t amxd_function_set_impl(amxd_function_t *const func, amxd_object_fn_t impl)
Set an implementation for a RPC method.
Definition: amxd_function.c:401
_amxd_dm
Definition: amxd_types.h:259
_amxd_func_attr::templ
uint32_t templ
Definition: amxd_types.h:326
_amxd_func_attr::priv
uint32_t priv
Definition: amxd_types.h:329
_amxd_func_attr::instance
uint32_t instance
Definition: amxd_types.h:327
_amxd_function
RPC method structure.
Definition: amxd_types.h:341
_amxd_function::args
amxc_llist_t args
Definition: amxd_types.h:346
_amxd_function::ret_type
uint32_t ret_type
Definition: amxd_types.h:345
_amxd_function::name
char * name
Definition: amxd_types.h:344
_amxd_function::impl
amxd_object_fn_t impl
Definition: amxd_types.h:347
_amxd_function::attr
amxd_func_attr_t attr
Definition: amxd_types.h:343
_amxd_object
Definition: amxd_types.h:229
_amxd_object::derived_objects
amxc_llist_t derived_objects
Definition: amxd_types.h:248
_amxd_object::derived_from
amxc_llist_it_t derived_from
Definition: amxd_types.h:249
_amxd_object::type
amxd_object_type_t type
Definition: amxd_types.h:236
dm
static amxd_dm_t dm
Definition: test_amxd_action_object_add.c:79
test_amxd_function_new_delete_invalid_args
void test_amxd_function_new_delete_invalid_args(UNUSED void **state)
Definition: test_amxd_function.c:137
test_amxd_function_are_args_valid
void test_amxd_function_are_args_valid(UNUSED void **state)
Definition: test_amxd_function.c:414
test_amxd_function_new_delete
void test_amxd_function_new_delete(UNUSED void **state)
Definition: test_amxd_function.c:115
test_amxd_function_get_base_invalid
void test_amxd_function_get_base_invalid(UNUSED void **state)
Definition: test_amxd_function.c:292
test_amxd_function_copy_with_args
void test_amxd_function_copy_with_args(UNUSED void **state)
Definition: test_amxd_function.c:178
test_amxd_function_get_owner_invalid
void test_amxd_function_get_owner_invalid(UNUSED void **state)
Definition: test_amxd_function.c:223
test_func3
static amxd_status_t test_func3(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
Definition: test_amxd_function.c:102
test_amxd_can_call_base
void test_amxd_can_call_base(UNUSED void **state)
Definition: test_amxd_function.c:309
test_amxd_function_get_base
void test_amxd_function_get_base(UNUSED void **state)
Definition: test_amxd_function.c:233
test_amxd_function_flags
void test_amxd_function_flags(UNUSED void **state)
Definition: test_amxd_function.c:499
test_amxd_function_copy
void test_amxd_function_copy(UNUSED void **state)
Definition: test_amxd_function.c:162
test_amxd_function_copy_invalid
void test_amxd_function_copy_invalid(UNUSED void **state)
Definition: test_amxd_function.c:206
test_amxd_function_attributes
void test_amxd_function_attributes(UNUSED void **state)
Definition: test_amxd_function.c:352
test_func2
static amxd_status_t test_func2(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
Definition: test_amxd_function.c:89
test_func
static amxd_status_t test_func(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
Definition: test_amxd_function.c:76
test_amxd_function_get_name_invalid
void test_amxd_function_get_name_invalid(UNUSED void **state)
Definition: test_amxd_function.c:348
test_amxd_function_copy_with_attributes
void test_amxd_function_copy_with_attributes(UNUSED void **state)
Definition: test_amxd_function.c:191
test_amxd_function.h