libamxd  6.4.1
Data Model Manager
test_amxd_object_hierarchy.c
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** SPDX-License-Identifier: BSD-2-Clause-Patent
4 **
5 ** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome
6 **
7 ** Redistribution and use in source and binary forms, with or without modification,
8 ** are permitted provided that the following conditions are met:
9 **
10 ** 1. Redistributions of source code must retain the above copyright notice,
11 ** this list of conditions and the following disclaimer.
12 **
13 ** 2. Redistributions in binary form must reproduce the above copyright notice,
14 ** this list of conditions and the following disclaimer in the documentation
15 ** and/or other materials provided with the distribution.
16 **
17 ** Subject to the terms and conditions of this license, each copyright holder
18 ** and contributor hereby grants to those receiving rights under this license
19 ** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
20 ** (except for failure to satisfy the conditions of this license) patent license
21 ** to make, have made, use, offer to sell, sell, import, and otherwise transfer
22 ** this software, where such license applies only to those patent claims, already
23 ** acquired or hereafter acquired, licensable by such copyright holder or contributor
24 ** that are necessarily infringed by:
25 **
26 ** (a) their Contribution(s) (the licensed copyrights of copyright holders and
27 ** non-copyrightable additions of contributors, in source or binary form) alone;
28 ** or
29 **
30 ** (b) combination of their Contribution(s) with the work of authorship to which
31 ** such Contribution(s) was added by such copyright holder or contributor, if,
32 ** at the time the Contribution is added, such addition causes such combination
33 ** to be necessarily infringed. The patent license shall not apply to any other
34 ** combinations which include the Contribution.
35 **
36 ** Except as expressly stated above, no rights or licenses from any copyright
37 ** holder or contributor is granted under this license, whether expressly, by
38 ** implication, estoppel or otherwise.
39 **
40 ** DISCLAIMER
41 **
42 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
43 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
46 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
48 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
49 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50 ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
51 ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
52 **
53 ****************************************************************************/
54 
55 #include <stdlib.h>
56 #include <stdio.h>
57 #include <stdarg.h>
58 #include <stddef.h>
59 #include <setjmp.h>
60 #include <fcntl.h>
61 #include <unistd.h>
62 #include <signal.h>
63 #include <cmocka.h>
64 
65 #include <amxc/amxc.h>
66 #include <amxp/amxp_signal.h>
67 #include <amxp/amxp_slot.h>
68 
69 #include <amxd/amxd_dm.h>
70 #include <amxd/amxd_object.h>
71 
72 #include "test_amxd_object.h"
73 
74 #include <amxc/amxc_macros.h>
75 static amxd_dm_t dm;
76 
77 void test_amxd_object_add_object(UNUSED void** state) {
78  amxd_object_t* parent = NULL;
79  amxd_object_t* child = NULL;
80  amxd_object_t* mib = NULL;
81 
82  assert_int_equal(amxd_dm_init(&dm), 0);
83 
84  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
85  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child"), 0);
86 
87  assert_int_equal(amxd_object_add_object(parent, child), 0);
88 
89  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
90  assert_int_not_equal(amxd_object_add_object(child, child), 0);
91  assert_int_not_equal(amxd_object_add_object(parent, parent), 0);
92 
93  assert_int_equal(amxd_object_add_object(parent, child), 0);
94  assert_int_not_equal(amxd_object_add_object(child, parent), 0);
95 
96  assert_int_equal(amxd_object_new(&mib, amxd_object_mib, "test-mib"), 0);
97  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child"), 0);
98  assert_int_equal(amxd_object_add_object(mib, child), 0);
99  assert_int_not_equal(amxd_object_add_object(parent, mib), 0);
100 
101  amxd_object_delete(&mib);
102 
103  amxd_dm_clean(&dm);
104 }
105 
106 void test_amxd_object_add_object_invalid_args(UNUSED void** state) {
107  amxd_object_t* parent = NULL;
108  amxd_object_t* child = NULL;
109  amxd_dm_t dm2;
110 
111  assert_int_equal(amxd_dm_init(&dm), 0);
112  assert_int_equal(amxd_dm_init(&dm2), 0);
113 
114  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
115  assert_int_equal(amxd_object_new(&child, amxd_object_mib, "child"), 0);
116  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
117 
118  assert_int_not_equal(amxd_object_add_object(parent, NULL), 0);
119  assert_int_not_equal(amxd_object_add_object(NULL, child), 0);
120  assert_int_not_equal(amxd_object_add_object(parent, child), 0);
121 
122  assert_int_not_equal(amxd_object_add_object(parent, amxd_dm_get_root(&dm2)), 0);
123 
124  amxd_object_delete(&child);
125 
126  amxd_dm_clean(&dm2);
127  amxd_dm_clean(&dm);
128 }
129 
130 void test_amxd_object_get_parent(UNUSED void** state) {
131  amxd_object_t* parent = NULL;
132  amxd_object_t* child = NULL;
133  amxd_object_t* instance = NULL;
134  amxd_object_t* mib = NULL;
135 
136  assert_int_equal(amxd_dm_init(&dm), 0);
137 
138  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
139  assert_int_equal(amxd_object_new(&child, amxd_object_template, "child"), 0);
140  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
141  assert_int_equal(amxd_object_add_object(parent, child), 0);
142  assert_int_equal(amxd_object_new_instance(&instance, child, "test", 0, NULL), 0);
143 
144  assert_ptr_equal(amxd_object_get_parent(instance), child);
145  assert_ptr_equal(amxd_object_get_parent(child), parent);
146  assert_ptr_equal(amxd_object_get_parent(parent), amxd_dm_get_root(&dm));
147  assert_ptr_equal(amxd_object_get_parent(amxd_dm_get_root(&dm)), NULL);
148  assert_ptr_equal(amxd_object_findf(instance, "^"), child);
149  assert_ptr_equal(amxd_object_findf(instance, "^.^"), parent);
150  assert_ptr_equal(amxd_object_findf(instance, "^.^.^"), amxd_dm_get_root(&dm));
151  assert_ptr_equal(amxd_object_findf(instance, "^.^.^.parent"), parent);
152  assert_ptr_equal(amxd_object_findf(instance, "^.^.^.^"), NULL);
153  assert_ptr_equal(amxd_object_findf(instance, "^.^.^.^.parent"), NULL);
154 
155  assert_int_equal(amxd_object_new(&mib, amxd_object_mib, "test-mib"), 0);
156  assert_ptr_equal(amxd_object_get_parent(mib), NULL);
157  assert_ptr_equal(amxd_object_get_parent(NULL), NULL);
158  amxd_object_delete(&mib);
159 
160  amxd_dm_clean(&dm);
161 }
162 
163 void test_amxd_object_get_root(UNUSED void** state) {
164  amxd_object_t* parent = NULL;
165  amxd_object_t* child = NULL;
166  amxd_object_t* instance = NULL;
167  amxd_object_t* mib = NULL;
168 
169  assert_int_equal(amxd_dm_init(&dm), 0);
170 
171  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
172  assert_int_equal(amxd_object_new(&child, amxd_object_template, "child"), 0);
173  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
174  assert_int_equal(amxd_object_add_object(parent, child), 0);
175  assert_int_equal(amxd_object_new_instance(&instance, child, "test", 0, NULL), 0);
176 
177  assert_ptr_equal(amxd_object_get_root(instance), amxd_dm_get_root(&dm));
178  assert_ptr_equal(amxd_object_get_root(child), amxd_dm_get_root(&dm));
179  assert_ptr_equal(amxd_object_get_root(parent), amxd_dm_get_root(&dm));
180  assert_ptr_equal(amxd_object_get_root(amxd_dm_get_root(&dm)), NULL);
181 
182  assert_int_equal(amxd_object_new(&mib, amxd_object_mib, "test-mib"), 0);
183  assert_ptr_equal(amxd_object_get_root(mib), NULL);
184  assert_ptr_equal(amxd_object_get_root(NULL), NULL);
185  amxd_object_delete(&mib);
186 
187  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
188  assert_int_equal(amxd_object_new(&child, amxd_object_template, "child"), 0);
189  assert_int_equal(amxd_object_add_object(parent, child), 0);
190  assert_ptr_equal(amxd_object_get_root(child), NULL);
191  assert_ptr_equal(amxd_object_get_root(parent), NULL);
192  amxd_object_delete(&parent);
193 
194  amxd_dm_clean(&dm);
195 }
196 
197 void test_amxd_object_get_dm(UNUSED void** state) {
198  amxd_object_t* parent = NULL;
199  amxd_object_t* child = NULL;
200  amxd_object_t* instance = NULL;
201  amxd_object_t* mib = NULL;
202 
203  assert_int_equal(amxd_dm_init(&dm), 0);
204 
205  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
206  assert_int_equal(amxd_object_new(&child, amxd_object_template, "child"), 0);
207  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
208  assert_int_equal(amxd_object_add_object(parent, child), 0);
209  assert_int_equal(amxd_object_new_instance(&instance, child, "test", 0, NULL), 0);
210 
211  assert_ptr_equal(amxd_object_get_dm(instance), &dm);
212  assert_ptr_equal(amxd_object_get_dm(child), &dm);
213  assert_ptr_equal(amxd_object_get_dm(parent), &dm);
214  assert_ptr_equal(amxd_object_get_dm(amxd_dm_get_root(&dm)), &dm);
215 
216  assert_int_equal(amxd_object_new(&mib, amxd_object_mib, "test-mib"), 0);
217  assert_ptr_equal(amxd_object_get_dm(mib), NULL);
218  assert_ptr_equal(amxd_object_get_dm(NULL), NULL);
219  amxd_object_delete(&mib);
220 
221  assert_int_equal(amxd_object_new(&child, amxd_object_template, "child"), 0);
222  assert_ptr_equal(amxd_object_get_dm(child), NULL);
223  amxd_object_delete(&child);
224 
225  amxd_dm_clean(&dm);
226 }
227 
228 void test_amxd_object_get_child(UNUSED void** state) {
229  amxd_object_t* parent = NULL;
230  amxd_object_t* child1 = NULL;
231  amxd_object_t* child2 = NULL;
232  amxd_object_t* instance = NULL;
233  amxd_object_t* mib = NULL;
234 
235  assert_int_equal(amxd_dm_init(&dm), 0);
236 
237  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
238  assert_int_equal(amxd_object_new(&child1, amxd_object_template, "child"), 0);
239  assert_int_equal(amxd_object_new(&child2, amxd_object_template, "sub-child"), 0);
240  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
241  assert_int_equal(amxd_object_add_object(parent, child1), 0);
242  assert_int_equal(amxd_object_add_object(child1, child2), 0);
243  assert_int_equal(amxd_object_new_instance(&instance, child1, "sub-child", 0, NULL), 0);
244 
245  assert_ptr_equal(amxd_object_get_child(parent, "child"), child1);
246  assert_ptr_equal(amxd_object_get_child(parent, "chi"), NULL);
247  assert_ptr_equal(amxd_object_get_child(parent, "invalid"), NULL);
248  assert_ptr_equal(amxd_object_get_child(child1, "test"), NULL);
249  assert_ptr_equal(amxd_object_get_child(child1, "sub-child"), child2);
250  assert_ptr_equal(amxd_object_get_child(amxd_dm_get_root(&dm), "parent"), parent);
251 
252  assert_int_equal(amxd_object_new(&mib, amxd_object_mib, "test-mib"), 0);
253  assert_int_equal(amxd_object_new(&child1, amxd_object_template, "mib-child"), 0);
254  assert_int_equal(amxd_object_add_object(mib, child1), 0);
255  assert_ptr_equal(amxd_object_get_child(mib, "mib-child"), child1);
256  amxd_object_delete(&mib);
257 
258  assert_ptr_equal(amxd_object_get_child(parent, ""), NULL);
259  assert_ptr_equal(amxd_object_get_child(parent, NULL), NULL);
260  assert_ptr_equal(amxd_object_get_child(NULL, "test"), NULL);
261 
262  amxd_dm_clean(&dm);
263 }
264 
265 void test_amxd_object_get_instance(UNUSED void** state) {
266  amxd_object_t* parent = NULL;
267  amxd_object_t* child1 = NULL;
268  amxd_object_t* child2 = NULL;
269  amxd_object_t* instance = NULL;
270  amxd_object_t* mib = NULL;
271 
272  assert_int_equal(amxd_dm_init(&dm), 0);
273 
274  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
275  assert_int_equal(amxd_object_new(&child1, amxd_object_template, "child"), 0);
276  assert_int_equal(amxd_object_new(&child2, amxd_object_template, "sub-child"), 0);
277  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
278  assert_int_equal(amxd_object_add_object(parent, child1), 0);
279  assert_int_equal(amxd_object_add_object(child1, child2), 0);
280  assert_int_equal(amxd_object_new_instance(&instance, child1, "sub-child", 0, NULL), 0);
281 
282  assert_ptr_equal(amxd_object_get_instance(parent, "child", 0), NULL);
283  assert_ptr_equal(amxd_object_get_instance(parent, "invalid", 0), NULL);
284  assert_ptr_equal(amxd_object_get_instance(child1, "test", 0), NULL);
285  assert_ptr_equal(amxd_object_get_instance(child1, "sub-child", 0), instance);
286  assert_ptr_equal(amxd_object_get_instance(child1, "sub", 0), NULL);
287  assert_ptr_equal(amxd_object_get_instance(child1, NULL, 1), instance);
288  assert_ptr_equal(amxd_object_get_instance(child1, "", 1), instance);
289  assert_ptr_equal(amxd_object_get_instance(amxd_dm_get_root(&dm), "parent", 0), NULL);
290 
291  assert_int_equal(amxd_object_new(&mib, amxd_object_mib, "test-mib"), 0);
292  assert_int_equal(amxd_object_new(&child1, amxd_object_template, "mib-child"), 0);
293  assert_int_equal(amxd_object_add_object(mib, child1), 0);
294  assert_ptr_equal(amxd_object_get_instance(mib, "mib-child", 0), NULL);
295  amxd_object_delete(&mib);
296 
297  assert_ptr_equal(amxd_object_get_instance(parent, "", 0), NULL);
298  assert_ptr_equal(amxd_object_get_instance(parent, NULL, 0), NULL);
299  assert_ptr_equal(amxd_object_get_instance(NULL, "test", 0), NULL);
300 
301  amxd_dm_clean(&dm);
302 }
303 
304 void test_amxd_object_get_instance_difficult_alias_name(UNUSED void** state) {
305  amxd_object_t* root = NULL;
306  amxd_object_t* template = NULL;
307  amxd_param_t* param = NULL;
308  const char* names[] = {
309  "normal_alias",
310  "another_normal_alias",
311  "we can use spaces",
312  "dot.in_the_middle",
313  "dot_at_the_end.",
314  "[brackets]",
315  "textbefore[brackets]",
316  "utf8snowman☃",
317  "quo'tes",
318  "injectionattack\" || \"a\" == \"b",
319  "injectionattack\" || \"a\" == \"b' || 'a' == 'b",
320  "diversion_brackets",
321  "[diversion_brackets]",
322  };
323 
324  assert_int_equal(amxd_dm_init(&dm), amxd_status_ok);
325  assert_int_equal(amxd_object_new(&root, amxd_object_singleton, "MyRoot"), amxd_status_ok);
326  assert_int_equal(amxd_object_new(&template, amxd_object_template, "MyTemplate"), amxd_status_ok);
327  assert_int_equal(amxd_param_new(&param, "Alias", AMXC_VAR_ID_CSTRING), 0);
328  amxd_param_set_attr(param, amxd_pattr_unique, true);
329  amxd_param_set_attr(param, amxd_pattr_key, true);
330  assert_int_equal(amxd_object_add_param(template, param), 0);
331  assert_int_equal(amxd_dm_add_root_object(&dm, root), amxd_status_ok);
332  assert_int_equal(amxd_object_add_object(root, template), amxd_status_ok);
333 
334  for(size_t i = 0; i < sizeof(names) / sizeof(names)[0]; i++) {
335  amxd_object_t* instance = NULL;
336  // GIVEN an instance object with a name that has tricky characters
337  const char* name = names[i];
338  amxd_object_t* retrieved_instance = NULL;
339  amxd_status_t status = amxd_object_new_instance(&instance, template, name, 0, NULL);
340  if(status == amxd_status_invalid_name) {
341  // If a difficult name is refused, then we don't have to be able to fetch by that name.
342  continue;
343  }
344  assert_int_equal(status, amxd_status_ok);
345  assert_non_null(instance);
346  printf("Instance name = %s\n", name);
347 
348  // WHEN retrieving that instance object by its name
349  retrieved_instance = amxd_object_get_instance(template, name, 0);
350 
351  // THEN the instance object was retrieved successfully
352  assert_non_null(retrieved_instance);
353  assert_ptr_equal(retrieved_instance, instance);
354  }
355 
356  for(size_t i = 0; i < sizeof(names) / sizeof(names)[0]; i++) {
357  // GIVEN an instance object with a name that has tricky characters
358  const char* name = names[i];
359  amxd_object_t* retrieved_instance = NULL;
360  printf("Instance name = %s\n", name);
361 
362  // WHEN retrieving that instance object by its name
363  retrieved_instance = amxd_object_get_instance(template, name, 0);
364 
365  // THEN the instance object was retrieved successfully
366  assert_non_null(retrieved_instance);
367  assert_string_equal(amxd_object_get_name(retrieved_instance, AMXD_OBJECT_NAMED), name);
368  }
369 
370  for(size_t i = 0; i < sizeof(names) / sizeof(names)[0]; i++) {
371  // GIVEN an instance object with a name that has tricky characters
372  const char* name = names[i];
373  amxd_object_t* retrieved_instance = NULL;
374  printf("Instance name = %s\n", name);
375 
376  // WHEN retrieving that instance object by its alias
377  // This triggers a memory leak in libamxp expression parser
378  // the problem needs to be investigated, when fixed this test can be enabled again
379  retrieved_instance = amxd_dm_findf(&dm, "MyRoot.MyTemplate.[%s].", name);
380  if(retrieved_instance == NULL) {
381  retrieved_instance = amxd_dm_findf(&dm, "MyRoot.MyTemplate.[Alias == '%s'].", name);
382  }
383  if(retrieved_instance == NULL) {
384  retrieved_instance = amxd_dm_findf(&dm, "MyRoot.MyTemplate.[Alias == \"%s\"].", name);
385  }
386  // THEN the instance object was retrieved successfully
387  assert_non_null(retrieved_instance);
388  assert_string_equal(amxd_object_get_name(retrieved_instance, AMXD_OBJECT_NAMED), name);
389  }
390 
391  amxd_dm_clean(&dm);
392 }
393 
394 void test_amxd_object_get(UNUSED void** state) {
395  amxd_object_t* parent = NULL;
396  amxd_object_t* child1 = NULL;
397  amxd_object_t* child2 = NULL;
398  amxd_object_t* instance = NULL;
399  amxd_object_t* mib = NULL;
400 
401  assert_int_equal(amxd_dm_init(&dm), 0);
402 
403  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
404  assert_int_equal(amxd_object_new(&child1, amxd_object_template, "child"), 0);
405  assert_int_equal(amxd_object_new(&child2, amxd_object_template, "sub-child"), 0);
406  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
407  assert_int_equal(amxd_object_add_object(parent, child1), 0);
408  assert_int_equal(amxd_object_add_object(child1, child2), 0);
409  assert_int_equal(amxd_object_new_instance(&instance, child1, "sub-child", 0, NULL), 0);
410 
411  assert_ptr_equal(amxd_object_get(parent, "child"), child1);
412  assert_ptr_equal(amxd_object_get(parent, "invalid"), NULL);
413  assert_ptr_equal(amxd_object_get(child1, "test"), NULL);
414  assert_ptr_equal(amxd_object_get(child1, "sub-child"), instance);
415  assert_ptr_equal(amxd_object_get(child1, "1"), instance);
416  assert_ptr_equal(amxd_object_get(amxd_dm_get_root(&dm), "parent"), parent);
417 
418  assert_int_equal(amxd_object_new(&mib, amxd_object_mib, "test-mib"), 0);
419  assert_int_equal(amxd_object_new(&child1, amxd_object_template, "mib-child"), 0);
420  assert_int_equal(amxd_object_add_object(mib, child1), 0);
421  assert_ptr_equal(amxd_object_get(mib, "mib-child"), child1);
422  amxd_object_delete(&mib);
423 
424  assert_ptr_equal(amxd_object_get(parent, ""), NULL);
425  assert_ptr_equal(amxd_object_get(parent, NULL), NULL);
426  assert_ptr_equal(amxd_object_get(NULL, "test"), NULL);
427 
428  amxd_dm_clean(&dm);
429 }
430 
431 void test_amxd_object_find(UNUSED void** state) {
432  amxd_object_t* parent = NULL;
433  amxd_object_t* child1 = NULL;
434  amxd_object_t* child2 = NULL;
435  amxd_object_t* instance = NULL;
436 
437  assert_int_equal(amxd_dm_init(&dm), 0);
438 
439  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
440  assert_int_equal(amxd_object_new(&child1, amxd_object_template, "child"), 0);
441  assert_int_equal(amxd_object_new(&child2, amxd_object_template, "sub-child"), 0);
442  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
443  assert_int_equal(amxd_object_add_object(parent, child1), 0);
444  assert_int_equal(amxd_object_add_object(child1, child2), 0);
445  assert_int_equal(amxd_object_new_instance(&instance, child1, "sub-child", 0, NULL), 0);
446 
447  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent"), parent);
448  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child"), child1);
449  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.sub-child"), child2);
450  assert_ptr_equal(amxd_object_findf(parent, "child.sub-child"), child2);
451  assert_ptr_equal(amxd_object_findf(parent, ".child.sub-child"), child2);
452  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.[sub-child]"), instance);
453  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.[1]"), instance);
454 
455  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.[2]"), NULL);
456  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.[not-existing]"), NULL);
457  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.not-existing"), NULL);
458 
459  assert_ptr_equal(amxd_object_findf(NULL, "parent.child.[2]"), NULL);
460  assert_ptr_equal(amxd_object_findf(parent, NULL), NULL);
461 
462  amxd_dm_clean(&dm);
463 }
464 
465 void test_amxd_object_findf(UNUSED void** state) {
466  amxd_object_t* parent = NULL;
467  amxd_object_t* child1 = NULL;
468  amxd_object_t* child2 = NULL;
469  amxd_object_t* instance = NULL;
470 
471  assert_int_equal(amxd_dm_init(&dm), 0);
472 
473  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
474  assert_int_equal(amxd_object_new(&child1, amxd_object_template, "child"), 0);
475  assert_int_equal(amxd_object_new(&child2, amxd_object_template, "sub-child"), 0);
476  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
477  assert_int_equal(amxd_object_add_object(parent, child1), 0);
478  assert_int_equal(amxd_object_add_object(child1, child2), 0);
479  assert_int_equal(amxd_object_new_instance(&instance, child1, "sub-child", 0, NULL), 0);
480 
481  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "%s", "parent"), parent);
482  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "%s.child", "parent"), child1);
483  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.%s", "sub-child"), child2);
484  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.[%s]", "sub-child"), instance);
485  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.[%d]", 1), instance);
486  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.%d", 1), instance);
487  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent..child..%d.", 1), instance);
488  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child..[%s].", "sub-child"), instance);
489  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "..."), amxd_dm_get_root(&dm));
490 
491  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.[%d]", 2), NULL);
492  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.[%s]", "not-existing"), NULL);
493  assert_ptr_equal(amxd_object_findf(amxd_dm_get_root(&dm), "parent.child.%s", "not-existing"), NULL);
494 
495  assert_ptr_equal(amxd_object_findf(NULL, "%s.child.[2]", "parent"), NULL);
496  assert_ptr_equal(amxd_object_findf(parent, NULL), NULL);
497 
498  amxd_dm_clean(&dm);
499 }
500 
501 void test_amxd_object_get_path(UNUSED void** state) {
502  char* path = NULL;
503  amxd_object_t* parent = NULL;
504  amxd_object_t* child1 = NULL;
505  amxd_object_t* child2 = NULL;
506  amxd_object_t* instance_child2 = NULL;
507  amxd_object_t* instance = NULL;
508  amxc_llist_t paths;
509 
510  amxc_llist_init(&paths);
511 
512  assert_int_equal(amxd_dm_init(&dm), 0);
513 
514  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
515  assert_int_equal(amxd_object_new(&child1, amxd_object_template, "child"), 0);
516  assert_int_equal(amxd_object_new(&child2, amxd_object_template, "sub-child"), 0);
517  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
518  assert_int_equal(amxd_object_add_object(parent, child1), 0);
519  assert_int_equal(amxd_object_add_object(child1, child2), 0);
520  assert_int_equal(amxd_object_new_instance(&instance, child1, "sub-child", 0, NULL), 0);
521 
522  path = amxd_object_get_path(parent, AMXD_OBJECT_NAMED);
523  assert_string_equal(path, "parent");
524  free(path);
525 
526  path = amxd_object_get_path(child1, AMXD_OBJECT_NAMED);
527  assert_string_equal(path, "parent.child");
528  free(path);
529 
530  path = amxd_object_get_rel_path(child1, parent, AMXD_OBJECT_NAMED);
531  assert_string_equal(path, "child");
532  free(path);
533 
534  path = amxd_object_get_rel_path(child1, child1, AMXD_OBJECT_NAMED);
535  assert_null(path);
536  free(path);
537 
538  path = amxd_object_get_path(child2, AMXD_OBJECT_NAMED);
539  assert_string_equal(path, "parent.child.sub-child");
540  free(path);
541 
542  path = amxd_object_get_path(child1, AMXD_OBJECT_SUPPORTED);
543  assert_string_equal(path, "parent.child.{i}");
544  free(path);
545 
546  path = amxd_object_get_path(child1, AMXD_OBJECT_SUPPORTED | AMXD_OBJECT_TERMINATE);
547  assert_string_equal(path, "parent.child.{i}.");
548  free(path);
549 
550  path = amxd_object_get_path(instance, AMXD_OBJECT_SUPPORTED | AMXD_OBJECT_TERMINATE);
551  assert_string_equal(path, "parent.child.{i}.");
552  free(path);
553 
554  path = amxd_object_get_path(child2, AMXD_OBJECT_NAMED | AMXD_OBJECT_TERMINATE);
555  assert_string_equal(path, "parent.child.sub-child.");
556  free(path);
557 
558  path = amxd_object_get_path(instance, AMXD_OBJECT_NAMED | AMXD_OBJECT_EXTENDED);
559  assert_string_equal(path, "parent.child.[sub-child]");
560  free(path);
561  path = amxd_object_get_path(instance, AMXD_OBJECT_INDEXED | AMXD_OBJECT_EXTENDED);
562  assert_string_equal(path, "parent.child.[1]");
563  free(path);
564 
565  path = amxd_object_get_path(instance, AMXD_OBJECT_NAMED);
566  assert_string_equal(path, "parent.child.sub-child");
567  free(path);
568  path = amxd_object_get_path(instance, AMXD_OBJECT_INDEXED);
569  assert_string_equal(path, "parent.child.1");
570  free(path);
571 
572  path = amxd_object_get_path(instance, AMXD_OBJECT_NAMED | AMXD_OBJECT_REGEXP);
573  assert_string_equal(path, "parent\\.child\\.sub-child");
574  free(path);
575  path = amxd_object_get_path(instance, AMXD_OBJECT_INDEXED | AMXD_OBJECT_REGEXP);
576  assert_string_equal(path, "parent\\.child\\.1");
577  free(path);
578 
579  path = amxd_object_get_path(instance, AMXD_OBJECT_NAMED | AMXD_OBJECT_EXTENDED | AMXD_OBJECT_REGEXP);
580  assert_string_equal(path, "parent\\.child\\.\\[sub-child\\]");
581  free(path);
582  path = amxd_object_get_path(instance, AMXD_OBJECT_INDEXED | AMXD_OBJECT_EXTENDED | AMXD_OBJECT_REGEXP);
583  assert_string_equal(path, "parent\\.child\\.\\[1\\]");
584  free(path);
585 
586  path = amxd_object_get_path(amxd_dm_get_root(&dm), AMXD_OBJECT_NAMED);
587  assert_ptr_equal(path, NULL);
588  free(path);
589 
590  instance_child2 = amxd_object_findf(instance, "sub-child");
591  assert_ptr_not_equal(instance_child2, NULL);
592  assert_ptr_not_equal(instance_child2, child2);
593 
594  path = amxd_object_get_path(instance_child2, AMXD_OBJECT_NAMED | AMXD_OBJECT_EXTENDED);
595  assert_string_equal(path, "parent.child.[sub-child].sub-child");
596  free(path);
597 
598  child2 = amxd_dm_findf(&dm, "parent.child.{i}.sub-child.");
599  assert_non_null(child2);
600  child2 = amxd_dm_findf(&dm, "parent.{i}.1.sub-child.");
601  assert_null(child2);
602 
603  child1 = amxd_dm_findf(&dm, "parent.child.");
604  assert_non_null(child1);
605  child2 = amxd_object_findf(child1, ".sub-child.");
606  assert_non_null(child2);
607  assert_int_equal(amxd_object_resolve_pathf(child1, &paths, ".sub2-child."), 0);
608 
609  assert_ptr_equal(amxd_object_get_path(NULL, 0), NULL);
610  amxc_llist_clean(&paths, amxc_string_list_it_free);
611 
612  amxd_dm_clean(&dm);
613 }
614 
615 static int pos = 0;
616 static char* expected_paths_down[] = {
617  NULL,
618  "parent",
619  "parent.child_1",
620  "parent.child_2",
621  "parent.child_2.child_2_1",
622  "parent.child_2.child_2_2",
623  "parent.child_2.[instance_1]",
624  "parent.child_2.[instance_1].child_2_1",
625  "parent.child_2.[instance_1].child_2_2",
626  "parent.child_2.[instance_2]",
627  "parent.child_2.[instance_2].child_2_1",
628  "parent.child_2.[instance_2].child_2_2",
629 };
630 
631 static void check_path_down(amxd_object_t* const object,
632  UNUSED int32_t depth,
633  void* priv) {
634  char* path = amxd_object_get_path(object, AMXD_OBJECT_NAMED | AMXD_OBJECT_EXTENDED);
635  assert_ptr_equal(priv, NULL);
636 
637  printf("%s == %s?\n", expected_paths_down[pos], path);
638 
639  if(path == NULL) {
640  assert_ptr_equal(expected_paths_down[pos], NULL);
641  } else {
642  assert_string_equal(path, expected_paths_down[pos]);
643  }
644  free(path);
645  pos++;
646 }
647 
648 static char* expected_paths_up[] = {
649  "parent.child_2.[instance_2]",
650  "parent.child_2",
651  "parent",
652  NULL,
653 };
654 
655 static void check_path_up(amxd_object_t* const object,
656  UNUSED int32_t depth,
657  void* priv) {
658  char* path = amxd_object_get_path(object, AMXD_OBJECT_NAMED | AMXD_OBJECT_EXTENDED);
659  assert_ptr_equal(priv, NULL);
660 
661  printf("%s == %s?\n", expected_paths_up[pos], path);
662 
663  if(path == NULL) {
664  assert_ptr_equal(expected_paths_up[pos], NULL);
665  } else {
666  assert_string_equal(path, expected_paths_up[pos]);
667  }
668  free(path);
669  pos++;
670 }
671 
672 void test_amxd_object_walk(UNUSED void** state) {
673  amxd_object_t* parent = NULL;
674  amxd_object_t* child = NULL;
675  amxd_object_t* instance = NULL;
676 
677  assert_int_equal(amxd_dm_init(&dm), 0);
678 
679  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
680  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
681 
682  printf("Current parent = %s\n", parent->name);
683  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child_1"), 0);
684  assert_int_equal(amxd_object_add_object(parent, child), 0);
685  assert_int_equal(amxd_object_new(&child, amxd_object_template, "child_2"), 0);
686  assert_int_equal(amxd_object_add_object(parent, child), 0);
687 
688  parent = child;
689  printf("Current parent = %s\n", parent->name);
690  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child_2_1"), 0);
691  assert_int_equal(amxd_object_add_object(parent, child), 0);
692  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child_2_2"), 0);
693  assert_int_equal(amxd_object_add_object(parent, child), 0);
694 
695  assert_int_equal(amxd_object_new_instance(&instance, parent, "instance_1", 0, NULL), 0);
696  assert_int_equal(amxd_object_new_instance(&instance, parent, "instance_2", 0, NULL), 0);
697 
698  pos = 0;
699  amxd_object_hierarchy_walk(amxd_dm_get_root(&dm), amxd_direction_down, NULL, check_path_down, INT32_MAX, NULL);
700  pos = 0;
701  amxd_object_hierarchy_walk(instance, amxd_direction_up, NULL, check_path_up, INT32_MAX, NULL);
702 
703  amxd_dm_clean(&dm);
704 }
705 
706 static char* expected_paths_down_filtered[] = {
707  NULL,
708  "parent",
709  "parent.child_1",
710  "parent.child_2",
711  "parent.child_2.instance_1",
712  "parent.child_2.instance_1.child_2_1",
713  "parent.child_2.instance_1.child_2_2",
714  "parent.child_2.instance_2",
715  "parent.child_2.instance_2.child_2_1",
716  "parent.child_2.instance_2.child_2_2",
717 };
718 
719 static bool no_tempate_child_objects(amxd_object_t* const object,
720  UNUSED int32_t depth,
721  void* priv) {
722  assert_ptr_equal(priv, NULL);
723  if((object->type == amxd_object_instance) ||
724  ( object->type == amxd_object_template) ||
725  ( object->type == amxd_object_root)) {
726  return true;
727  }
728 
729  if((amxd_object_get_parent(object) != NULL) &&
730  ( amxd_object_get_parent(object)->type != amxd_object_template)) {
731  return true;
732  }
733 
734  return false;
735 }
736 
737 static bool no_root_objects(amxd_object_t* const object,
738  UNUSED int32_t depth,
739  void* priv) {
740  assert_ptr_equal(priv, NULL);
741  return object->type != amxd_object_root;
742 }
743 
744 static void check_path_down_filtered(amxd_object_t* const object,
745  UNUSED int32_t depth,
746  void* priv) {
747  char* path = amxd_object_get_path(object, AMXD_OBJECT_NAMED);
748  assert_ptr_equal(priv, NULL);
749 
750  printf("%s == %s?\n", expected_paths_down_filtered[pos], path);
751 
752  if(path == NULL) {
753  assert_ptr_equal(expected_paths_down_filtered[pos], NULL);
754  } else {
755  assert_string_equal(path, expected_paths_down_filtered[pos]);
756  }
757  free(path);
758  pos++;
759 }
760 
761 void test_amxd_object_walk_filtered(UNUSED void** state) {
762  amxd_object_t* parent = NULL;
763  amxd_object_t* child = NULL;
764  amxd_object_t* instance = NULL;
765 
766  assert_int_equal(amxd_dm_init(&dm), 0);
767 
768  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
769  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
770 
771  printf("Current parent = %s\n", parent->name);
772  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child_1"), 0);
773  assert_int_equal(amxd_object_add_object(parent, child), 0);
774  assert_int_equal(amxd_object_new(&child, amxd_object_template, "child_2"), 0);
775  assert_int_equal(amxd_object_add_object(parent, child), 0);
776 
777  parent = child;
778  printf("Current parent = %s\n", parent->name);
779  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child_2_1"), 0);
780  assert_int_equal(amxd_object_add_object(parent, child), 0);
781  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child_2_2"), 0);
782  assert_int_equal(amxd_object_add_object(parent, child), 0);
783 
784  assert_int_equal(amxd_object_new_instance(&instance, parent, "instance_1", 0, NULL), 0);
785  assert_int_equal(amxd_object_new_instance(&instance, parent, "instance_2", 0, NULL), 0);
786 
787  pos = 0;
788  amxd_object_hierarchy_walk(amxd_dm_get_root(&dm), amxd_direction_down, no_tempate_child_objects, check_path_down_filtered, INT32_MAX, NULL);
789  pos = 0;
790  amxd_object_hierarchy_walk(instance, amxd_direction_up, no_root_objects, check_path_up, INT32_MAX, NULL);
791 
792  amxd_dm_clean(&dm);
793 }
794 
795 static char* expected_paths_down_depth[] = {
796  NULL,
797  "parent",
798 };
799 
800 static void check_path_down_depth(amxd_object_t* const object,
801  UNUSED int32_t depth,
802  void* priv) {
803  char* path = amxd_object_get_path(object, AMXD_OBJECT_NAMED);
804  assert_ptr_equal(priv, NULL);
805 
806  printf("%s == %s?\n", expected_paths_down_depth[pos], path);
807 
808  if(path == NULL) {
809  assert_ptr_equal(expected_paths_down_depth[pos], NULL);
810  } else {
811  assert_string_equal(path, expected_paths_down_depth[pos]);
812  }
813  free(path);
814  pos++;
815 }
816 
817 static char* expected_paths_up_depth[] = {
818  "parent.child_2.[2]",
819  "parent.child_2",
820 };
821 
822 static void check_path_up_depth(amxd_object_t* const object,
823  UNUSED int32_t depth,
824  void* priv) {
825  char* path = amxd_object_get_path(object, AMXD_OBJECT_INDEXED | AMXD_OBJECT_EXTENDED);
826  assert_ptr_equal(priv, NULL);
827 
828  printf("%s == %s?\n", expected_paths_up_depth[pos], path);
829 
830  if(path == NULL) {
831  assert_ptr_equal(expected_paths_up_depth[pos], NULL);
832  } else {
833  assert_string_equal(path, expected_paths_up_depth[pos]);
834  }
835  free(path);
836  pos++;
837 }
838 
839 void test_amxd_object_walk_depth(UNUSED void** state) {
840  amxd_object_t* parent = NULL;
841  amxd_object_t* child = NULL;
842  amxd_object_t* instance = NULL;
843 
844  assert_int_equal(amxd_dm_init(&dm), 0);
845 
846  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
847  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
848 
849  printf("Current parent = %s\n", parent->name);
850  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child_1"), 0);
851  assert_int_equal(amxd_object_add_object(parent, child), 0);
852  assert_int_equal(amxd_object_new(&child, amxd_object_template, "child_2"), 0);
853  assert_int_equal(amxd_object_add_object(parent, child), 0);
854 
855  parent = child;
856  printf("Current parent = %s\n", parent->name);
857  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child_2_1"), 0);
858  assert_int_equal(amxd_object_add_object(parent, child), 0);
859  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "child_2_2"), 0);
860  assert_int_equal(amxd_object_add_object(parent, child), 0);
861 
862  assert_int_equal(amxd_object_new_instance(&instance, parent, "instance_1", 0, NULL), 0);
863  assert_int_equal(amxd_object_new_instance(&instance, parent, "instance_2", 0, NULL), 0);
864 
865  pos = 0;
866  amxd_object_hierarchy_walk(amxd_dm_get_root(&dm), amxd_direction_down, NULL, check_path_down_depth, 1, NULL);
867  pos = 0;
868  amxd_object_hierarchy_walk(instance, amxd_direction_up, NULL, check_path_up_depth, 1, NULL);
869 
870  amxd_dm_clean(&dm);
871 }
872 
873 void test_amxd_object_walk_invalid_args(UNUSED void** state) {
874  amxd_object_hierarchy_walk(amxd_dm_get_root(&dm), amxd_direction_down, NULL, NULL, INT32_MAX, NULL);
875  amxd_object_hierarchy_walk(NULL, amxd_direction_down, NULL, check_path_up_depth, INT32_MAX, NULL);
876 }
877 
878 void test_amxd_object_is_child_of(UNUSED void** state) {
879  amxd_object_t* parent = NULL;
880  amxd_object_t* child1 = NULL;
881  amxd_object_t* child2 = NULL;
882  amxd_object_t* instance = NULL;
883 
884  assert_int_equal(amxd_dm_init(&dm), 0);
885 
886  assert_int_equal(amxd_object_new(&parent, amxd_object_singleton, "parent"), 0);
887  assert_int_equal(amxd_dm_add_root_object(&dm, parent), 0);
888 
889  assert_int_equal(amxd_object_new(&child1, amxd_object_singleton, "child_1"), 0);
890  assert_int_equal(amxd_object_add_object(parent, child1), 0);
891  assert_int_equal(amxd_object_new(&child2, amxd_object_template, "child_2"), 0);
892  assert_int_equal(amxd_object_add_object(parent, child2), 0);
893 
894  assert_int_equal(amxd_object_new_instance(&instance, child2, "instance_1", 0, NULL), 0);
895 
896  assert_true(amxd_object_is_child_of(instance, parent));
897  assert_true(amxd_object_is_child_of(child2, parent));
898  assert_true(amxd_object_is_child_of(child1, parent));
899  assert_false(amxd_object_is_child_of(child1, child2));
900  assert_false(amxd_object_is_child_of(child2, child1));
901  assert_false(amxd_object_is_child_of(parent, child2));
902  assert_true(amxd_object_is_child_of(instance, child2));
903  assert_false(amxd_object_is_child_of(instance, child1));
904 
905  assert_false(amxd_object_is_child_of(NULL, parent));
906  assert_false(amxd_object_is_child_of(child1, NULL));
907 
908  amxd_dm_clean(&dm);
909 }
amxd_dm.h
Ambiorix Data Model API header file.
amxd_dm_findf
amxd_object_t * amxd_dm_findf(amxd_dm_t *const dm, const char *abs_path,...) __attribute__((format(printf
amxd_object.h
Ambiorix Data Model API header file.
amxd_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_pattr_unique
@ amxd_pattr_unique
Definition: amxd_types.h:363
amxd_pattr_key
@ amxd_pattr_key
Definition: amxd_types.h:362
amxd_status_t
enum _amxd_status amxd_status_t
amxd_status_invalid_name
@ amxd_status_invalid_name
Definition: amxd_types.h:86
amxd_status_ok
@ amxd_status_ok
Definition: amxd_types.h:78
amxd_direction_down
@ amxd_direction_down
Definition: amxd_types.h:216
amxd_direction_up
@ amxd_direction_up
Definition: amxd_types.h:215
AMXD_OBJECT_SUPPORTED
#define AMXD_OBJECT_SUPPORTED
Path format flag - adds {i} as placeholder for an instance object.
Definition: amxd_object.h:226
AMXD_OBJECT_INDEXED
#define AMXD_OBJECT_INDEXED
Name and path format flag - use index for instance objects.
Definition: amxd_object.h:176
AMXD_OBJECT_REGEXP
#define AMXD_OBJECT_REGEXP
Path format flag - create path that can be used as regular expression.
Definition: amxd_object.h:202
AMXD_OBJECT_NAMED
#define AMXD_OBJECT_NAMED
Name and path format flag - default behavior, use name for instance objects.
Definition: amxd_object.h:164
AMXD_OBJECT_EXTENDED
#define AMXD_OBJECT_EXTENDED
Path format flag - set name or index of instrance objects between '[' and ']'.
Definition: amxd_object.h:188
AMXD_OBJECT_TERMINATE
#define AMXD_OBJECT_TERMINATE
Path format flag - when set the object path is terminated with a dot.
Definition: amxd_object.h:214
amxd_object_root
@ amxd_object_root
Definition: amxd_types.h:178
amxd_object_template
@ amxd_object_template
Definition: amxd_types.h:183
amxd_object_mib
@ amxd_object_mib
Definition: amxd_types.h:188
amxd_object_singleton
@ amxd_object_singleton
Definition: amxd_types.h:181
amxd_object_instance
@ amxd_object_instance
Definition: amxd_types.h:186
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_path
amxd_object_t amxd_status_t amxd_status_t char * amxd_object_get_path(const amxd_object_t *object, const uint32_t flags)
Get the full path of the object.
Definition: amxd_object_hierarchy.c:483
amxd_object_is_child_of
bool amxd_object_is_child_of(const amxd_object_t *const child, const amxd_object_t *const parent)
Checks if the child object is in the hierarchical tree of the parent object.
Definition: amxd_object_hierarchy.c:515
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_get_root
amxd_object_t * amxd_object_get_root(const amxd_object_t *const object)
Get the data model root.
Definition: amxd_object_hierarchy.c:244
amxd_object_get_rel_path
char * amxd_object_get_rel_path(const amxd_object_t *child, const amxd_object_t *parent, const uint32_t flags)
Get the relative path of the object.
Definition: amxd_object_hierarchy.c:496
amxd_object_hierarchy_walk
void amxd_object_hierarchy_walk(amxd_object_t *const object, const amxd_direction_t direction, amxd_object_filter_fn_t filter, amxd_object_cb_fn_t cb, int32_t depth, void *priv)
Iterates over all objects in the data model tree.
Definition: amxd_object_hierarchy.c:535
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_dm
amxd_dm_t * amxd_object_get_dm(const amxd_object_t *const object)
Get the data model.
Definition: amxd_object_hierarchy.c:265
amxd_object_resolve_pathf
amxd_object_t amxd_status_t amxd_object_resolve_pathf(amxd_object_t *object, amxc_llist_t *paths, const char *rel_path,...) __attribute__((format(printf
Resolves a search path into a list of matching object paths.
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_instance
amxd_object_t * amxd_object_get_instance(const amxd_object_t *object, const char *name, uint32_t index)
Get an instance of the template object.
Definition: amxd_object_hierarchy.c:327
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_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_object_get_name
const char * amxd_object_get_name(const amxd_object_t *const object, const uint32_t flags)
Get the name of the object (or index as a string for instance objects)
Definition: amxd_object.c:239
_amxd_dm
Definition: amxd_types.h:259
_amxd_object
Definition: amxd_types.h:229
_amxd_object::type
amxd_object_type_t type
Definition: amxd_types.h:236
_amxd_object::name
char * name
Definition: amxd_types.h:238
_amxd_parameter
Definition: amxd_types.h:386
test_amxd_object.h
status
static amxd_status_t status
Definition: test_amxd_object_action.c:83
test_amxd_object_walk_depth
void test_amxd_object_walk_depth(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:839
test_amxd_object_get_dm
void test_amxd_object_get_dm(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:197
pos
static int pos
Definition: test_amxd_object_hierarchy.c:615
check_path_up
static void check_path_up(amxd_object_t *const object, UNUSED int32_t depth, void *priv)
Definition: test_amxd_object_hierarchy.c:655
test_amxd_object_add_object_invalid_args
void test_amxd_object_add_object_invalid_args(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:106
test_amxd_object_add_object
void test_amxd_object_add_object(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:77
no_root_objects
static bool no_root_objects(amxd_object_t *const object, UNUSED int32_t depth, void *priv)
Definition: test_amxd_object_hierarchy.c:737
expected_paths_down_depth
static char * expected_paths_down_depth[]
Definition: test_amxd_object_hierarchy.c:795
check_path_down_filtered
static void check_path_down_filtered(amxd_object_t *const object, UNUSED int32_t depth, void *priv)
Definition: test_amxd_object_hierarchy.c:744
dm
static amxd_dm_t dm
Definition: test_amxd_object_hierarchy.c:75
test_amxd_object_walk_filtered
void test_amxd_object_walk_filtered(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:761
expected_paths_up_depth
static char * expected_paths_up_depth[]
Definition: test_amxd_object_hierarchy.c:817
check_path_down_depth
static void check_path_down_depth(amxd_object_t *const object, UNUSED int32_t depth, void *priv)
Definition: test_amxd_object_hierarchy.c:800
test_amxd_object_findf
void test_amxd_object_findf(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:465
expected_paths_up
static char * expected_paths_up[]
Definition: test_amxd_object_hierarchy.c:648
test_amxd_object_get
void test_amxd_object_get(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:394
test_amxd_object_walk
void test_amxd_object_walk(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:672
no_tempate_child_objects
static bool no_tempate_child_objects(amxd_object_t *const object, UNUSED int32_t depth, void *priv)
Definition: test_amxd_object_hierarchy.c:719
expected_paths_down_filtered
static char * expected_paths_down_filtered[]
Definition: test_amxd_object_hierarchy.c:706
check_path_up_depth
static void check_path_up_depth(amxd_object_t *const object, UNUSED int32_t depth, void *priv)
Definition: test_amxd_object_hierarchy.c:822
check_path_down
static void check_path_down(amxd_object_t *const object, UNUSED int32_t depth, void *priv)
Definition: test_amxd_object_hierarchy.c:631
test_amxd_object_find
void test_amxd_object_find(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:431
test_amxd_object_get_path
void test_amxd_object_get_path(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:501
test_amxd_object_is_child_of
void test_amxd_object_is_child_of(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:878
test_amxd_object_walk_invalid_args
void test_amxd_object_walk_invalid_args(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:873
test_amxd_object_get_root
void test_amxd_object_get_root(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:163
test_amxd_object_get_parent
void test_amxd_object_get_parent(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:130
test_amxd_object_get_child
void test_amxd_object_get_child(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:228
test_amxd_object_get_instance_difficult_alias_name
void test_amxd_object_get_instance_difficult_alias_name(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:304
test_amxd_object_get_instance
void test_amxd_object_get_instance(UNUSED void **state)
Definition: test_amxd_object_hierarchy.c:265
expected_paths_down
static char * expected_paths_down[]
Definition: test_amxd_object_hierarchy.c:616