libamxd  6.4.1
Data Model Manager
test_amxd_object_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_dm.h>
69 #include <amxd/amxd_object.h>
70 #include <amxd/amxd_function.h>
71 
72 #include "test_amxd_object.h"
73 
74 #include <amxc/amxc_macros.h>
75 static amxd_dm_t dm;
76 static int count1 = 0;
77 static int count2 = 0;
78 static uint64_t call_id = 0;
79 
80 static amxd_status_t test_func(amxd_object_t* object,
81  amxd_function_t* func,
82  amxc_var_t* args,
83  amxc_var_t* ret) {
84  assert_ptr_not_equal(object, NULL);
85  assert_ptr_not_equal(func, NULL);
86  assert_ptr_not_equal(args, NULL);
87  assert_ptr_not_equal(ret, NULL);
88  assert_int_equal(amxc_var_type_of(args), AMXC_VAR_ID_HTABLE);
89 
90  count1++;
91 
92  return 0;
93 }
94 
95 static amxd_status_t test_func2(amxd_object_t* object,
96  amxd_function_t* func,
97  amxc_var_t* args,
98  amxc_var_t* ret) {
99  assert_ptr_not_equal(object, NULL);
100  assert_ptr_not_equal(func, NULL);
101  assert_ptr_not_equal(args, NULL);
102  assert_ptr_not_equal(ret, NULL);
103  assert_int_equal(amxc_var_type_of(args), AMXC_VAR_ID_HTABLE);
104 
105  count2++;
106 
107  return 0;
108 }
109 
110 static amxd_status_t test_deferred_func(amxd_object_t* object,
111  amxd_function_t* func,
112  amxc_var_t* args,
113  amxc_var_t* ret) {
114  assert_ptr_not_equal(object, NULL);
115  assert_ptr_not_equal(func, NULL);
116  assert_ptr_not_equal(args, NULL);
117  assert_ptr_not_equal(ret, NULL);
118  assert_int_equal(amxc_var_type_of(args), AMXC_VAR_ID_HTABLE);
119 
120  call_id = 0;
121  assert_int_not_equal(amxd_function_defer(NULL, &call_id, ret, NULL, NULL), 0);
122  assert_int_equal(call_id, 0);
123  assert_int_not_equal(amxd_function_defer(func, &call_id, NULL, NULL, NULL), 0);
124  assert_int_equal(call_id, 0);
125  assert_int_not_equal(amxd_function_defer(func, NULL, ret, NULL, NULL), 0);
126 
127  assert_int_equal(amxd_function_defer(func, &call_id, ret, NULL, NULL), 0);
128 
129  return amxd_status_deferred;
130 }
131 
132 static amxd_status_t test_deferred_func_invalid(amxd_object_t* object,
133  amxd_function_t* func,
134  amxc_var_t* args,
135  amxc_var_t* ret) {
136  assert_ptr_not_equal(object, NULL);
137  assert_ptr_not_equal(func, NULL);
138  assert_ptr_not_equal(args, NULL);
139  assert_ptr_not_equal(ret, NULL);
140  assert_int_equal(amxc_var_type_of(args), AMXC_VAR_ID_HTABLE);
141 
142  return amxd_status_deferred;
143 }
144 
145 static void test_deferred_cancel(UNUSED uint64_t id, void* const priv) {
146  assert_non_null(priv);
147  assert_ptr_equal(priv, &dm);
148 }
149 
150 static void test_deferred_done(UNUSED const amxc_var_t* const data, void* const priv) {
151  assert_non_null(priv);
152  assert_ptr_equal(priv, &dm);
153 }
154 
155 static amxd_status_t test_deferred_func_cancel(amxd_object_t* object,
156  amxd_function_t* func,
157  amxc_var_t* args,
158  amxc_var_t* ret) {
159  assert_ptr_not_equal(object, NULL);
160  assert_ptr_not_equal(func, NULL);
161  assert_ptr_not_equal(args, NULL);
162  assert_ptr_not_equal(ret, NULL);
163  assert_int_equal(amxc_var_type_of(args), AMXC_VAR_ID_HTABLE);
164 
165  amxd_function_defer(func, &call_id, ret, test_deferred_cancel, &dm);
166 
167  return amxd_status_deferred;
168 }
169 
170 void test_amxd_object_add_function(UNUSED void** state) {
171  amxd_object_t* object = NULL;
172  amxd_function_t* function = NULL;
173  assert_int_equal(amxd_dm_init(&dm), 0);
174 
175  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "parent"), 0);
176  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
177 
178  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
179  assert_int_equal(amxd_object_add_function(object, function), 0);
180 
181  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
182  assert_int_not_equal(amxd_object_add_function(object, function), 0);
183  amxd_function_delete(&function);
184 
185  assert_int_equal(amxd_function_new(&function, "test_func2", AMXC_VAR_ID_CSTRING, test_func), 0);
186  assert_int_equal(amxd_object_add_function(object, function), 0);
187 
188  assert_int_equal(amxd_object_set_attr(object, amxd_oattr_locked, true), 0);
189  assert_int_equal(amxd_function_new(&function, "test_func3", AMXC_VAR_ID_CSTRING, test_func), 0);
190  assert_int_not_equal(amxd_object_add_function(object, function), 0);
191  amxd_function_delete(&function);
192 
193  amxd_dm_clean(&dm);
194 }
195 
196 void test_amxd_object_add_function_invalid_arg(UNUSED void** state) {
197  amxd_object_t* object = NULL;
198  amxd_function_t* function = NULL;
199  assert_int_equal(amxd_dm_init(&dm), 0);
200 
201  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "parent"), 0);
202  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
203 
204  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
205  assert_int_not_equal(amxd_object_add_function(NULL, function), 0);
206  assert_int_not_equal(amxd_object_add_function(object, NULL), 0);
207  assert_int_equal(amxd_object_add_function(object, function), 0);
208  assert_int_not_equal(amxd_object_add_function(object, function), 0);
209 
210  amxd_dm_clean(&dm);
211 }
212 
213 void test_amxd_object_change_function(UNUSED void** state) {
214  amxd_object_t* object = NULL;
215  amxd_object_t* instance = NULL;
216  amxd_function_t* function = NULL;
217  amxd_function_t* function_inst = NULL;
218  assert_int_equal(amxd_dm_init(&dm), 0);
219 
220  assert_int_equal(amxd_object_new(&object, amxd_object_template, "parent"), 0);
221  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
222 
223  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
224  assert_int_equal(amxd_object_add_function(object, function), 0);
225 
226  assert_int_equal(amxd_object_change_function(object, "test_func", test_func2), 0);
227  assert_int_equal(amxd_object_change_function(object, "test_func", test_func), 0);
228 
229  assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
230  function_inst = amxd_object_get_function(instance, "test_func");
231  assert_ptr_not_equal(function_inst, NULL);
232  assert_ptr_equal(function_inst->impl, test_func);
233  assert_ptr_equal(function_inst, function);
234 
235  assert_int_equal(amxd_object_change_function(instance, "test_func", test_func2), 0);
236  function_inst = amxd_object_get_function(instance, "test_func");
237  assert_ptr_not_equal(function_inst, NULL);
238  assert_ptr_equal(function_inst->impl, test_func2);
239  assert_ptr_not_equal(function_inst, function);
240 
241  amxd_dm_clean(&dm);
242 }
243 
244 void test_amxd_object_change_function_invalid_args(UNUSED void** state) {
245  amxd_object_t* object = NULL;
246  amxd_function_t* function = NULL;
247  assert_int_equal(amxd_dm_init(&dm), 0);
248 
249  assert_int_equal(amxd_object_new(&object, amxd_object_template, "parent"), 0);
250  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
251 
252  assert_int_equal(amxd_function_new(&function, "test_func", AMXC_VAR_ID_CSTRING, test_func), 0);
253  assert_int_equal(amxd_object_add_function(object, function), 0);
254 
255  assert_int_not_equal(amxd_object_change_function(NULL, "test_func", test_func2), 0);
256  assert_int_not_equal(amxd_object_change_function(object, "test_func2", test_func2), 0);
257  assert_int_not_equal(amxd_object_change_function(object, NULL, test_func2), 0);
258  assert_int_not_equal(amxd_object_change_function(object, "", test_func2), 0);
259  assert_int_equal(amxd_object_change_function(object, "test_func", NULL), 0);
260 
261  amxd_dm_clean(&dm);
262 }
263 
264 void test_amxd_object_get_function(UNUSED void** state) {
265  amxd_object_t* template = NULL;
266  amxd_object_t* object = NULL;
267  amxd_object_t* instance = NULL;
268  amxd_object_t* instance_object = NULL;
269 
270  amxd_function_t* function = NULL;
271  assert_int_equal(amxd_dm_init(&dm), 0);
272 
273  assert_int_equal(amxd_object_new(&template, amxd_object_template, "parent"), 0);
274  assert_int_equal(amxd_dm_add_root_object(&dm, template), 0);
275  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
276  assert_int_equal(amxd_object_add_object(template, object), 0);
277  assert_int_equal(amxd_function_new(&function, "templ_func", AMXC_VAR_ID_CSTRING, test_func), 0);
278  assert_int_equal(amxd_object_add_function(template, function), 0);
279  assert_int_equal(amxd_function_new(&function, "child_func", AMXC_VAR_ID_CSTRING, test_func2), 0);
280  assert_int_equal(amxd_object_add_function(object, function), 0);
281 
282  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
283  function = amxd_object_get_function(instance, "templ_func");
284  assert_ptr_not_equal(function, NULL);
285  assert_ptr_equal(amxd_function_get_owner(function), template);
286 
287  function = amxd_object_get_function(object, "child_func");
288  assert_ptr_not_equal(function, NULL);
289  assert_ptr_equal(amxd_function_get_owner(function), object);
290 
291  instance_object = amxd_object_get(instance, "child");
292  assert_ptr_not_equal(instance_object, NULL);
293  assert_ptr_equal(amxd_object_get_parent(instance_object), instance);
294  assert_ptr_equal(instance_object->derived_from.llist, &object->derived_objects);
295  assert_ptr_equal(instance_object->type, amxd_object_singleton);
296  function = amxd_object_get_function(instance_object, "child_func");
297  assert_ptr_not_equal(function, NULL);
298  assert_ptr_equal(amxd_function_get_owner(function), object);
299 
300  assert_int_equal(amxd_object_change_function(instance_object, "child_func", test_func), 0);
301  function = amxd_object_get_function(instance_object, "child_func");
302  assert_ptr_not_equal(function, NULL);
303  assert_ptr_equal(amxd_function_get_owner(function), instance_object);
304 
305  amxd_dm_clean(&dm);
306 }
307 
308 void test_amxd_object_get_function_invalid_args(UNUSED void** state) {
309  amxd_object_t* template = NULL;
310  amxd_object_t* object = NULL;
311  amxd_object_t* instance = NULL;
312 
313  amxd_function_t* function = NULL;
314  assert_int_equal(amxd_dm_init(&dm), 0);
315 
316  assert_int_equal(amxd_object_new(&template, amxd_object_template, "parent"), 0);
317  assert_int_equal(amxd_dm_add_root_object(&dm, template), 0);
318  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
319  assert_int_equal(amxd_object_add_object(template, object), 0);
320  assert_int_equal(amxd_function_new(&function, "templ_func", AMXC_VAR_ID_CSTRING, test_func), 0);
321  assert_int_equal(amxd_object_add_function(template, function), 0);
322  assert_int_equal(amxd_function_new(&function, "child_func", AMXC_VAR_ID_CSTRING, test_func2), 0);
323  assert_int_equal(amxd_object_add_function(object, function), 0);
324 
325  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
326  function = amxd_object_get_function(instance, "templ_func");
327  assert_ptr_not_equal(function, NULL);
328  assert_ptr_equal(amxd_function_get_owner(function), template);
329 
330  function = amxd_object_get_function(NULL, "templ_func");
331  assert_ptr_equal(function, NULL);
332  function = amxd_object_get_function(instance, "");
333  assert_ptr_equal(function, NULL);
334  function = amxd_object_get_function(instance, NULL);
335  assert_ptr_equal(function, NULL);
336  function = amxd_object_get_function(instance, "afunc");
337  assert_ptr_equal(function, NULL);
338  function = amxd_object_get_function(amxd_dm_get_root(&dm), "afunc");
339  assert_ptr_equal(function, NULL);
340 
341  amxd_dm_clean(&dm);
342 }
343 
344 void test_amxd_object_get_functions(UNUSED void** state) {
345  amxd_object_t* template = NULL;
346  amxd_object_t* object = NULL;
347  amxd_object_t* instance = NULL;
348  amxd_object_t* instance_object = NULL;
349  amxc_var_t functions;
350  const amxc_llist_t* func_list = NULL;
351 
352  amxd_function_t* function = NULL;
353  amxc_var_init(&functions);
354 
355  assert_int_equal(amxd_dm_init(&dm), 0);
356 
357  assert_int_equal(amxd_object_new(&template, amxd_object_template, "parent"), 0);
358  assert_int_equal(amxd_dm_add_root_object(&dm, template), 0);
359  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
360  assert_int_equal(amxd_object_add_object(template, object), 0);
361 
362  assert_int_equal(amxd_function_new(&function, "templ_func", AMXC_VAR_ID_CSTRING, test_func), 0);
363  assert_int_equal(amxd_object_add_function(template, function), 0);
364  assert_int_equal(amxd_function_new(&function, "templ_func2", AMXC_VAR_ID_CSTRING, test_func), 0);
365  assert_int_equal(amxd_function_set_attr(function, amxd_fattr_template, true), 0);
366  assert_int_equal(amxd_object_add_function(template, function), 0);
367  assert_int_equal(amxd_function_new(&function, "templ_func3", AMXC_VAR_ID_CSTRING, test_func), 0);
368  assert_int_equal(amxd_function_set_attr(function, amxd_fattr_private, true), 0);
369  assert_int_equal(amxd_object_add_function(template, function), 0);
370 
371  assert_int_equal(amxd_function_new(&function, "child_func", AMXC_VAR_ID_CSTRING, test_func), 0);
372  assert_int_equal(amxd_object_add_function(object, function), 0);
373  assert_int_equal(amxd_function_new(&function, "child_func2", AMXC_VAR_ID_CSTRING, test_func2), 0);
374  assert_int_equal(amxd_object_add_function(object, function), 0);
375  assert_int_equal(amxd_function_new(&function, "child_func3", AMXC_VAR_ID_CSTRING, test_func2), 0);
376  assert_int_equal(amxd_function_set_attr(function, amxd_fattr_private, true), 0);
377  assert_int_equal(amxd_object_add_function(object, function), 0);
378 
379  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
380  function = amxd_object_get_function(instance, "templ_func");
381  assert_ptr_not_equal(function, NULL);
382  assert_ptr_equal(amxd_function_get_owner(function), template);
383 
384  instance_object = amxd_object_get(instance, "child");
385  assert_int_equal(amxd_object_change_function(instance_object, "child_func", test_func), 0);
386  assert_int_equal(amxd_object_list_functions(instance_object, &functions, amxd_dm_access_private), 0);
387  assert_int_equal(amxc_var_type_of(&functions), AMXC_VAR_ID_LIST);
388  func_list = amxc_var_constcast(amxc_llist_t, &functions);
389  assert_int_equal(amxc_llist_size(func_list), 3 + INSTANCE_DEFAULT_FUNCS);
390  assert_int_equal(amxd_object_list_functions(instance_object, &functions, amxd_dm_access_protected), 0);
391  assert_int_equal(amxc_var_type_of(&functions), AMXC_VAR_ID_LIST);
392  func_list = amxc_var_constcast(amxc_llist_t, &functions);
393  assert_int_equal(amxc_llist_size(func_list), 2 + INSTANCE_DEFAULT_FUNCS);
394  amxc_var_clean(&functions);
395 
396  assert_int_equal(amxd_object_list_functions(instance, &functions, amxd_dm_access_private), 0);
397  amxc_var_dump(&functions, STDOUT_FILENO);
398  func_list = amxc_var_constcast(amxc_llist_t, &functions);
399  assert_int_equal(amxc_llist_size(func_list), 2 + INSTANCE_DEFAULT_FUNCS);
400  assert_int_equal(amxd_object_list_functions(instance, &functions, amxd_dm_access_protected), 0);
401  func_list = amxc_var_constcast(amxc_llist_t, &functions);
402  assert_int_equal(amxc_llist_size(func_list), 1 + INSTANCE_DEFAULT_FUNCS);
403  amxc_var_clean(&functions);
404 
405  assert_int_not_equal(amxd_object_list_functions(instance, NULL, 0), 0);
406  assert_int_not_equal(amxd_object_list_functions(NULL, &functions, 0), 0);
407 
408  amxd_dm_clean(&dm);
409 }
410 
411 void test_amxd_object_invoke_function(UNUSED void** state) {
412  amxd_object_t* template = NULL;
413  amxd_object_t* object = NULL;
414  amxd_object_t* instance = NULL;
415  amxd_function_t* function = NULL;
416 
417  amxc_var_t args;
418  amxc_var_t ret;
419 
420  amxc_var_init(&args);
421  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
422  amxc_var_init(&ret);
423 
424  assert_int_equal(amxd_dm_init(&dm), 0);
425 
426  assert_int_equal(amxd_object_new(&template, amxd_object_template, "parent"), 0);
427  assert_int_equal(amxd_dm_add_root_object(&dm, template), 0);
428  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
429  assert_int_equal(amxd_object_add_object(template, object), 0);
430 
431  assert_int_equal(amxd_function_new(&function, "templ_func", AMXC_VAR_ID_CSTRING, test_func), 0);
432  amxd_function_set_attr(function, amxd_fattr_template, true);
433  assert_int_equal(amxd_object_add_function(template, function), 0);
434  assert_int_equal(amxd_function_new(&function, "inst_func", AMXC_VAR_ID_CSTRING, test_func), 0);
435  assert_int_equal(amxd_object_add_function(template, function), 0);
436  assert_int_equal(amxd_function_new(&function, "inst_func2", AMXC_VAR_ID_CSTRING, NULL), 0);
437  assert_int_equal(amxd_object_add_function(template, function), 0);
438  assert_int_equal(amxd_function_new(&function, "child_func", AMXC_VAR_ID_CSTRING, test_func), 0);
439  assert_int_equal(amxd_object_add_function(object, function), 0);
440  assert_int_equal(amxd_function_new(&function, "child_func2", AMXC_VAR_ID_CSTRING, test_func2), 0);
441  assert_int_equal(amxd_object_add_function(object, function), 0);
442  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
443 
444  assert_int_equal(amxd_object_invoke_function(template, "templ_func", &args, &ret), 0);
445  assert_int_equal(count1, 1);
446  assert_int_equal(amxd_object_invoke_function(instance, "inst_func", &args, &ret), 0);
447  assert_int_equal(count1, 2);
448  assert_int_not_equal(amxd_object_invoke_function(instance, "templ_func", &args, &ret), 0);
449  assert_int_equal(count1, 2);
450  assert_int_not_equal(amxd_object_invoke_function(template, "inst_func", &args, &ret), 0);
451  assert_int_equal(count1, 2);
452  assert_int_not_equal(amxd_object_invoke_function(instance, "inst_func2", &args, &ret), 0);
453  assert_int_equal(count1, 2);
454 
455  assert_int_equal(amxd_object_invoke_function(object, "child_func", &args, &ret), 0);
456  assert_int_equal(count1, 3);
457  assert_int_not_equal(amxd_object_invoke_function(template, "child_func", &args, &ret), 0);
458  assert_int_equal(count1, 3);
459  assert_int_equal(amxd_object_invoke_function(object, "child_func2", &args, &ret), 0);
460  assert_int_equal(count1, 3);
461  assert_int_equal(count2, 1);
462 
463  assert_int_not_equal(amxd_object_invoke_function(NULL, "child_func", &args, &ret), 0);
464  assert_int_not_equal(amxd_object_invoke_function(object, "", &args, &ret), 0);
465  assert_int_not_equal(amxd_object_invoke_function(object, NULL, &args, &ret), 0);
466  assert_int_not_equal(amxd_object_invoke_function(object, "child_func", NULL, &ret), 0);
467  assert_int_not_equal(amxd_object_invoke_function(object, "child_func", &args, NULL), 0);
468  amxc_var_set_type(&args, AMXC_VAR_ID_LIST);
469  assert_int_not_equal(amxd_object_invoke_function(object, "child_func", &args, &ret), 0);
470 
471  amxc_var_clean(&args);
472  amxc_var_clean(&ret);
473  amxd_dm_clean(&dm);
474 }
475 
476 void test_amxd_object_deferred_function_no_callbacks(UNUSED void** state) {
477  amxd_object_t* object = NULL;
478  amxd_function_t* function = NULL;
479  uint64_t local_call_id = 0;
480 
481  amxc_var_t args;
482  amxc_var_t ret;
483 
484  amxc_var_init(&args);
485  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
486  amxc_var_init(&ret);
487 
488  assert_int_equal(amxd_dm_init(&dm), 0);
489 
490  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
491  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
492  assert_int_equal(amxd_function_new(&function, "deferred_func", AMXC_VAR_ID_CSTRING, test_deferred_func), 0);
493  assert_int_equal(amxd_object_add_function(object, function), 0);
494  assert_int_equal(amxd_function_new(&function, "deferred_func_invalid", AMXC_VAR_ID_CSTRING, test_deferred_func_invalid), 0);
495  assert_int_equal(amxd_object_add_function(object, function), 0);
496 
497  while(amxp_signal_read() == 0) {
498  }
499 
500  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
501  local_call_id = amxc_var_constcast(uint64_t, &ret);
502  assert_int_equal(local_call_id, call_id);
503 
504  while(amxp_signal_read() == 0) {
505  }
506 
507  amxd_function_deferred_remove(local_call_id);
508  while(amxp_signal_read() == 0) {
509  }
510  amxd_function_deferred_remove(local_call_id);
511  while(amxp_signal_read() == 0) {
512  }
513 
514  amxc_var_clean(&ret);
515  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
516  local_call_id = amxc_var_constcast(uint64_t, &ret);
517  assert_int_equal(local_call_id, call_id);
518  amxd_function_deferred_remove(local_call_id);
519  while(amxp_signal_read() == 0) {
520  }
521 
522  amxc_var_clean(&ret);
523  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
524  local_call_id = amxc_var_constcast(uint64_t, &ret);
525  assert_int_equal(local_call_id, call_id);
526  amxd_function_deferred_done(local_call_id, amxd_status_ok, NULL, NULL);
527  while(amxp_signal_read() == 0) {
528  }
529 
530  amxc_var_clean(&ret);
531  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
532  local_call_id = amxc_var_constcast(uint64_t, &ret);
533  amxc_var_set(bool, &ret, true);
534  assert_int_equal(amxd_function_deferred_done(local_call_id, amxd_status_ok, &args, &ret), 0);
535  assert_int_not_equal(amxd_function_deferred_done(local_call_id, amxd_status_ok, &args, &ret), 0);
536  while(amxp_signal_read() == 0) {
537  }
538 
539  amxc_var_clean(&ret);
540  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
541  local_call_id = amxc_var_constcast(uint64_t, &ret);
542  assert_int_equal(local_call_id, call_id);
543  amxc_var_clean(&ret);
544  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
545  local_call_id = amxc_var_constcast(uint64_t, &ret);
546  assert_int_equal(local_call_id, call_id);
547 
548  amxc_var_clean(&ret);
549  assert_int_not_equal(amxd_object_invoke_function(object, "deferred_func_invalid", &args, &ret), amxd_status_deferred);
550 
551  amxc_var_clean(&args);
552  amxc_var_clean(&ret);
553  amxd_dm_clean(&dm);
554 }
555 
556 void test_amxd_object_deferred_function_cancel_callback(UNUSED void** state) {
557  amxd_object_t* object = NULL;
558  amxd_function_t* function = NULL;
559  uint64_t local_call_id = 0;
560 
561  amxc_var_t args;
562  amxc_var_t ret;
563 
564  amxc_var_init(&args);
565  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
566  amxc_var_init(&ret);
567 
568  assert_int_equal(amxd_dm_init(&dm), 0);
569 
570  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
571  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
572  assert_int_equal(amxd_function_new(&function, "deferred_func", AMXC_VAR_ID_CSTRING, test_deferred_func_cancel), 0);
573  assert_int_equal(amxd_object_add_function(object, function), 0);
574 
575  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
576  local_call_id = amxc_var_constcast(uint64_t, &ret);
577  assert_int_equal(local_call_id, call_id);
578  assert_ptr_equal(amxd_function_deferred_get_priv(local_call_id), &dm);
579  assert_null(amxd_function_deferred_get_priv(local_call_id + 1));
580  while(amxp_signal_read() == 0) {
581  }
582 
583  amxd_function_deferred_remove(local_call_id);
584  assert_null(amxd_function_deferred_get_priv(local_call_id));
585  while(amxp_signal_read() == 0) {
586  }
587 
588  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
589  local_call_id = amxc_var_constcast(uint64_t, &ret);
590  assert_int_equal(local_call_id, call_id);
591  amxd_function_deferred_remove(local_call_id);
592  while(amxp_signal_read() == 0) {
593  }
594 
595  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
596  local_call_id = amxc_var_constcast(uint64_t, &ret);
597  amxd_function_deferred_done(local_call_id, amxd_status_ok, NULL, NULL);
598  while(amxp_signal_read() == 0) {
599  }
600 
601  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
602  local_call_id = amxc_var_constcast(uint64_t, &ret);
603  amxc_var_set(bool, &ret, true);
604  assert_int_equal(amxd_function_deferred_done(local_call_id, amxd_status_ok, &args, &ret), 0);
605  assert_int_not_equal(amxd_function_deferred_done(local_call_id, amxd_status_ok, &args, &ret), 0);
606  while(amxp_signal_read() == 0) {
607  }
608 
609  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
610  local_call_id = amxc_var_constcast(uint64_t, &ret);
611  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
612  local_call_id = amxc_var_constcast(uint64_t, &ret);
613  assert_int_equal(local_call_id, call_id);
614 
615  amxc_var_clean(&args);
616  amxc_var_clean(&ret);
617  amxd_dm_clean(&dm);
618 }
619 
620 void test_amxd_object_deferred_function_done_callback(UNUSED void** state) {
621  amxd_object_t* object = NULL;
622  amxd_function_t* function = NULL;
623  uint64_t local_call_id = 0;
624 
625  amxc_var_t args;
626  amxc_var_t ret;
627 
628  amxc_var_init(&args);
629  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
630  amxc_var_init(&ret);
631 
632  assert_int_equal(amxd_dm_init(&dm), 0);
633 
634  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
635  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
636  assert_int_equal(amxd_function_new(&function, "deferred_func", AMXC_VAR_ID_CSTRING, test_deferred_func), 0);
637  assert_int_equal(amxd_object_add_function(object, function), 0);
638 
639  while(amxp_signal_read() == 0) {
640  }
641 
642  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
643  local_call_id = amxc_var_constcast(uint64_t, &ret);
644  assert_int_equal(local_call_id, call_id);
645  assert_int_equal(amxd_function_set_deferred_cb(local_call_id, test_deferred_done, &dm), 0);
646 
647  while(amxp_signal_read() == 0) {
648  }
649 
650  amxd_function_deferred_remove(local_call_id);
651  while(amxp_signal_read() == 0) {
652  }
653  amxd_function_deferred_remove(local_call_id);
654  while(amxp_signal_read() == 0) {
655  }
656 
657  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
658  local_call_id = amxc_var_constcast(uint64_t, &ret);
659  assert_int_equal(local_call_id, call_id);
660  assert_int_equal(amxd_function_set_deferred_cb(local_call_id, test_deferred_done, &dm), 0);
661  while(amxp_signal_read() == 0) {
662  }
663 
664  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
665  local_call_id = amxc_var_constcast(uint64_t, &ret);
666  assert_int_equal(local_call_id, call_id);
667  assert_int_equal(amxd_function_set_deferred_cb(local_call_id, test_deferred_done, &dm), 0);
668  amxd_function_deferred_done(local_call_id, amxd_status_ok, NULL, NULL);
669  while(amxp_signal_read() == 0) {
670  }
671 
672  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
673  local_call_id = amxc_var_constcast(uint64_t, &ret);
674  amxc_var_set(bool, &ret, true);
675  assert_int_equal(amxd_function_set_deferred_cb(local_call_id, test_deferred_done, &dm), 0);
676  assert_int_equal(amxd_function_deferred_done(local_call_id, amxd_status_ok, &args, &ret), 0);
677  assert_int_not_equal(amxd_function_deferred_done(local_call_id, amxd_status_ok, &args, &ret), 0);
678  assert_int_not_equal(amxd_function_set_deferred_cb(local_call_id, test_deferred_done, &dm), 0);
679  while(amxp_signal_read() == 0) {
680  }
681 
682  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
683  local_call_id = amxc_var_constcast(uint64_t, &ret);
684  assert_int_equal(local_call_id, call_id);
685  assert_int_equal(amxd_function_set_deferred_cb(local_call_id, test_deferred_done, &dm), 0);
686  assert_int_equal(amxd_object_invoke_function(object, "deferred_func", &args, &ret), amxd_status_deferred);
687  local_call_id = amxc_var_constcast(uint64_t, &ret);
688  assert_int_equal(local_call_id, call_id);
689  assert_int_equal(amxd_function_set_deferred_cb(local_call_id, test_deferred_done, &dm), 0);
690 
691  amxc_var_clean(&args);
692  amxc_var_clean(&ret);
693  amxd_dm_clean(&dm);
694 }
695 
696 
697 void test_amxd_object_count_functions(UNUSED void** state) {
698  amxd_object_t* template = NULL;
699  amxd_object_t* object = NULL;
700  amxd_object_t* instance = NULL;
701  amxd_function_t* function = NULL;
702 
703  amxc_var_t args;
704  amxc_var_t ret;
705 
706  amxc_var_init(&args);
707  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
708  amxc_var_init(&ret);
709 
710  assert_int_equal(amxd_dm_init(&dm), 0);
711 
712  assert_int_equal(amxd_object_new(&template, amxd_object_template, "parent"), 0);
713  assert_int_equal(amxd_dm_add_root_object(&dm, template), 0);
714  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
715  assert_int_equal(amxd_object_add_object(template, object), 0);
716 
717  assert_int_equal(amxd_function_new(&function, "templ_func", AMXC_VAR_ID_CSTRING, test_func), 0);
718  amxd_function_set_attr(function, amxd_fattr_template, true);
719  assert_int_equal(amxd_object_add_function(template, function), 0);
720  assert_int_equal(amxd_function_new(&function, "inst_func", AMXC_VAR_ID_CSTRING, test_func), 0);
721  assert_int_equal(amxd_object_add_function(template, function), 0);
722  assert_int_equal(amxd_function_new(&function, "inst_func2", AMXC_VAR_ID_CSTRING, NULL), 0);
723  assert_int_equal(amxd_object_add_function(template, function), 0);
724 
725  assert_int_equal(amxd_function_new(&function, "child_func", AMXC_VAR_ID_CSTRING, test_func), 0);
726  assert_int_equal(amxd_object_add_function(object, function), 0);
727  assert_int_equal(amxd_function_new(&function, "child_func2", AMXC_VAR_ID_CSTRING, test_func2), 0);
728  assert_int_equal(amxd_object_add_function(object, function), 0);
729 
730  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
731 
732  assert_int_equal(amxd_object_get_function_count(template, amxd_dm_access_private), 3 + TEMPLATE_DEFAULT_FUNCS);
733  assert_int_equal(amxd_object_get_function_count(template, amxd_dm_access_protected), 3 + TEMPLATE_DEFAULT_FUNCS);
734  assert_int_equal(amxd_object_get_function_count(instance, amxd_dm_access_protected), 2 + INSTANCE_DEFAULT_FUNCS);
735  assert_int_equal(amxd_object_get_function_count(object, amxd_dm_access_protected), 2 + SINGELTON_DEFAULT_FUNCS);
736 
737  assert_int_equal(amxd_object_get_function_count(NULL, amxd_dm_access_protected), 0);
738 
739  amxc_var_clean(&args);
740  amxc_var_clean(&ret);
741  amxd_dm_clean(&dm);
742 }
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_status_t
enum _amxd_status amxd_status_t
amxd_status_ok
@ amxd_status_ok
Definition: amxd_types.h:78
amxd_status_deferred
@ amxd_status_deferred
Definition: amxd_types.h:92
amxd_fattr_template
@ amxd_fattr_template
Definition: amxd_types.h:311
amxd_fattr_private
@ amxd_fattr_private
Definition: amxd_types.h:313
amxd_oattr_locked
@ amxd_oattr_locked
Definition: amxd_types.h:206
amxd_dm_access_private
@ amxd_dm_access_private
Definition: amxd_types.h:141
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_get_root
amxd_object_t * amxd_dm_get_root(amxd_dm_t *const dm)
Fetches the root object of the data model.
Definition: amxd_dm.c:456
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_get_function_count
uint32_t amxd_object_get_function_count(amxd_object_t *const object, amxd_dm_access_t access)
Retruns the number of RPC methods available in an object.
Definition: amxd_object_function.c:276
amxd_object_list_functions
amxd_status_t amxd_object_list_functions(amxd_object_t *const object, amxc_var_t *const list, amxd_dm_access_t access)
Builds a linked list variant containing all function names available in the object.
Definition: amxd_action_object_list.c:363
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_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_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_delete
void amxd_function_delete(amxd_function_t **func)
Data model RPC method destructor function.
Definition: amxd_function.c:169
amxd_function_deferred_remove
void amxd_function_deferred_remove(uint64_t call_id)
Removes a deferred RPC context.
Definition: amxd_function_deferred.c:154
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_defer
amxd_status_t amxd_function_defer(const amxd_function_t *const func, uint64_t *call_id, amxc_var_t *const ret, amxd_deferred_cancel_t cancel_fn, void *priv)
Creates a deferred RPC context.
Definition: amxd_function_deferred.c:126
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_deferred_done
amxd_status_t amxd_function_deferred_done(uint64_t call_id, amxd_status_t status, amxc_var_t *out_args, amxc_var_t *ret)
Finishes a deferred method and removes the deferred function context.
Definition: amxd_function_deferred.c:242
amxd_function_set_deferred_cb
amxd_status_t amxd_function_set_deferred_cb(uint64_t call_id, amxp_deferred_fn_t cb, void *priv)
Sets a callback function to get the result of the deferred call.
Definition: amxd_function_deferred.c:184
amxd_function_deferred_get_priv
void * amxd_function_deferred_get_priv(uint64_t call_id)
Gets the callee private data of an deferred function.
Definition: amxd_function_deferred.c:173
_amxd_dm
Definition: amxd_types.h:259
_amxd_function
RPC method structure.
Definition: amxd_types.h:341
_amxd_function::impl
amxd_object_fn_t impl
Definition: amxd_types.h:347
_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
TEMPLATE_DEFAULT_FUNCS
#define TEMPLATE_DEFAULT_FUNCS
Definition: test_amxd_default_functions.h:58
INSTANCE_DEFAULT_FUNCS
#define INSTANCE_DEFAULT_FUNCS
Definition: test_amxd_default_functions.h:59
test_amxd_object.h
SINGELTON_DEFAULT_FUNCS
#define SINGELTON_DEFAULT_FUNCS
Definition: test_amxd_object.h:58
test_amxd_object_deferred_function_no_callbacks
void test_amxd_object_deferred_function_no_callbacks(UNUSED void **state)
Definition: test_amxd_object_function.c:476
dm
static amxd_dm_t dm
Definition: test_amxd_object_function.c:75
count2
static int count2
Definition: test_amxd_object_function.c:77
test_deferred_cancel
static void test_deferred_cancel(UNUSED uint64_t id, void *const priv)
Definition: test_amxd_object_function.c:145
test_amxd_object_add_function
void test_amxd_object_add_function(UNUSED void **state)
Definition: test_amxd_object_function.c:170
call_id
static uint64_t call_id
Definition: test_amxd_object_function.c:78
test_amxd_object_get_function
void test_amxd_object_get_function(UNUSED void **state)
Definition: test_amxd_object_function.c:264
test_amxd_object_count_functions
void test_amxd_object_count_functions(UNUSED void **state)
Definition: test_amxd_object_function.c:697
test_deferred_func_invalid
static amxd_status_t test_deferred_func_invalid(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
Definition: test_amxd_object_function.c:132
test_amxd_object_add_function_invalid_arg
void test_amxd_object_add_function_invalid_arg(UNUSED void **state)
Definition: test_amxd_object_function.c:196
count1
static int count1
Definition: test_amxd_object_function.c:76
test_amxd_object_deferred_function_done_callback
void test_amxd_object_deferred_function_done_callback(UNUSED void **state)
Definition: test_amxd_object_function.c:620
test_amxd_object_get_functions
void test_amxd_object_get_functions(UNUSED void **state)
Definition: test_amxd_object_function.c:344
test_deferred_done
static void test_deferred_done(UNUSED const amxc_var_t *const data, void *const priv)
Definition: test_amxd_object_function.c:150
test_deferred_func
static amxd_status_t test_deferred_func(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
Definition: test_amxd_object_function.c:110
test_amxd_object_invoke_function
void test_amxd_object_invoke_function(UNUSED void **state)
Definition: test_amxd_object_function.c:411
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_object_function.c:95
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_object_function.c:80
test_deferred_func_cancel
static amxd_status_t test_deferred_func_cancel(amxd_object_t *object, amxd_function_t *func, amxc_var_t *args, amxc_var_t *ret)
Definition: test_amxd_object_function.c:155
test_amxd_object_change_function_invalid_args
void test_amxd_object_change_function_invalid_args(UNUSED void **state)
Definition: test_amxd_object_function.c:244
test_amxd_object_get_function_invalid_args
void test_amxd_object_get_function_invalid_args(UNUSED void **state)
Definition: test_amxd_object_function.c:308
test_amxd_object_change_function
void test_amxd_object_change_function(UNUSED void **state)
Definition: test_amxd_object_function.c:213
test_amxd_object_deferred_function_cancel_callback
void test_amxd_object_deferred_function_cancel_callback(UNUSED void **state)
Definition: test_amxd_object_function.c:556