libamxd  6.4.1
Data Model Manager
test_amxd_object_parameter.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_action.h>
70 #include <amxd/amxd_object.h>
71 #include <amxd/amxd_parameter.h>
72 
73 #include "test_amxd_object.h"
74 
75 #include <amxc/amxc_macros.h>
76 static amxd_dm_t dm;
77 
78 static amxd_object_t* test_build_dm(void) {
79  amxd_object_t* object = NULL;
80  amxd_object_t* template = NULL;
81  amxd_param_t* param = NULL;
82 
83  assert_int_equal(amxd_dm_init(&dm), 0);
84 
85  assert_int_equal(amxd_object_new(&template, amxd_object_template, "parent"), 0);
86  assert_int_equal(amxd_dm_add_root_object(&dm, template), 0);
87  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
88  assert_int_equal(amxd_object_add_object(template, object), 0);
89 
90  assert_int_equal(amxd_param_new(&param, "templ_param", AMXC_VAR_ID_CSTRING), 0);
91  amxd_param_set_attr(param, amxd_pattr_template, true);
92  assert_int_equal(amxd_object_add_param(template, param), 0);
93  assert_int_equal(amxd_param_new(&param, "inst_param", AMXC_VAR_ID_BOOL), 0);
94  assert_int_equal(amxd_object_add_param(template, param), 0);
95  assert_int_equal(amxd_param_new(&param, "param", AMXC_VAR_ID_UINT32), 0);
96  amxd_param_set_attr(param, amxd_pattr_template, true);
97  amxd_param_set_attr(param, amxd_pattr_instance, true);
98  assert_int_equal(amxd_object_add_param(template, param), 0);
99 
100  assert_int_equal(amxd_param_new(&param, "child_param", AMXC_VAR_ID_CSTRING), 0);
101  amxd_param_set_attr(param, amxd_pattr_private, true);
102  assert_int_equal(amxd_object_add_param(object, param), 0);
103  assert_int_equal(amxd_param_new(&param, "child_param2", AMXC_VAR_ID_BOOL), 0);
104  assert_int_equal(amxd_object_add_param(object, param), 0);
105  assert_int_equal(amxd_param_new(&param, "child_param3", AMXC_VAR_ID_UINT64), 0);
106  assert_int_equal(amxd_object_add_param(object, param), 0);
107 
108  return template;
109 }
110 
111 void test_amxd_object_add_parameter(UNUSED void** state) {
112  amxd_object_t* object = NULL;
113  amxd_object_t* templ = NULL;
114  amxd_param_t* param = NULL;
115  assert_int_equal(amxd_dm_init(&dm), 0);
116 
117  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "parent"), 0);
118  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
119 
120  assert_int_equal(amxd_object_new(&templ, amxd_object_template, "templ"), 0);
121  assert_int_equal(amxd_dm_add_root_object(&dm, templ), 0);
122 
123  assert_int_equal(amxd_param_new(&param, "test_param", AMXC_VAR_ID_CSTRING), 0);
124  assert_int_equal(amxd_object_add_param(object, param), 0);
125 
126  assert_int_equal(amxd_param_new(&param, "test_param", AMXC_VAR_ID_CSTRING), 0);
127  assert_int_not_equal(amxd_object_add_param(object, param), 0);
128  amxd_param_delete(&param);
129 
130  assert_int_equal(amxd_param_new(&param, "test_param2", AMXC_VAR_ID_CSTRING), 0);
131  assert_int_equal(amxd_object_add_param(object, param), 0);
132 
133  assert_int_equal(amxd_object_set_attr(object, amxd_oattr_locked, true), 0);
134  assert_int_equal(amxd_param_new(&param, "test_param3", AMXC_VAR_ID_CSTRING), 0);
135  assert_int_not_equal(amxd_object_add_param(object, param), 0);
136  amxd_param_delete(&param);
137 
138  assert_int_equal(amxd_param_new(&param, "templ_param1", AMXC_VAR_ID_CSTRING), 0);
139  assert_int_equal(amxd_object_add_param(templ, param), 0);
140  assert_int_equal(amxd_param_new(&param, "templ_param2", AMXC_VAR_ID_CSTRING), 0);
141  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_template, true), 0);
142  assert_int_equal(amxd_object_add_param(templ, param), 0);
143  assert_int_equal(amxd_param_new(&param, "templ_param3", AMXC_VAR_ID_CSTRING), 0);
144  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_instance, true), 0);
145  assert_int_equal(amxd_object_add_param(templ, param), 0);
146  assert_int_equal(amxd_param_new(&param, "templ_param4", AMXC_VAR_ID_CSTRING), 0);
147  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_instance, true), 0);
148  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_template, true), 0);
149  assert_int_equal(amxd_object_add_param(templ, param), 0);
150 
151  amxd_dm_clean(&dm);
152 }
153 
154 void test_amxd_object_add_param_invalid_arg(UNUSED void** state) {
155  amxd_object_t* object = NULL;
156  amxd_param_t* param = NULL;
157  assert_int_equal(amxd_dm_init(&dm), 0);
158 
159  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "parent"), 0);
160  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
161 
162  assert_int_equal(amxd_param_new(&param, "test_func", AMXC_VAR_ID_CSTRING), 0);
163  assert_int_not_equal(amxd_object_add_param(NULL, param), 0);
164  assert_int_not_equal(amxd_object_add_param(object, NULL), 0);
165  assert_int_equal(amxd_object_add_param(object, param), 0);
166  assert_int_not_equal(amxd_object_add_param(object, param), 0);
167 
168  amxd_dm_clean(&dm);
169 }
170 
171 void test_amxd_object_get_parameter(UNUSED void** state) {
172  amxd_object_t* template = NULL;
173  amxd_object_t* object = NULL;
174  amxd_object_t* instance = NULL;
175  amxd_object_t* instance_object = NULL;
176 
177  amxd_param_t* param = NULL;
178  assert_int_equal(amxd_dm_init(&dm), 0);
179 
180  assert_int_equal(amxd_object_new(&template, amxd_object_template, "parent"), 0);
181  assert_int_equal(amxd_dm_add_root_object(&dm, template), 0);
182  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "child"), 0);
183  assert_int_equal(amxd_object_add_object(template, object), 0);
184  assert_int_equal(amxd_param_new(&param, "templ_param_x", AMXC_VAR_ID_CSTRING), 0);
185  assert_int_equal(amxd_object_add_param(template, param), 0);
186  assert_int_equal(amxd_param_new(&param, "templ_param", AMXC_VAR_ID_CSTRING), 0);
187  assert_int_equal(amxd_object_add_param(template, param), 0);
188  assert_int_equal(amxd_param_new(&param, "child_param", AMXC_VAR_ID_CSTRING), 0);
189  assert_int_equal(amxd_object_add_param(object, param), 0);
190 
191  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
192  param = amxd_object_get_param_def(instance, "templ_param");
193  assert_ptr_not_equal(param, NULL);
194  assert_ptr_equal(amxd_param_get_owner(param), instance);
195 
196  assert_ptr_equal(amxd_object_get_param_value(instance, "templ_param"), &param->value);
197  assert_null(amxd_object_get_param_value(instance, "NotExistingParam"));
198  assert_null(amxd_object_get_param_value(NULL, "templ_param"));
199  assert_null(amxd_object_get_param_value(instance, ""));
200  assert_null(amxd_object_get_param_value(instance, NULL));
201  assert_int_equal(amxd_param_new(&param, "new_param", AMXC_VAR_ID_CSTRING), 0);
202  assert_int_equal(amxd_object_add_param(instance, param), 0);
203  assert_non_null(amxd_object_get_param_value(instance, "new_param"));
204  assert_true(param->attr.instance);
205  assert_int_equal(amxd_param_new(&param, "new_templ_param", AMXC_VAR_ID_CSTRING), 0);
206  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_template, true), 0);
207  assert_int_not_equal(amxd_object_add_param(instance, param), 0);
208  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_instance, true), 0);
209  assert_int_equal(amxd_object_add_param(instance, param), 0);
210  amxd_param_delete(&param);
211 
212  param = amxd_object_get_param_def(object, "child_param");
213  assert_ptr_not_equal(param, NULL);
214  assert_ptr_equal(amxd_param_get_owner(param), object);
215 
216  instance_object = amxd_object_get(instance, "child");
217  assert_ptr_not_equal(instance_object, NULL);
218  assert_ptr_equal(amxd_object_get_parent(instance_object), instance);
219  assert_ptr_equal(instance_object->derived_from.llist, &object->derived_objects);
220  assert_ptr_equal(instance_object->type, amxd_object_singleton);
221  param = amxd_object_get_param_def(instance_object, "child_param");
222  assert_ptr_not_equal(param, NULL);
223  assert_ptr_equal(amxd_param_get_owner(param), instance_object);
224 
225  assert_ptr_equal(amxd_object_get_param_def(NULL, "child_param"), NULL);
226  assert_ptr_equal(amxd_object_get_param_def(instance_object, ""), NULL);
227  assert_ptr_equal(amxd_object_get_param_def(instance_object, NULL), NULL);
228  assert_ptr_equal(amxd_object_get_param_def(amxd_dm_get_root(&dm), "Test"), NULL);
229 
230  amxd_dm_clean(&dm);
231 }
232 
233 void test_amxd_object_get_parameter_value(UNUSED void** state) {
234  amxd_object_t* template = NULL;
235  amxd_object_t* object = NULL;
236  amxd_object_t* instance = NULL;
237  amxc_var_t value;
238 
239  amxc_var_init(&value);
240 
241  template = test_build_dm();
242  object = amxd_object_get_child(template, "child");
243 
244  assert_int_equal(amxd_object_get_param(template, "templ_param", &value), 0);
245  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_CSTRING);
246  assert_int_equal(amxd_object_get_param(template, "inst_param", &value), 0);
247  assert_int_equal(amxd_object_get_param(template, "param", &value), 0);
248  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT32);
249 
250  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
251  assert_int_not_equal(amxd_object_get_param(instance, "templ_param", &value), 0);
252  assert_int_equal(amxd_object_get_param(instance, "inst_param", &value), 0);
253  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_BOOL);
254  assert_int_equal(amxd_object_get_param(instance, "param", &value), 0);
255  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT32);
256 
257  assert_int_equal(amxd_object_get_param(object, "child_param", &value), 0);
258  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_CSTRING);
259  assert_int_equal(amxd_object_get_param(object, "child_param2", &value), 0);
260  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_BOOL);
261  assert_int_equal(amxd_object_get_param(object, "child_param3", &value), 0);
262  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT64);
263 
264  object = amxd_object_get_child(instance, "child");
265  assert_int_equal(amxd_object_get_param(object, "child_param", &value), 0);
266  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_CSTRING);
267  assert_int_equal(amxd_object_get_param(object, "child_param2", &value), 0);
268  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_BOOL);
269  assert_int_equal(amxd_object_get_param(object, "child_param3", &value), 0);
270  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT64);
271 
272  assert_int_not_equal(amxd_object_get_param(object, "fake_news", &value), 0);
273  assert_int_not_equal(amxd_object_get_param(object, NULL, &value), 0);
274  assert_int_not_equal(amxd_object_get_param(object, "", &value), 0);
275  assert_int_not_equal(amxd_object_get_param(object, "fake_news", NULL), 0);
276  assert_int_not_equal(amxd_object_get_param(NULL, "fake_news", &value), 0);
277 
278  amxc_var_clean(&value);
279  amxd_dm_clean(&dm);
280 }
281 
282 void test_amxd_object_get_parameter_value_type(UNUSED void** state) {
283  amxd_object_t* template = NULL;
284  amxd_object_t* object = NULL;
285  amxd_object_t* instance = NULL;
286  amxd_status_t status = amxd_status_ok;
287  char* str_val = NULL;
288  uint32_t uint32_val = 0;
289  uint64_t uint64_val = 0;
290  int32_t int32_val = 0;
291  int64_t int64_val = 0;
292  bool bool_val = false;
293  double double_val = 0;
294 
295  template = test_build_dm();
296  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
297  object = amxd_object_get_child(instance, "child");
298 
299  amxd_object_set_value(cstring_t, object, "child_param", "1234");
300  str_val = amxd_object_get_value(cstring_t, object, "child_param", &status);
301  assert_int_equal(status, 0);
302  assert_ptr_not_equal(str_val, NULL);
303  assert_string_equal(str_val, "1234");
304  free(str_val);
305  str_val = NULL;
306 
307  uint32_val = amxd_object_get_value(uint32_t, object, "child_param", &status);
308  assert_int_equal(status, 0);
309  assert_int_equal(uint32_val, 1234);
310  uint64_val = amxd_object_get_value(uint64_t, object, "child_param", &status);
311  assert_int_equal(status, 0);
312  assert_int_equal(uint64_val, 1234);
313  int32_val = amxd_object_get_value(int32_t, object, "child_param", &status);
314  assert_int_equal(status, 0);
315  assert_int_equal(int32_val, 1234);
316  int64_val = amxd_object_get_value(int64_t, object, "child_param", &status);
317  assert_int_equal(int64_val, 1234);
318  assert_int_equal(status, 0);
319  bool_val = amxd_object_get_value(bool, object, "child_param", &status);
320  assert_int_equal(status, 0);
321  assert_false(bool_val);
322  double_val = amxd_object_get_value(double, object, "child_param", &status);
323  assert_int_equal(status, 0);
324  assert_true(double_val == 1234);
325 
326  uint32_val = amxd_object_get_value(uint32_t, object, "child_param", NULL);
327  assert_int_equal(uint32_val, 1234);
328  uint64_val = amxd_object_get_value(uint64_t, object, "child_param", NULL);
329  assert_int_equal(uint64_val, 1234);
330  int32_val = amxd_object_get_value(int32_t, object, "child_param", NULL);
331  assert_int_equal(int32_val, 1234);
332  int64_val = amxd_object_get_value(int64_t, object, "child_param", NULL);
333  assert_int_equal(status, 0);
334  bool_val = amxd_object_get_value(bool, object, "child_param", NULL);
335  assert_false(bool_val);
336  double_val = amxd_object_get_value(double, object, "child_param", NULL);
337  assert_true(double_val == 1234);
338 
339  str_val = amxd_object_get_value(cstring_t, NULL, "child_param", &status);
340  assert_int_not_equal(status, 0);
341  uint32_val = amxd_object_get_value(uint32_t, NULL, "child_param", &status);
342  assert_int_not_equal(status, 0);
343  uint64_val = amxd_object_get_value(uint64_t, NULL, "child_param", &status);
344  assert_int_not_equal(status, 0);
345  int32_val = amxd_object_get_value(int32_t, NULL, "child_param", &status);
346  assert_int_not_equal(status, 0);
347  int64_val = amxd_object_get_value(int64_t, NULL, "child_param", &status);
348  assert_int_not_equal(status, 0);
349  bool_val = amxd_object_get_value(bool, NULL, "child_param", &status);
350  assert_int_not_equal(status, 0);
351  double_val = amxd_object_get_value(double, NULL, "child_param", &status);
352  assert_int_not_equal(status, 0);
353 
354  str_val = amxd_object_get_value(cstring_t, object, NULL, &status);
355  assert_int_not_equal(status, 0);
356  uint32_val = amxd_object_get_value(uint32_t, object, NULL, &status);
357  assert_int_not_equal(status, 0);
358  uint64_val = amxd_object_get_value(uint64_t, object, NULL, &status);
359  assert_int_not_equal(status, 0);
360  int32_val = amxd_object_get_value(int32_t, object, NULL, &status);
361  assert_int_not_equal(status, 0);
362  int64_val = amxd_object_get_value(int64_t, object, NULL, &status);
363  assert_int_not_equal(status, 0);
364  bool_val = amxd_object_get_value(bool, object, NULL, &status);
365  assert_int_not_equal(status, 0);
366  double_val = amxd_object_get_value(double, object, NULL, &status);
367  assert_int_not_equal(status, 0);
368 
369  amxd_dm_clean(&dm);
370 }
371 
372 void test_amxd_object_get_parameter_value_with_cb(UNUSED void** state) {
373  amxd_object_t* template = NULL;
374  amxd_object_t* object = NULL;
375  amxd_object_t* instance = NULL;
376  amxc_var_t value;
377 
378  amxc_var_init(&value);
379 
380  template = test_build_dm();
381  object = amxd_object_get_child(template, "child");
382  assert_int_equal(amxd_object_add_action_cb(template, action_object_read, amxd_action_object_read, NULL), 0);
383  assert_int_equal(amxd_object_add_action_cb(object, action_object_read, amxd_action_object_read, NULL), 0);
384 
385  assert_int_equal(amxd_object_get_param(template, "templ_param", &value), 0);
386  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_CSTRING);
387  assert_int_equal(amxd_object_get_param(template, "inst_param", &value), 0);
388  assert_int_equal(amxd_object_get_param(template, "param", &value), 0);
389  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT32);
390 
391  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
392  assert_int_not_equal(amxd_object_get_param(instance, "templ_param", &value), 0);
393  assert_int_equal(amxd_object_get_param(instance, "inst_param", &value), 0);
394  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_BOOL);
395  assert_int_equal(amxd_object_get_param(instance, "param", &value), 0);
396  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT32);
397 
398  assert_int_equal(amxd_object_get_param(template, "templ_param", &value), 0);
399  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_CSTRING);
400  assert_int_equal(amxd_object_get_param(template, "inst_param", &value), 0);
401  assert_int_equal(amxd_object_get_param(template, "param", &value), 0);
402  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT32);
403 
404  assert_int_equal(amxd_object_get_param(object, "child_param", &value), 0);
405  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_CSTRING);
406  assert_int_equal(amxd_object_get_param(object, "child_param2", &value), 0);
407  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_BOOL);
408  assert_int_equal(amxd_object_get_param(object, "child_param3", &value), 0);
409  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT64);
410 
411  object = amxd_object_get_child(instance, "child");
412  assert_int_equal(amxd_object_get_param(object, "child_param", &value), 0);
413  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_CSTRING);
414  assert_int_equal(amxd_object_get_param(object, "child_param2", &value), 0);
415  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_BOOL);
416  assert_int_equal(amxd_object_get_param(object, "child_param3", &value), 0);
417  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT64);
418 
419  assert_int_not_equal(amxd_object_get_param(object, "fake_news", &value), 0);
420  assert_int_not_equal(amxd_object_get_param(object, NULL, &value), 0);
421  assert_int_not_equal(amxd_object_get_param(object, "", &value), 0);
422  assert_int_not_equal(amxd_object_get_param(object, "fake_news", NULL), 0);
423  assert_int_not_equal(amxd_object_get_param(NULL, "fake_news", &value), 0);
424 
425  amxc_var_clean(&value);
426  amxd_dm_clean(&dm);
427 }
428 
429 void test_amxd_object_set_parameter_value(UNUSED void** state) {
430  amxd_object_t* template = NULL;
431  amxd_object_t* object = NULL;
432  amxd_object_t* instance = NULL;
433  amxc_var_t value;
434 
435  amxc_var_init(&value);
436  template = test_build_dm();
437  object = amxd_object_get_child(template, "child");
438 
439  amxc_var_set(uint32_t, &value, 123);
440  assert_int_equal(amxd_object_set_param(template, "templ_param", &value), 0);
441  amxc_var_clean(&value);
442  assert_int_equal(amxd_object_get_param(template, "templ_param", &value), 0);
443  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_CSTRING);
444  assert_string_equal(amxc_var_constcast(cstring_t, &value), "123");
445  amxc_var_set(uint32_t, &value, 123);
446  assert_int_not_equal(amxd_object_set_param(template, "inst_param", &value), 0);
447  assert_int_equal(amxd_object_set_param(template, "param", &value), 0);
448 
449  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
450  assert_int_not_equal(amxd_object_set_param(instance, "templ_param", &value), 0);
451  assert_int_equal(amxd_object_set_param(instance, "inst_param", &value), 0);
452  assert_int_equal(amxd_object_set_param(instance, "param", &value), 0);
453  amxc_var_clean(&value);
454  assert_int_equal(amxd_object_get_param(instance, "param", &value), 0);
455  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT32);
456 
457  assert_int_not_equal(amxd_object_set_param(object, "fake_news", &value), 0);
458  assert_int_not_equal(amxd_object_set_param(object, NULL, &value), 0);
459  assert_int_not_equal(amxd_object_set_param(object, "", &value), 0);
460  assert_int_not_equal(amxd_object_set_param(object, "fake_news", NULL), 0);
461  assert_int_not_equal(amxd_object_set_param(NULL, "fake_news", &value), 0);
462 
463  amxc_var_clean(&value);
464  amxd_dm_clean(&dm);
465 }
466 
467 void test_amxd_object_set_parameter_value_type(UNUSED void** state) {
468  amxd_object_t* template = NULL;
469  amxd_object_t* object = NULL;
470  amxd_object_t* instance = NULL;
471  amxc_var_t value;
472 
473  amxc_var_init(&value);
474  template = test_build_dm();
475  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
476 
477  object = amxd_object_get_child(instance, "child");
478  assert_int_equal(amxd_object_set_value(cstring_t, object, "child_param", "Hello"), 0);
479  assert_int_equal(amxd_object_set_value(cstring_t, object, "child_param", ""), 0);
480  assert_int_equal(amxd_object_set_value(int32_t, object, "child_param", 1), 0);
481  assert_int_equal(amxd_object_set_value(uint32_t, object, "child_param", 2), 0);
482  assert_int_equal(amxd_object_set_value(int64_t, object, "child_param", 3), 0);
483  assert_int_equal(amxd_object_set_value(uint64_t, object, "child_param", 4), 0);
484  assert_int_equal(amxd_object_set_value(bool, object, "child_param", true), 0);
485  assert_int_equal(amxd_object_set_value(double, object, "child_param", 3.14), 0);
486 
487  assert_int_not_equal(amxd_object_set_value(cstring_t, object, "child_param", NULL), 0);
488  assert_int_not_equal(amxd_object_set_value(cstring_t, NULL, "child_param", "Hello"), 0);
489  assert_int_not_equal(amxd_object_set_value(int32_t, NULL, "child_param", 1), 0);
490  assert_int_not_equal(amxd_object_set_value(uint32_t, NULL, "child_param", 2), 0);
491  assert_int_not_equal(amxd_object_set_value(int64_t, NULL, "child_param", 3), 0);
492  assert_int_not_equal(amxd_object_set_value(uint64_t, NULL, "child_param", 4), 0);
493  assert_int_not_equal(amxd_object_set_value(bool, NULL, "child_param", true), 0);
494  assert_int_not_equal(amxd_object_set_value(double, NULL, "child_param", 3.14), 0);
495 
496  assert_int_not_equal(amxd_object_set_value(cstring_t, object, "", "Hello"), 0);
497  assert_int_not_equal(amxd_object_set_value(int32_t, object, "", 1), 0);
498  assert_int_not_equal(amxd_object_set_value(uint32_t, object, "", 2), 0);
499  assert_int_not_equal(amxd_object_set_value(int64_t, object, "", 3), 0);
500  assert_int_not_equal(amxd_object_set_value(uint64_t, object, "", 4), 0);
501  assert_int_not_equal(amxd_object_set_value(bool, object, "", true), 0);
502  assert_int_not_equal(amxd_object_set_value(double, object, "", 3.14), 0);
503 
504  assert_int_not_equal(amxd_object_set_value(cstring_t, object, NULL, "Hello"), 0);
505  assert_int_not_equal(amxd_object_set_value(int32_t, object, NULL, 1), 0);
506  assert_int_not_equal(amxd_object_set_value(uint32_t, object, NULL, 2), 0);
507  assert_int_not_equal(amxd_object_set_value(int64_t, object, NULL, 3), 0);
508  assert_int_not_equal(amxd_object_set_value(uint64_t, object, NULL, 4), 0);
509  assert_int_not_equal(amxd_object_set_value(bool, object, NULL, true), 0);
510  assert_int_not_equal(amxd_object_set_value(double, object, NULL, 3.14), 0);
511 
512  amxc_var_clean(&value);
513  amxd_dm_clean(&dm);
514 }
515 
516 void test_amxd_object_set_parameters_value(UNUSED void** state) {
517  amxd_object_t* template = NULL;
518  amxd_object_t* object = NULL;
519  amxc_var_t values;
520  amxc_var_t* value;
521 
522  amxc_var_init(&values);
523  template = test_build_dm();
524  object = amxd_object_get_child(template, "child");
525 
526  amxc_var_set_type(&values, AMXC_VAR_ID_HTABLE);
527  amxc_var_add_key(cstring_t, &values, "param", "123");
528  amxc_var_add_key(uint32_t, &values, "templ_param", 123);
529  assert_int_equal(amxd_object_set_params(template, &values), 0);
530  amxc_var_clean(&values);
531  assert_int_equal(amxd_object_get_params(template, &values, amxd_dm_access_private), 0);
532  value = amxc_var_get_path(&values, "templ_param", AMXC_VAR_FLAG_DEFAULT);
533  assert_int_equal(amxc_var_type_of(value), AMXC_VAR_ID_CSTRING);
534  assert_string_equal(amxc_var_constcast(cstring_t, value), "123");
535  value = amxc_var_get_path(&values, "param", AMXC_VAR_FLAG_DEFAULT);
536  assert_int_equal(amxc_var_type_of(value), AMXC_VAR_ID_UINT32);
537  assert_int_equal(amxc_var_constcast(uint32_t, value), 123);
538 
539  amxc_var_set_type(&values, AMXC_VAR_ID_HTABLE);
540  amxc_var_add_key(cstring_t, &values, "fake_news", "123");
541  amxc_var_add_key(uint32_t, &values, "invalid", 123);
542  assert_int_not_equal(amxd_object_set_params(object, &values), 0);
543  assert_int_not_equal(amxd_object_set_params(object, NULL), 0);
544  assert_int_not_equal(amxd_object_set_params(NULL, &values), 0);
545  amxc_var_set_type(&values, AMXC_VAR_ID_LIST);
546  assert_int_not_equal(amxd_object_set_params(object, &values), 0);
547 
548  amxc_var_clean(&values);
549  amxd_dm_clean(&dm);
550 }
551 
552 void test_amxd_object_set_parameter_value_with_cb(UNUSED void** state) {
553  amxd_object_t* template = NULL;
554  amxd_object_t* object = NULL;
555  amxd_object_t* instance = NULL;
556  amxc_var_t value;
557 
558  amxc_var_init(&value);
559  template = test_build_dm();
560  object = amxd_object_get_child(template, "child");
561  assert_int_equal(amxd_object_add_action_cb(template, action_object_write, amxd_action_object_write, NULL), 0);
562  assert_int_equal(amxd_object_add_action_cb(object, action_object_write, amxd_action_object_write, NULL), 0);
563 
564  amxc_var_set(uint32_t, &value, 123);
565  assert_int_equal(amxd_object_set_param(template, "templ_param", &value), 0);
566  amxc_var_clean(&value);
567  assert_int_equal(amxd_object_get_param(template, "templ_param", &value), 0);
568  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_CSTRING);
569  assert_string_equal(amxc_var_constcast(cstring_t, &value), "123");
570  amxc_var_set(uint32_t, &value, 123);
571  assert_int_not_equal(amxd_object_set_param(template, "inst_param", &value), 0);
572  assert_int_equal(amxd_object_set_param(template, "param", &value), 0);
573 
574  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
575  assert_int_not_equal(amxd_object_set_param(instance, "templ_param", &value), 0);
576  assert_int_equal(amxd_object_set_param(instance, "inst_param", &value), 0);
577  assert_int_equal(amxd_object_set_param(instance, "param", &value), 0);
578  amxc_var_clean(&value);
579  assert_int_equal(amxd_object_get_param(instance, "param", &value), 0);
580  assert_int_equal(amxc_var_type_of(&value), AMXC_VAR_ID_UINT32);
581 
582  assert_int_not_equal(amxd_object_set_param(object, "fake_news", &value), 0);
583  assert_int_not_equal(amxd_object_set_param(object, NULL, &value), 0);
584  assert_int_not_equal(amxd_object_set_param(object, "", &value), 0);
585  assert_int_not_equal(amxd_object_set_param(object, "fake_news", NULL), 0);
586  assert_int_not_equal(amxd_object_set_param(NULL, "fake_news", &value), 0);
587 
588  amxd_dm_clean(&dm);
589 }
590 
591 void test_amxd_object_set_parameters_value_with_cb(UNUSED void** state) {
592  amxd_object_t* template = NULL;
593  amxd_object_t* object = NULL;
594  amxc_var_t values;
595  amxc_var_t* value;
596 
597  amxc_var_init(&values);
598  template = test_build_dm();
599  object = amxd_object_get_child(template, "child");
600  assert_int_equal(amxd_object_add_action_cb(template, action_object_write, amxd_action_object_write, NULL), 0);
601 
602  amxc_var_set_type(&values, AMXC_VAR_ID_HTABLE);
603  amxc_var_add_key(cstring_t, &values, "param", "123");
604  amxc_var_add_key(uint32_t, &values, "templ_param", 123);
605  assert_int_equal(amxd_object_set_params(template, &values), 0);
606  amxc_var_clean(&values);
607  assert_int_equal(amxd_object_get_params(template, &values, amxd_dm_access_private), 0);
608  value = amxc_var_get_path(&values, "templ_param", AMXC_VAR_FLAG_DEFAULT);
609  assert_int_equal(amxc_var_type_of(value), AMXC_VAR_ID_CSTRING);
610  assert_string_equal(amxc_var_constcast(cstring_t, value), "123");
611  value = amxc_var_get_path(&values, "param", AMXC_VAR_FLAG_DEFAULT);
612  assert_int_equal(amxc_var_type_of(value), AMXC_VAR_ID_UINT32);
613  assert_int_equal(amxc_var_constcast(uint32_t, value), 123);
614 
615  amxc_var_set_type(&values, AMXC_VAR_ID_HTABLE);
616  amxc_var_add_key(cstring_t, &values, "fake_news", "123");
617  amxc_var_add_key(uint32_t, &values, "invalid", 123);
618  assert_int_not_equal(amxd_object_set_params(object, &values), 0);
619  assert_int_not_equal(amxd_object_set_params(object, NULL), 0);
620  assert_int_not_equal(amxd_object_set_params(NULL, &values), 0);
621  amxc_var_set_type(&values, AMXC_VAR_ID_LIST);
622  assert_int_not_equal(amxd_object_set_params(object, &values), 0);
623 
624  amxc_var_clean(&values);
625  amxd_dm_clean(&dm);
626 }
627 
628 void test_amxd_object_get_parameters_value(UNUSED void** state) {
629  amxd_object_t* template = NULL;
630  amxd_object_t* object = NULL;
631  amxd_object_t* instance = NULL;
632  int index = 0;
633  amxc_var_t params;
634 
635  amxc_var_init(&params);
636  template = test_build_dm();
637  object = amxd_object_get_child(template, "child");
638 
639  assert_int_equal(amxd_object_get_params(template, &params, amxd_dm_access_protected), 0);
640  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
641  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 3);
642 
643  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
644  assert_int_equal(amxd_object_get_params(template, &params, amxd_dm_access_protected), 0);
645  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
646  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 3); // 2 template parameters
647 
648  assert_int_equal(amxd_object_get_params(instance, &params, amxd_dm_access_protected), 0);
649  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
650  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 2);
651 
652  assert_int_equal(amxd_object_get_params(object, &params, amxd_dm_access_protected), 0);
653  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
654  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 2);
655 
656  assert_int_equal(amxd_object_get_params(object, &params, amxd_dm_access_private), 0);
657  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
658  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 3);
659 
660  object = amxd_object_get_child(instance, "child");
661  assert_int_equal(amxd_object_get_params(object, &params, amxd_dm_access_protected), 0);
662  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
663  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 2);
664  index = 0;
665  amxc_htable_for_each(it, amxc_var_constcast(amxc_htable_t, &params)) {
666  const char* names[2] = { "child_param2", "child_param3" };
667  const char* param_name = amxc_htable_it_get_key(it);
668  assert_string_equal(param_name, names[index]);
669  index++;
670  }
671 
672  assert_int_equal(amxd_object_get_params(object, &params, amxd_dm_access_private), 0);
673  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
674  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 3);
675 
676  assert_int_not_equal(amxd_object_get_params(NULL, &params, amxd_dm_access_private), 0);
677  assert_int_not_equal(amxd_object_get_params(object, NULL, amxd_dm_access_private), 0);
678 
679  amxc_var_clean(&params);
680  amxd_dm_clean(&dm);
681 }
682 
683 void test_amxd_object_get_parameters_value_with_cb(UNUSED void** state) {
684  amxd_object_t* template = NULL;
685  amxd_object_t* object = NULL;
686  amxd_object_t* instance = NULL;
687  int index = 0;
688  amxc_var_t params;
689 
690  amxc_var_init(&params);
691  template = test_build_dm();
692  object = amxd_object_get_child(template, "child");
693  assert_int_equal(amxd_object_add_action_cb(template, action_object_read, amxd_action_object_read, NULL), 0);
694  assert_int_equal(amxd_object_add_action_cb(object, action_object_read, amxd_action_object_read, NULL), 0);
695 
696  assert_int_equal(amxd_object_get_params(template, &params, amxd_dm_access_protected), 0);
697  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
698  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 3);
699 
700  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
701  assert_int_equal(amxd_object_get_params(template, &params, amxd_dm_access_protected), 0);
702  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
703  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 3); // 2 template parameters
704 
705  assert_int_equal(amxd_object_get_params(instance, &params, amxd_dm_access_protected), 0);
706  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
707  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 2);
708 
709  assert_int_equal(amxd_object_get_params(object, &params, amxd_dm_access_protected), 0);
710  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
711  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 2);
712 
713  assert_int_equal(amxd_object_get_params(object, &params, amxd_dm_access_private), 0);
714  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
715  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 3);
716 
717  object = amxd_object_get_child(instance, "child");
718  assert_int_equal(amxd_object_get_params(object, &params, amxd_dm_access_protected), 0);
719  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
720  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 2);
721  index = 0;
722  amxc_htable_for_each(it, amxc_var_constcast(amxc_htable_t, &params)) {
723  const char* names[2] = { "child_param2", "child_param3" };
724  const char* param_name = amxc_htable_it_get_key(it);
725  assert_string_equal(param_name, names[index]);
726  index++;
727  }
728 
729  assert_int_equal(amxd_object_get_params(object, &params, amxd_dm_access_private), 0);
730  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
731  assert_int_equal(amxc_htable_size(amxc_var_constcast(amxc_htable_t, &params)), 3);
732 
733  assert_int_not_equal(amxd_object_get_params(NULL, &params, amxd_dm_access_private), 0);
734  assert_int_not_equal(amxd_object_get_params(object, NULL, amxd_dm_access_private), 0);
735 
736  amxc_var_clean(&params);
737  amxd_dm_clean(&dm);
738 }
739 
740 void test_amxd_object_list_parameters(UNUSED void** state) {
741  amxd_object_t* template = NULL;
742  amxd_object_t* object = NULL;
743  amxd_object_t* instance = NULL;
744  int index = 0;
745  amxc_var_t plist;
746 
747  amxc_var_init(&plist);
748  template = test_build_dm();
749  object = amxd_object_get_child(template, "child");
750 
751  assert_int_equal(amxd_object_list_params(template, &plist, amxd_dm_access_public), 0);
752  assert_int_equal(amxc_var_type_of(&plist), AMXC_VAR_ID_LIST);
753  index = 0;
754  amxc_llist_for_each(it, (amxc_var_constcast(amxc_llist_t, &plist))) {
755  const char* names[3] = { "templ_param", "inst_param", "param" };
756  amxc_var_t* param_name = amxc_var_from_llist_it(it);
757  assert_int_equal(amxc_var_type_of(param_name), AMXC_VAR_ID_CSTRING);
758  assert_string_equal(amxc_var_constcast(cstring_t, param_name), names[index]);
759  index++;
760  }
761 
762  assert_int_equal(amxd_object_list_params(template, &plist, amxd_dm_access_protected), 0);
763  assert_int_equal(amxc_var_type_of(&plist), AMXC_VAR_ID_LIST);
764  index = 0;
765  amxc_llist_for_each(it, (amxc_var_constcast(amxc_llist_t, &plist))) {
766  const char* names[3] = { "templ_param", "inst_param", "param" };
767  amxc_var_t* param_name = amxc_var_from_llist_it(it);
768  assert_int_equal(amxc_var_type_of(param_name), AMXC_VAR_ID_CSTRING);
769  assert_string_equal(amxc_var_constcast(cstring_t, param_name), names[index]);
770  index++;
771  }
772 
773  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
774  index = 0;
775  assert_int_equal(amxd_object_list_params(instance, &plist, amxd_dm_access_public), 0);
776  assert_int_equal(amxc_var_type_of(&plist), AMXC_VAR_ID_LIST);
777  amxc_llist_for_each(it, (amxc_var_constcast(amxc_llist_t, &plist))) {
778  const char* names[2] = { "inst_param", "param" };
779  amxc_var_t* param_name = amxc_var_from_llist_it(it);
780  assert_int_equal(amxc_var_type_of(param_name), AMXC_VAR_ID_CSTRING);
781  assert_string_equal(amxc_var_constcast(cstring_t, param_name), names[index]);
782  index++;
783  }
784 
785  assert_int_equal(amxd_object_list_params(object, &plist, amxd_dm_access_public), 0);
786  assert_int_equal(amxc_var_type_of(&plist), AMXC_VAR_ID_LIST);
787  index = 0;
788  amxc_llist_for_each(it, (amxc_var_constcast(amxc_llist_t, &plist))) {
789  const char* names[2] = { "child_param2", "child_param3" };
790  amxc_var_t* param_name = amxc_var_from_llist_it(it);
791  assert_int_equal(amxc_var_type_of(param_name), AMXC_VAR_ID_CSTRING);
792  assert_string_equal(amxc_var_constcast(cstring_t, param_name), names[index]);
793  index++;
794  }
795 
796  assert_int_equal(amxd_object_list_params(object, &plist, amxd_dm_access_private), 0);
797  assert_int_equal(amxc_var_type_of(&plist), AMXC_VAR_ID_LIST);
798  index = 0;
799  amxc_llist_for_each(it, (amxc_var_constcast(amxc_llist_t, &plist))) {
800  const char* names[3] = { "child_param", "child_param2", "child_param3" };
801  amxc_var_t* param_name = amxc_var_from_llist_it(it);
802  assert_int_equal(amxc_var_type_of(param_name), AMXC_VAR_ID_CSTRING);
803  assert_string_equal(amxc_var_constcast(cstring_t, param_name), names[index]);
804  index++;
805  }
806 
807  assert_int_equal(amxd_object_list_params(object, &plist, amxd_dm_access_public), 0);
808  assert_int_equal(amxc_var_type_of(&plist), AMXC_VAR_ID_LIST);
809  index = 0;
810  amxc_llist_for_each(it, (amxc_var_constcast(amxc_llist_t, &plist))) {
811  const char* names[2] = { "child_param2", "child_param3" };
812  amxc_var_t* param_name = amxc_var_from_llist_it(it);
813  assert_int_equal(amxc_var_type_of(param_name), AMXC_VAR_ID_CSTRING);
814  assert_string_equal(amxc_var_constcast(cstring_t, param_name), names[index]);
815  index++;
816  }
817 
818  object = amxd_object_get_child(instance, "child");
819  assert_int_equal(amxd_object_list_params(object, &plist, amxd_dm_access_private), 0);
820  assert_int_equal(amxc_var_type_of(&plist), AMXC_VAR_ID_LIST);
821  index = 0;
822  amxc_llist_for_each(it, (amxc_var_constcast(amxc_llist_t, &plist))) {
823  const char* names[3] = { "child_param", "child_param2", "child_param3" };
824  amxc_var_t* param_name = amxc_var_from_llist_it(it);
825  assert_int_equal(amxc_var_type_of(param_name), AMXC_VAR_ID_CSTRING);
826  assert_string_equal(amxc_var_constcast(cstring_t, param_name), names[index]);
827  index++;
828  }
829 
830  assert_int_not_equal(amxd_object_list_params(object, NULL, amxd_dm_access_private), 0);
831  assert_int_not_equal(amxd_object_list_params(NULL, &plist, amxd_dm_access_private), 0);
832 
833  amxc_var_clean(&plist);
834  amxd_dm_clean(&dm);
835 }
836 
837 void test_amxd_object_count_parameters(UNUSED void** state) {
838  amxd_object_t* template = NULL;
839  amxd_object_t* object = NULL;
840  amxd_object_t* instance = NULL;
841 
842  template = test_build_dm();
843  object = amxd_object_get_child(template, "child");
844 
845  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
846 
847  assert_int_equal(amxd_object_get_param_count(template, amxd_dm_access_protected), 3);
848  assert_int_equal(amxd_object_get_param_count(instance, amxd_dm_access_protected), 2);
849  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_protected), 2);
850  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_private), 3);
851  object = amxd_object_get_child(instance, "child");
852  assert_ptr_not_equal(object, NULL);
853  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_protected), 2);
854  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_private), 3);
855 
856  assert_int_equal(amxd_object_get_param_count(NULL, amxd_dm_access_protected), 0);
857  assert_int_equal(amxd_object_get_param_count(NULL, amxd_dm_access_private), 0);
858 
859  amxd_dm_clean(&dm);
860 }
861 
862 void test_amxd_object_count_parameters_with_cb(UNUSED void** state) {
863  amxd_object_t* template = NULL;
864  amxd_object_t* object = NULL;
865  amxd_object_t* instance = NULL;
866 
867  template = test_build_dm();
868  object = amxd_object_get_child(template, "child");
869  assert_int_equal(amxd_object_add_action_cb(template, action_object_list, amxd_action_object_list, NULL), 0);
870  assert_int_equal(amxd_object_add_action_cb(object, action_object_list, amxd_action_object_list, NULL), 0);
871 
872  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
873 
874  assert_int_equal(amxd_object_get_param_count(template, amxd_dm_access_protected), 3);
875  assert_int_equal(amxd_object_get_param_count(instance, amxd_dm_access_protected), 2);
876  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_protected), 2);
877  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_private), 3);
878  object = amxd_object_get_child(instance, "child");
879  assert_ptr_not_equal(object, NULL);
880  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_protected), 2);
881  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_private), 3);
882 
883  assert_int_equal(amxd_object_get_param_count(NULL, amxd_dm_access_protected), 0);
884  assert_int_equal(amxd_object_get_param_count(NULL, amxd_dm_access_private), 0);
885 
886  amxd_dm_clean(&dm);
887 }
888 
889 void test_amxd_object_get_params_filtered(UNUSED void** state) {
890  amxd_object_t* template = NULL;
891  amxd_object_t* object = NULL;
892  amxd_object_t* instance = NULL;
893  amxd_param_t* param = NULL;
894  amxc_var_t params;
895  int rv = 0;
896  const amxc_htable_t* ht_params = NULL;
897 
898  amxc_var_init(&params);
899 
900  template = test_build_dm();
901  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
902  object = amxd_object_findf(template, "1.child.");
903  assert_non_null(object);
904  param = amxd_object_get_param_def(object, "child_param2");
905  assert_non_null(param);
906  amxd_param_set_flag(param, "bart");
907  assert_true(amxd_param_has_flag(param, "bart"));
908 
909  rv = amxd_object_get_params_filtered(object, &params,
910  "'bart' in flags", amxd_dm_access_private);
911  assert_int_equal(rv, 0);
912  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
913  ht_params = amxc_var_constcast(amxc_htable_t, &params);
914  assert_int_equal(amxc_htable_size(ht_params), 1);
915 
916  amxd_param_unset_flag(param, "bart");
917  assert_false(amxd_param_has_flag(param, "bart"));
918  rv = amxd_object_get_params_filtered(object, &params,
919  "'bart' in flags", amxd_dm_access_private);
920  assert_int_equal(rv, 0);
921  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
922  ht_params = amxc_var_constcast(amxc_htable_t, &params);
923  assert_int_equal(amxc_htable_size(ht_params), 0);
924 
925  rv = amxd_object_get_params_filtered(object, &params,
926  "name starts with 'child'", amxd_dm_access_private);
927  assert_int_equal(rv, 0);
928  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
929  amxc_var_dump(&params, STDOUT_FILENO);
930  ht_params = amxc_var_constcast(amxc_htable_t, &params);
931  assert_int_equal(amxc_htable_size(ht_params), 3);
932 
933  rv = amxd_object_get_params_filtered(object, &params,
934  "attributes.private == true", amxd_dm_access_private);
935  assert_int_equal(rv, 0);
936  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
937  ht_params = amxc_var_constcast(amxc_htable_t, &params);
938  assert_int_equal(amxc_htable_size(ht_params), 1);
939 
940  rv = amxd_object_get_params_filtered(object, &params, NULL, amxd_dm_access_private);
941  assert_int_equal(rv, 0);
942  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
943  ht_params = amxc_var_constcast(amxc_htable_t, &params);
944  assert_int_equal(amxc_htable_size(ht_params), 3);
945 
946  rv = amxd_object_get_params_filtered(object, &params, "", amxd_dm_access_private);
947  assert_int_equal(rv, 0);
948  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
949  ht_params = amxc_var_constcast(amxc_htable_t, &params);
950  assert_int_equal(amxc_htable_size(ht_params), 3);
951 
952  rv = amxd_object_get_params_filtered(object, &params, "", amxd_dm_access_public);
953  assert_int_equal(rv, 0);
954  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_HTABLE);
955  ht_params = amxc_var_constcast(amxc_htable_t, &params);
956  assert_int_equal(amxc_htable_size(ht_params), 2);
957 
958  amxc_var_clean(&params);
959  amxd_dm_clean(&dm);
960 }
961 
962 void test_amxd_object_get_params_invalid_expr_filter(UNUSED void** state) {
963  amxd_object_t* template = NULL;
964  amxd_object_t* object = NULL;
965  amxd_object_t* instance = NULL;
966  amxc_var_t params;
967  int rv = 0;
968 
969  amxc_var_init(&params);
970 
971  template = test_build_dm();
972  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
973  object = amxd_object_findf(template, "1.child.");
974  assert_non_null(object);
975 
976  rv = amxd_object_get_params_filtered(object, &params, "protocol > 100", amxd_dm_access_private);
977  assert_int_not_equal(rv, 0);
978  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_NULL);
979 
980  rv = amxd_object_get_params_filtered(object, &params, "name <> 100", amxd_dm_access_private);
981  assert_int_not_equal(rv, 0);
982  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_NULL);
983 
984  rv = amxd_object_get_params_filtered(NULL, &params, NULL, amxd_dm_access_private);
985  assert_int_not_equal(rv, 0);
986  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_NULL);
987 
988  rv = amxd_object_get_params_filtered(object, NULL, NULL, amxd_dm_access_private);
989  assert_int_not_equal(rv, 0);
990  assert_int_equal(amxc_var_type_of(&params), AMXC_VAR_ID_NULL);
991 
992  amxc_var_clean(&params);
993  amxd_dm_clean(&dm);
994 }
995 
996 void test_amxd_object_parameter_flags(UNUSED void** state) {
997  amxd_object_t* object = NULL;
998  amxd_param_t* param = NULL;
999 
1000  assert_int_equal(amxd_object_new(&object, amxd_object_template, "test_object"), 0);
1001  assert_int_equal(amxd_param_new(&param, "test_param", AMXC_VAR_ID_CSTRING), 0);
1002  assert_int_equal(amxd_object_add_param(object, param), 0);
1003 
1004  amxd_param_set_flag(param, "test_flag");
1005  assert_true(amxd_param_has_flag(param, "test_flag"));
1006  amxd_param_unset_flag(param, "test_flag");
1007  assert_false(amxd_param_has_flag(param, "test_flag"));
1008 
1009  amxd_param_set_flag(NULL, "test_flag");
1010  amxd_param_set_flag(param, NULL);
1011  amxd_param_set_flag(param, "");
1012 
1013  assert_false(amxd_param_has_flag(NULL, "test_flag"));
1014  assert_false(amxd_param_has_flag(param, NULL));
1015  assert_false(amxd_param_has_flag(param, ""));
1016 
1017  amxd_param_unset_flag(NULL, "test_flag");
1018  amxd_param_unset_flag(param, NULL);
1019  amxd_param_unset_flag(param, "");
1020 
1021  amxd_object_delete(&object);
1022 }
1023 
1024 void test_amxd_object_set(UNUSED void** state) {
1025  amxd_object_t* template = NULL;
1026  amxd_object_t* instance = NULL;
1027  amxd_object_t* object = NULL;
1028  amxd_status_t status = amxd_status_ok;
1029 
1030  char* txt = NULL;
1031  amxc_ts_t ts;
1032  amxc_ts_t* tsp = NULL;
1033 
1034  amxc_ts_now(&ts);
1035 
1036  template = test_build_dm();
1037  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
1038  object = amxd_object_findf(instance, "child.");
1039 
1040  assert_int_equal(amxd_object_set_value(csv_string_t, object, "child_param", "a,b,c"), 0);
1041  assert_int_equal(amxd_object_set_value(ssv_string_t, object, "child_param", "a b c"), 0);
1042  assert_int_equal(amxd_object_set_value(int8_t, object, "child_param", 1), 0);
1043  assert_int_equal(amxd_object_set_value(uint8_t, object, "child_param", 2), 0);
1044  assert_int_equal(amxd_object_set_value(int16_t, object, "child_param", 3), 0);
1045  assert_int_equal(amxd_object_set_value(uint16_t, object, "child_param", 4), 0);
1046  assert_int_equal(amxd_object_set_value(amxc_ts_t, object, "child_param", &ts), 0);
1047 
1048  txt = amxd_object_get_value(cstring_t, object, "child_param", &status);
1049  tsp = amxd_object_get_value(amxc_ts_t, object, "child_param", &status);
1050 
1051  free(txt);
1052  free(tsp);
1053  amxd_dm_clean(&dm);
1054 }
1055 
1056 void test_amxd_object_get_helpers(UNUSED void** state) {
1057  amxd_object_t* template = NULL;
1058  amxd_object_t* instance = NULL;
1059  amxd_object_t* object = NULL;
1060  amxd_status_t status = amxd_status_ok;
1061  amxc_ts_t ts;
1062 
1063  amxc_ts_now(&ts);
1064 
1065  template = test_build_dm();
1066  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
1067  object = amxd_object_findf(instance, "child.");
1068 
1069  assert_int_equal(amxd_object_set_value(cstring_t, object, "child_param", "10"), 0);
1070 
1071  assert_int_equal(amxd_object_get_value(int8_t, object, "child_param", &status), 10);
1072  assert_int_equal(amxd_object_get_value(uint8_t, object, "child_param", &status), 10);
1073  assert_int_equal(amxd_object_get_value(int16_t, object, "child_param", &status), 10);
1074  assert_int_equal(amxd_object_get_value(uint16_t, object, "child_param", &status), 10);
1075 
1076  amxd_dm_clean(&dm);
1077 }
amxd_action.h
Ambiorix Data Model Default actions header file.
amxd_action_object_read
amxd_status_t amxd_action_object_read(amxd_object_t *const object, amxd_param_t *const param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
amxd_action_object_write
amxd_status_t amxd_action_object_write(amxd_object_t *const object, amxd_param_t *const param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
amxd_dm.h
Ambiorix Data Model API header file.
amxd_object.h
Ambiorix Data Model API header file.
amxd_object_add_action_cb
amxd_status_t amxd_object_add_action_cb(amxd_object_t *const object, const amxd_action_t reason, amxd_action_fn_t fn, void *priv)
Definition: amxd_object_action.c:73
amxd_object_list_params
amxd_status_t amxd_object_list_params(amxd_object_t *const object, amxc_var_t *const list, amxd_dm_access_t access)
Definition: amxd_action_object_list.c:353
amxd_object_get_params_filtered
amxd_status_t amxd_object_get_params_filtered(amxd_object_t *const object, amxc_var_t *const params, const char *filter, amxd_dm_access_t access)
Definition: amxd_action_object_read.c:362
amxd_object_get_param_count
uint32_t amxd_object_get_param_count(amxd_object_t *object, amxd_dm_access_t access)
Definition: amxd_object_parameter.c:312
amxd_parameter.h
amxd_param_unset_flag
void amxd_param_unset_flag(amxd_param_t *param, const char *flag)
Definition: amxd_parameter.c:422
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_param_has_flag
bool amxd_param_has_flag(const amxd_param_t *const param, const char *flag)
Definition: amxd_parameter.c:433
amxd_param_set_flag
void amxd_param_set_flag(amxd_param_t *param, const char *flag)
Definition: amxd_parameter.c:411
amxd_param_get_owner
amxd_object_t * amxd_param_get_owner(const amxd_param_t *const param)
Definition: amxd_parameter.c:311
amxd_param_delete
amxd_status_t amxd_param_delete(amxd_param_t **param)
Definition: amxd_action_param_destroy.c:109
amxd_pattr_template
@ amxd_pattr_template
Definition: amxd_types.h:355
amxd_pattr_private
@ amxd_pattr_private
Definition: amxd_types.h:357
amxd_pattr_instance
@ amxd_pattr_instance
Definition: amxd_types.h:356
action_object_write
@ action_object_write
Definition: amxd_types.h:118
action_object_read
@ action_object_read
Definition: amxd_types.h:117
action_object_list
@ action_object_list
Definition: amxd_types.h:120
amxd_status_t
enum _amxd_status amxd_status_t
amxd_status_ok
@ amxd_status_ok
Definition: amxd_types.h:78
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_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_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_action_object_list
amxd_status_t amxd_action_object_list(amxd_object_t *const object, amxd_param_t *const param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
Default object list action implementation.
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_child
amxd_object_t * amxd_object_get_child(const amxd_object_t *object, const char *name)
Get a child of the object.
Definition: amxd_object_hierarchy.c:299
amxd_object_findf
amxd_object_t * amxd_object_findf(amxd_object_t *object, const char *rel_path,...) __attribute__((format(printf
Find an object in the data model tree, starting from an object.
amxd_object_get
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_get_value
#define amxd_object_get_value(type, object, name, status)
Helper macro for getting a value.
Definition: amxd_object_parameter.h:100
amxd_object_set_params
amxd_status_t amxd_object_set_params(amxd_object_t *const object, amxc_var_t *const values)
Sets multiple parameter values in a data model object.
Definition: amxd_action_object_write.c:270
amxd_object_get_params
amxd_status_t amxd_object_get_params(amxd_object_t *const object, amxc_var_t *const params, amxd_dm_access_t access)
Gets all parameter values of an object.
Definition: amxd_action_object_read.c:314
amxd_object_set_param
amxd_status_t amxd_object_set_param(amxd_object_t *const object, const char *name, amxc_var_t *const value)
Sets a value for a parameter in a data model object.
Definition: amxd_object_parameter.c:221
amxd_object_set_value
#define amxd_object_set_value(type, object, name, value)
Helper macro for setting a value.
Definition: amxd_object_parameter.h:85
amxd_object_get_param_def
amxd_param_t * amxd_object_get_param_def(const amxd_object_t *const object, const char *name)
Gets a parameter definition from an object.
Definition: amxd_object_parameter.c:146
amxd_object_get_param_value
const amxc_var_t * amxd_object_get_param_value(const amxd_object_t *const object, const char *name)
Gets the variant in which the parameter value is stored.
Definition: amxd_object_parameter.c:301
amxd_object_get_param
amxd_status_t amxd_object_get_param(amxd_object_t *const object, const char *name, amxc_var_t *const value)
Gets a single parameter value.
Definition: amxd_object_parameter.c:252
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_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_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_dm
Definition: amxd_types.h:259
_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
_amxd_param_attr::instance
uint32_t instance
Definition: amxd_types.h:371
_amxd_parameter
Definition: amxd_types.h:386
_amxd_parameter::value
amxc_var_t value
Definition: amxd_types.h:390
_amxd_parameter::attr
amxd_param_attr_t attr
Definition: amxd_types.h:388
test_amxd_object.h
status
static amxd_status_t status
Definition: test_amxd_object_action.c:83
test_amxd_object_get_params_invalid_expr_filter
void test_amxd_object_get_params_invalid_expr_filter(UNUSED void **state)
Definition: test_amxd_object_parameter.c:962
test_amxd_object_list_parameters
void test_amxd_object_list_parameters(UNUSED void **state)
Definition: test_amxd_object_parameter.c:740
test_amxd_object_get_parameter_value_type
void test_amxd_object_get_parameter_value_type(UNUSED void **state)
Definition: test_amxd_object_parameter.c:282
test_amxd_object_get_parameters_value_with_cb
void test_amxd_object_get_parameters_value_with_cb(UNUSED void **state)
Definition: test_amxd_object_parameter.c:683
test_amxd_object_add_param_invalid_arg
void test_amxd_object_add_param_invalid_arg(UNUSED void **state)
Definition: test_amxd_object_parameter.c:154
dm
static amxd_dm_t dm
Definition: test_amxd_object_parameter.c:76
test_amxd_object_get_parameter
void test_amxd_object_get_parameter(UNUSED void **state)
Definition: test_amxd_object_parameter.c:171
test_amxd_object_get_params_filtered
void test_amxd_object_get_params_filtered(UNUSED void **state)
Definition: test_amxd_object_parameter.c:889
test_amxd_object_set_parameter_value
void test_amxd_object_set_parameter_value(UNUSED void **state)
Definition: test_amxd_object_parameter.c:429
test_amxd_object_set_parameter_value_with_cb
void test_amxd_object_set_parameter_value_with_cb(UNUSED void **state)
Definition: test_amxd_object_parameter.c:552
test_amxd_object_count_parameters
void test_amxd_object_count_parameters(UNUSED void **state)
Definition: test_amxd_object_parameter.c:837
test_amxd_object_set_parameters_value
void test_amxd_object_set_parameters_value(UNUSED void **state)
Definition: test_amxd_object_parameter.c:516
test_amxd_object_get_helpers
void test_amxd_object_get_helpers(UNUSED void **state)
Definition: test_amxd_object_parameter.c:1056
test_amxd_object_get_parameter_value_with_cb
void test_amxd_object_get_parameter_value_with_cb(UNUSED void **state)
Definition: test_amxd_object_parameter.c:372
test_amxd_object_set_parameter_value_type
void test_amxd_object_set_parameter_value_type(UNUSED void **state)
Definition: test_amxd_object_parameter.c:467
test_amxd_object_parameter_flags
void test_amxd_object_parameter_flags(UNUSED void **state)
Definition: test_amxd_object_parameter.c:996
test_amxd_object_count_parameters_with_cb
void test_amxd_object_count_parameters_with_cb(UNUSED void **state)
Definition: test_amxd_object_parameter.c:862
test_amxd_object_add_parameter
void test_amxd_object_add_parameter(UNUSED void **state)
Definition: test_amxd_object_parameter.c:111
test_amxd_object_set_parameters_value_with_cb
void test_amxd_object_set_parameters_value_with_cb(UNUSED void **state)
Definition: test_amxd_object_parameter.c:591
test_amxd_object_get_parameter_value
void test_amxd_object_get_parameter_value(UNUSED void **state)
Definition: test_amxd_object_parameter.c:233
test_amxd_object_get_parameters_value
void test_amxd_object_get_parameters_value(UNUSED void **state)
Definition: test_amxd_object_parameter.c:628
test_build_dm
static amxd_object_t * test_build_dm(void)
Definition: test_amxd_object_parameter.c:78
test_amxd_object_set
void test_amxd_object_set(UNUSED void **state)
Definition: test_amxd_object_parameter.c:1024