libamxd  6.4.1
Data Model Manager
test_amxd_instance_counter.c
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** SPDX-License-Identifier: BSD-2-Clause-Patent
4 **
5 ** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome
6 **
7 ** Redistribution and use in source and binary forms, with or without modification,
8 ** are permitted provided that the following conditions are met:
9 **
10 ** 1. Redistributions of source code must retain the above copyright notice,
11 ** this list of conditions and the following disclaimer.
12 **
13 ** 2. Redistributions in binary form must reproduce the above copyright notice,
14 ** this list of conditions and the following disclaimer in the documentation
15 ** and/or other materials provided with the distribution.
16 **
17 ** Subject to the terms and conditions of this license, each copyright holder
18 ** and contributor hereby grants to those receiving rights under this license
19 ** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
20 ** (except for failure to satisfy the conditions of this license) patent license
21 ** to make, have made, use, offer to sell, sell, import, and otherwise transfer
22 ** this software, where such license applies only to those patent claims, already
23 ** acquired or hereafter acquired, licensable by such copyright holder or contributor
24 ** that are necessarily infringed by:
25 **
26 ** (a) their Contribution(s) (the licensed copyrights of copyright holders and
27 ** non-copyrightable additions of contributors, in source or binary form) alone;
28 ** or
29 **
30 ** (b) combination of their Contribution(s) with the work of authorship to which
31 ** such Contribution(s) was added by such copyright holder or contributor, if,
32 ** at the time the Contribution is added, such addition causes such combination
33 ** to be necessarily infringed. The patent license shall not apply to any other
34 ** combinations which include the Contribution.
35 **
36 ** Except as expressly stated above, no rights or licenses from any copyright
37 ** holder or contributor is granted under this license, whether expressly, by
38 ** implication, estoppel or otherwise.
39 **
40 ** DISCLAIMER
41 **
42 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
43 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
46 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
48 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
49 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50 ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
51 ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
52 **
53 ****************************************************************************/
54 
55 #include <stdlib.h>
56 #include <stdio.h>
57 #include <stdarg.h>
58 #include <stddef.h>
59 #include <setjmp.h>
60 #include <fcntl.h>
61 #include <unistd.h>
62 #include <signal.h>
63 #include <cmocka.h>
64 
65 #include <amxc/amxc.h>
66 #include <amxp/amxp_signal.h>
67 #include <amxp/amxp_slot.h>
68 #include <amxp/amxp_timer.h>
69 
70 #include <amxd/amxd_dm.h>
71 #include <amxd/amxd_object.h>
72 #include <amxd/amxd_object_event.h>
73 #include <amxd/amxd_transaction.h>
74 
75 #include "test_amxd_instance_counter.h"
76 
77 #include <amxc/amxc_macros.h>
78 static amxd_dm_t dm;
79 
80 static amxd_object_t* test_build_dm(void) {
81  amxd_object_t* object = NULL;
82  amxd_object_t* template = NULL;
83  amxd_object_t* subobject = NULL;
84 
85  assert_int_equal(amxd_dm_init(&dm), 0);
86 
87  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "MainObject1"), 0);
88  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
89  assert_int_equal(amxd_object_new(&template, amxd_object_template, "Template"), 0);
90  assert_int_equal(amxd_object_add_object(object, template), 0);
91 
92  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "MainObject2"), 0);
93  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
94  assert_int_equal(amxd_object_new(&subobject, amxd_object_singleton, "SubObject"), 0);
95  assert_int_equal(amxd_object_add_object(object, subobject), 0);
96 
97  assert_int_equal(amxd_object_new(&object, amxd_object_template, "MainObject3"), 0);
98  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
99 
100  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "MainObject4"), 0);
101  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
102  assert_int_equal(amxd_object_new(&template, amxd_object_template, "Template"), 0);
103  assert_int_equal(amxd_object_add_object(object, template), 0);
104  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "Child"), 0);
105  assert_int_equal(amxd_object_add_object(template, object), 0);
106  assert_int_equal(amxd_object_new(&template, amxd_object_template, "ChildTemplate"), 0);
107  assert_int_equal(amxd_object_add_object(object, template), 0);
108 
109  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "MainObject5"), 0);
110  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
111  assert_int_equal(amxd_object_new(&template, amxd_object_template, "Template"), 0);
112  assert_int_equal(amxd_object_add_object(object, template), 0);
113  assert_int_equal(amxd_object_new(&object, amxd_object_template, "Template"), 0);
114  assert_int_equal(amxd_object_add_object(template, object), 0);
115 
116  template = amxd_dm_findf(&dm, "MainObject1.Template");
117  return template;
118 }
119 
120 void test_amxd_set_counter(UNUSED void** state) {
121  amxd_object_t* template = NULL;
122  amxd_object_t* childtemplate = NULL;
123  amxd_object_t* main_obj = NULL;
124  amxd_param_t* counter = NULL;
125 
126  template = test_build_dm();
127  main_obj = amxd_object_get_parent(template);
128 
129  assert_int_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
130  counter = amxd_object_get_param_def(main_obj, "TemplateInstances");
131  assert_ptr_not_equal(counter, NULL);
132  assert_int_equal(amxd_param_get_type(counter), AMXC_VAR_ID_UINT32);
133  assert_true(amxd_param_is_attr_set(counter, amxd_pattr_read_only));
134  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstance", NULL), 0);
135 
136  template = amxd_dm_findf(&dm, "MainObject2.SubObject");
137  main_obj = amxd_object_get_parent(template);
138  assert_int_not_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
139  assert_ptr_equal(amxd_object_get_param_def(main_obj, "TemplateInstances"), NULL);
140 
141  template = amxd_dm_findf(&dm, "MainObject3");
142  main_obj = amxd_object_get_parent(template);
143  assert_int_not_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
144  assert_ptr_equal(amxd_object_get_param_def(main_obj, "TemplateInstances"), NULL);
145 
146  template = amxd_dm_findf(&dm, "MainObject4.Template.Child.ChildTemplate");
147  main_obj = amxd_object_get_parent(template);
148  assert_int_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
149  assert_ptr_not_equal(amxd_object_get_param_def(main_obj, "TemplateInstances"), NULL);
150 
151  template = amxd_dm_findf(&dm, "MainObject4.Template");
152  assert_int_equal(amxd_object_new_instance(&childtemplate, template, NULL, 0, NULL), 0);
153  main_obj = amxd_dm_findf(&dm, "MainObject4.Template.1.Child");
154  assert_ptr_not_equal(amxd_object_get_param_def(main_obj, "TemplateInstances"), NULL);
155 
156  amxd_dm_clean(&dm);
157 }
158 
159 void test_amxd_set_predefined_counter(UNUSED void** state) {
160  amxd_object_t* template = NULL;
161  amxd_object_t* parent = NULL;
162  amxd_param_t* counter = NULL;
163 
164  template = test_build_dm();
165  parent = amxd_object_get_parent(template);
166 
167  assert_int_equal(amxd_param_new(&counter, "MyCounter", AMXC_VAR_ID_UINT32), 0);
168  amxd_param_set_attr(counter, amxd_pattr_counter, true);
169  assert_int_equal(amxd_object_add_param(parent, counter), 0);
170 
171  assert_int_equal(amxd_object_set_counter(template, "MyCounter"), 0);
172 
173  amxd_dm_clean(&dm);
174 
175  template = test_build_dm();
176  parent = amxd_object_get_parent(template);
177 
178  assert_int_equal(amxd_param_new(&counter, "MyCounter", AMXC_VAR_ID_UINT32), 0);
179  assert_int_equal(amxd_object_add_param(parent, counter), 0);
180 
181  assert_int_not_equal(amxd_object_set_counter(template, "MyCounter"), 0);
182 
183  amxd_dm_clean(&dm);
184 }
185 
186 void test_amxd_set_counter_invalid(UNUSED void** state) {
187  amxd_object_t* template = NULL;
188  amxd_object_t* main_obj = NULL;
189  amxd_param_t* counter = NULL;
190 
191  template = test_build_dm();
192  main_obj = amxd_object_get_parent(template);
193 
194  assert_int_not_equal(amxd_object_set_counter(NULL, "TemplateInstances"), 0);
195  assert_int_not_equal(amxd_object_set_counter(template, NULL), 0);
196  assert_int_not_equal(amxd_object_set_counter(template, ""), 0);
197  assert_int_not_equal(amxd_object_set_counter(amxd_dm_get_root(&dm), "TestCounter"), 0);
198 
199  amxd_param_new(&counter, "MyCounter", AMXC_VAR_ID_UINT32);
200  amxd_object_add_param(main_obj, counter);
201  assert_int_not_equal(amxd_object_set_counter(template, "MyCounter"), 0);
202 
203  assert_int_equal(amxd_param_set_attr(counter, amxd_pattr_counter, true), 0);
204  assert_int_equal(amxd_object_set_counter(template, "MyCounter"), 0);
205 
206  amxd_dm_clean(&dm);
207 }
208 
209 void test_amxd_counter_has_correct_value(UNUSED void** state) {
210  amxd_object_t* template = NULL;
211  amxd_object_t* childtemplate = NULL;
212  amxd_object_t* main_obj = NULL;
213  amxd_object_t* instance = NULL;
214 
215  template = test_build_dm();
216  main_obj = amxd_object_get_parent(template);
217 
218  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
219  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
220  assert_int_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
221  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstances", NULL), 2);
222 
223  template = amxd_dm_findf(&dm, "MainObject4.Template.Child.ChildTemplate");
224  main_obj = amxd_object_get_parent(template);
225  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
226  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
227  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
228  assert_int_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
229  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstances", NULL), 3);
230 
231  template = amxd_dm_findf(&dm, "MainObject4.Template");
232  assert_int_equal(amxd_object_new_instance(&childtemplate, template, NULL, 0, NULL), 0);
233  main_obj = amxd_dm_findf(&dm, "MainObject4.Template.1.Child");
234  assert_ptr_not_equal(amxd_object_get_param_def(main_obj, "TemplateInstances"), NULL);
235  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstances", NULL), 0);
236 
237  amxd_dm_clean(&dm);
238 }
239 
240 void test_amxd_counter_changes(UNUSED void** state) {
241  amxd_object_t* template = NULL;
242  amxd_object_t* main_obj = NULL;
243  amxd_object_t* instance = NULL;
244  amxd_trans_t trans;
245 
246 
247  template = test_build_dm();
248  main_obj = amxd_object_get_parent(template);
249 
250  assert_int_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
251  amxd_trans_init(&trans);
252  amxd_trans_select_pathf(&trans, "MainObject1.Template");
253  amxd_trans_add_inst(&trans, 0, NULL);
254  amxd_trans_select_pathf(&trans, ".^");
255  amxd_trans_add_inst(&trans, 0, NULL);
256  amxd_trans_select_pathf(&trans, ".^");
257  amxd_trans_add_inst(&trans, 0, NULL);
258  amxd_trans_select_pathf(&trans, ".^");
259  amxd_trans_add_inst(&trans, 0, NULL);
260  assert_int_equal(amxd_trans_apply(&trans, &dm), 0);
261  amxd_trans_clean(&trans);
262 
263  while(amxp_signal_read() == 0) {
264  }
265 
266  assert_ptr_not_equal(amxd_object_get_param_def(main_obj, "TemplateInstances"), NULL);
267  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstances", NULL), 4);
268 
269  template = amxd_dm_findf(&dm, "MainObject4.Template.Child.ChildTemplate");
270  assert_int_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
271 
272  template = amxd_dm_findf(&dm, "MainObject4.Template");
273  assert_int_equal(amxd_object_new_instance(&instance, template, NULL, 0, NULL), 0);
274 
275  amxd_trans_init(&trans);
276  amxd_trans_select_pathf(&trans, "MainObject4.Template.1.Child.ChildTemplate");
277  amxd_trans_add_inst(&trans, 0, NULL);
278  amxd_trans_select_pathf(&trans, ".^");
279  amxd_trans_add_inst(&trans, 0, NULL);
280  amxd_trans_select_pathf(&trans, ".^");
281  amxd_trans_add_inst(&trans, 0, NULL);
282  amxd_trans_select_pathf(&trans, ".^");
283  amxd_trans_add_inst(&trans, 0, NULL);
284  assert_int_equal(amxd_trans_apply(&trans, &dm), 0);
285  amxd_trans_clean(&trans);
286 
287  while(amxp_signal_read() == 0) {
288  }
289 
290  main_obj = amxd_dm_findf(&dm, "MainObject4.Template.1.Child");
291  assert_ptr_not_equal(amxd_object_get_param_def(main_obj, "TemplateInstances"), NULL);
292  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstances", NULL), 4);
293 
294  amxd_trans_init(&trans);
295  amxd_trans_select_pathf(&trans, "MainObject4.Template.1.Child.ChildTemplate");
296  amxd_trans_del_inst(&trans, 1, NULL);
297  amxd_trans_del_inst(&trans, 2, NULL);
298  assert_int_equal(amxd_trans_apply(&trans, &dm), 0);
299  amxd_trans_clean(&trans);
300 
301  while(amxp_signal_read() == 0) {
302  }
303 
304  main_obj = amxd_dm_findf(&dm, "MainObject4.Template.1.Child");
305  assert_ptr_not_equal(amxd_object_get_param_def(main_obj, "TemplateInstances"), NULL);
306  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstances", NULL), 2);
307 
308 
309  amxd_dm_clean(&dm);
310 }
311 
312 void test_amxd_counter_is_removed_when_template_deleted(UNUSED void** state) {
313  amxd_object_t* template = NULL;
314  amxd_object_t* main_obj = NULL;
315 
316  template = test_build_dm();
317  main_obj = amxd_object_get_parent(template);
318 
319  assert_int_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
320  assert_ptr_not_equal(amxd_object_get_param_def(main_obj, "TemplateInstances"), NULL);
321  amxd_object_emit_signal(template, "dm:object-removed", NULL);
322  amxd_object_delete(&template);
323 
324  while(amxp_signal_read() == 0) {
325  }
326  assert_ptr_equal(amxd_object_get_param_def(main_obj, "TemplateInstances"), NULL);
327 
328  amxd_dm_clean(&dm);
329 }
330 
331 void test_amxd_counter_stops_counting_when_attribute_is_removed(UNUSED void** state) {
332  amxd_object_t* template = NULL;
333  amxd_object_t* main_obj = NULL;
334  amxd_param_t* param = NULL;
335  amxd_trans_t trans;
336 
337 
338  template = test_build_dm();
339  main_obj = amxd_object_get_parent(template);
340 
341  assert_int_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
342  amxd_trans_init(&trans);
343  amxd_trans_select_pathf(&trans, "MainObject1.Template");
344  amxd_trans_add_inst(&trans, 0, NULL);
345  amxd_trans_select_pathf(&trans, ".^");
346  amxd_trans_add_inst(&trans, 0, NULL);
347  amxd_trans_select_pathf(&trans, ".^");
348  amxd_trans_add_inst(&trans, 0, NULL);
349  amxd_trans_select_pathf(&trans, ".^");
350  amxd_trans_add_inst(&trans, 0, NULL);
351  assert_int_equal(amxd_trans_apply(&trans, &dm), 0);
352  amxd_trans_clean(&trans);
353 
354  while(amxp_signal_read() == 0) {
355  }
356 
357  param = amxd_object_get_param_def(main_obj, "TemplateInstances");
358  assert_ptr_not_equal(param, NULL);
359  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstances", NULL), 4);
360 
361  amxd_param_set_attr(param, amxd_pattr_counter, false);
362  amxd_trans_init(&trans);
363  amxd_trans_select_pathf(&trans, "MainObject1.Template");
364  amxd_trans_add_inst(&trans, 0, NULL);
365  amxd_trans_select_pathf(&trans, ".^");
366  amxd_trans_add_inst(&trans, 0, NULL);
367  amxd_trans_select_pathf(&trans, ".^");
368  amxd_trans_add_inst(&trans, 0, NULL);
369  amxd_trans_select_pathf(&trans, ".^");
370  amxd_trans_add_inst(&trans, 0, NULL);
371  assert_int_equal(amxd_trans_apply(&trans, &dm), 0);
372  amxd_trans_clean(&trans);
373 
374  while(amxp_signal_read() == 0) {
375  }
376 
377  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstances", NULL), 4);
378 
379  amxd_dm_clean(&dm);
380 }
381 
382 void test_amxd_counter_is_not_changed_on_any_event(UNUSED void** state) {
383  amxd_object_t* template = NULL;
384  amxd_object_t* main_obj = NULL;
385  amxd_param_t* param = NULL;
386  amxd_trans_t trans;
387 
388  template = test_build_dm();
389  main_obj = amxd_object_get_parent(template);
390 
391  assert_int_equal(amxd_object_set_counter(template, "TemplateInstances"), 0);
392  amxd_trans_init(&trans);
393  amxd_trans_select_pathf(&trans, "MainObject1.Template");
394  amxd_trans_add_inst(&trans, 0, NULL);
395  amxd_trans_select_pathf(&trans, ".^");
396  amxd_trans_add_inst(&trans, 0, NULL);
397  amxd_trans_select_pathf(&trans, ".^");
398  amxd_trans_add_inst(&trans, 0, NULL);
399  amxd_trans_select_pathf(&trans, ".^");
400  amxd_trans_add_inst(&trans, 0, NULL);
401  assert_int_equal(amxd_trans_apply(&trans, &dm), 0);
402  amxd_trans_clean(&trans);
403 
404  while(amxp_signal_read() == 0) {
405  }
406 
407  param = amxd_object_get_param_def(main_obj, "TemplateInstances");
408  assert_ptr_not_equal(param, NULL);
409  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstances", NULL), 4);
410 
411  amxd_object_emit_signal(template, "dm:instance-added", NULL);
412  amxd_object_emit_signal(template, "dm:instance-added", NULL);
413 
414  while(amxp_signal_read() == 0) {
415  }
416 
417  param = amxd_object_get_param_def(main_obj, "TemplateInstances");
418  assert_ptr_not_equal(param, NULL);
419  assert_int_equal(amxd_object_get_value(uint32_t, main_obj, "TemplateInstances", NULL), 4);
420 
421  amxd_dm_clean(&dm);
422 }
423 
424 void test_amxd_counter_has_correct_attributes(UNUSED void** state) {
425  amxd_object_t* sub_template = NULL;
426  amxd_object_t* top = NULL;
427  amxd_param_t* param = NULL;
428  amxd_trans_t trans;
429 
430  test_build_dm();
431  sub_template = amxd_dm_findf(&dm, "MainObject5.Template.Template");
432  top = amxd_dm_findf(&dm, "MainObject5.Template");
433 
434  assert_int_equal(amxd_object_set_counter(sub_template, "NumberOfInstances"), 0);
435  param = amxd_object_get_param_def(top, "NumberOfInstances");
436  amxd_param_set_attr(param, amxd_pattr_protected, true);
437  amxd_trans_init(&trans);
438  amxd_trans_select_pathf(&trans, "MainObject5.Template");
439  amxd_trans_add_inst(&trans, 0, NULL);
440  amxd_trans_select_pathf(&trans, ".Template");
441  amxd_trans_add_inst(&trans, 0, NULL);
442  assert_int_equal(amxd_trans_apply(&trans, &dm), 0);
443  amxd_trans_clean(&trans);
444 
445  while(amxp_signal_read() == 0) {
446  }
447 
448  top = amxd_dm_findf(&dm, "MainObject5.Template.1");
449  param = amxd_object_get_param_def(top, "NumberOfInstances");
450  assert_ptr_not_equal(param, NULL);
451  assert_true(amxd_param_is_attr_set(param, amxd_pattr_counter));
452  assert_true(amxd_param_is_attr_set(param, amxd_pattr_read_only));
453  assert_true(amxd_param_is_attr_set(param, amxd_pattr_instance));
454  assert_true(amxd_param_is_attr_set(param, amxd_pattr_protected));
455  assert_int_equal(amxd_object_get_value(uint32_t, top, "NumberOfInstances", NULL), 1);
456 
457 
458  amxd_dm_clean(&dm);
459 
460 }
amxd_dm.h
Ambiorix Data Model API header file.
amxd_dm_findf
amxd_object_t * amxd_dm_findf(amxd_dm_t *const dm, const char *abs_path,...) __attribute__((format(printf
amxd_object.h
Ambiorix Data Model API header file.
amxd_object_set_counter
amxd_status_t amxd_object_set_counter(amxd_object_t *const object, const char *name)
Definition: amxd_object.c:362
amxd_object_event.h
Ambiorix Data Model API header file.
amxd_param_is_attr_set
bool amxd_param_is_attr_set(const amxd_param_t *const param, const amxd_pattr_id_t attr)
Definition: amxd_parameter.c:397
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_get_type
static uint32_t amxd_param_get_type(const amxd_param_t *const param)
Definition: amxd_parameter.h:81
amxd_transaction.h
Ambiorix Data Model API header file.
amxd_pattr_instance
@ amxd_pattr_instance
Definition: amxd_types.h:356
amxd_pattr_protected
@ amxd_pattr_protected
Definition: amxd_types.h:364
amxd_pattr_read_only
@ amxd_pattr_read_only
Definition: amxd_types.h:358
amxd_pattr_counter
@ amxd_pattr_counter
Definition: amxd_types.h:361
amxd_object_template
@ amxd_object_template
Definition: amxd_types.h:183
amxd_object_singleton
@ amxd_object_singleton
Definition: amxd_types.h:181
amxd_dm_get_root
amxd_object_t * amxd_dm_get_root(amxd_dm_t *const dm)
Fetches the root object of the data model.
Definition: amxd_dm.c:456
amxd_dm_add_root_object
amxd_status_t amxd_dm_add_root_object(amxd_dm_t *const dm, amxd_object_t *const object)
Adds an object to the root of the data model.
Definition: amxd_dm.c:418
amxd_dm_init
amxd_status_t amxd_dm_init(amxd_dm_t *dm)
Initializes a data model structure.
Definition: amxd_dm.c:334
amxd_dm_clean
void amxd_dm_clean(amxd_dm_t *dm)
Cleans a data model structure.
Definition: amxd_dm.c:365
amxd_object_emit_signal
AMXD_INLINE void amxd_object_emit_signal(amxd_object_t *const object, const char *name, amxc_var_t *const data)
Emit an object signal/event.
Definition: amxd_object_event.h:142
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_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_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_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_trans_clean
void amxd_trans_clean(amxd_trans_t *const trans)
Cleans the transaction object.
Definition: amxd_transaction.c:529
amxd_trans_apply
amxd_status_t amxd_trans_apply(amxd_trans_t *const trans, amxd_dm_t *const dm)
Applies all previously added actions.
Definition: amxd_transaction.c:841
amxd_trans_add_inst
amxd_status_t amxd_trans_add_inst(amxd_trans_t *const trans, const uint32_t index, const char *name)
Adds an instance add action to a transaction.
Definition: amxd_transaction.c:738
amxd_trans_del_inst
amxd_status_t amxd_trans_del_inst(amxd_trans_t *const trans, const uint32_t index, const char *name)
Adds an instance delete action to a transaction.
Definition: amxd_transaction.c:776
amxd_trans_select_pathf
amxd_status_t amxd_trans_select_pathf(amxd_trans_t *const trans, const char *path,...) __attribute__((format(printf
Selects an object using a absolute or relative path.
amxd_trans_init
amxd_status_t amxd_trans_init(amxd_trans_t *const trans)
Initializes a transaction object.
Definition: amxd_transaction.c:507
_amxd_dm
Definition: amxd_types.h:259
_amxd_object
Definition: amxd_types.h:229
_amxd_parameter
Definition: amxd_types.h:386
_amxd_transaction
Definition: amxd_transaction.h:119
counter
static int counter
Definition: test_amxd_action_object_destroy.c:81
test_amxd_counter_stops_counting_when_attribute_is_removed
void test_amxd_counter_stops_counting_when_attribute_is_removed(UNUSED void **state)
Definition: test_amxd_instance_counter.c:331
test_amxd_counter_is_not_changed_on_any_event
void test_amxd_counter_is_not_changed_on_any_event(UNUSED void **state)
Definition: test_amxd_instance_counter.c:382
dm
static amxd_dm_t dm
Definition: test_amxd_instance_counter.c:78
test_amxd_counter_is_removed_when_template_deleted
void test_amxd_counter_is_removed_when_template_deleted(UNUSED void **state)
Definition: test_amxd_instance_counter.c:312
test_amxd_counter_has_correct_attributes
void test_amxd_counter_has_correct_attributes(UNUSED void **state)
Definition: test_amxd_instance_counter.c:424
test_amxd_counter_changes
void test_amxd_counter_changes(UNUSED void **state)
Definition: test_amxd_instance_counter.c:240
test_amxd_set_predefined_counter
void test_amxd_set_predefined_counter(UNUSED void **state)
Definition: test_amxd_instance_counter.c:159
test_amxd_set_counter_invalid
void test_amxd_set_counter_invalid(UNUSED void **state)
Definition: test_amxd_instance_counter.c:186
test_amxd_counter_has_correct_value
void test_amxd_counter_has_correct_value(UNUSED void **state)
Definition: test_amxd_instance_counter.c:209
test_amxd_set_counter
void test_amxd_set_counter(UNUSED void **state)
Definition: test_amxd_instance_counter.c:120
test_build_dm
static amxd_object_t * test_build_dm(void)
Definition: test_amxd_instance_counter.c:80
test_amxd_instance_counter.h