libamxd  6.4.1
Data Model Manager
test_amxd_mib.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 #include <string.h>
64 
65 #include <amxc/amxc.h>
66 #include <amxp/amxp_signal.h>
67 #include <amxp/amxp_slot.h>
68 
69 #include <amxd/amxd_common.h>
70 #include <amxd/amxd_dm.h>
71 #include <amxd/amxd_object.h>
72 #include <amxd/amxd_object_event.h>
73 #include <amxd/amxd_parameter.h>
74 #include <amxd/amxd_function.h>
75 #include <amxd/amxd_action.h>
76 #include <amxd/amxd_mib.h>
77 #include <amxd/amxd_transaction.h>
78 
79 #include <amxd_priv.h>
80 
81 #include "test_amxd_mib.h"
82 
83 #include <amxc/amxc_macros.h>
84 static amxd_dm_t dm;
85 
86 static void test_event_handler(const char* const sig_name,
87  UNUSED const amxc_var_t* const data,
88  void* const priv) {
89  int* counter = (int*) priv;
90 
91  if(strcmp(sig_name, "dm:mib-added") == 0) {
92  (*counter)++;
93  }
94 
95  if(strcmp(sig_name, "dm:mib-removed") == 0) {
96  (*counter)--;
97  }
98 }
99 
100 static amxd_status_t test_mib_cleanup_data(amxd_object_t* const object,
101  amxd_param_t* const param,
102  amxd_action_t reason,
103  UNUSED const amxc_var_t* const args,
104  UNUSED amxc_var_t* const retval,
105  void* priv) {
106  amxd_status_t status = amxd_status_ok;
107  amxc_var_t* data = (amxc_var_t*) priv;
108 
109  // action private data must not be removed when the action is used
110  // on derivced objects.
111  // only remove action data when the action is owned by the object or
112  // parameter on which the action is called.
113  if(reason == action_object_destroy) {
114  if(amxd_object_has_action_cb(object, reason, test_mib_cleanup_data)) {
115  amxc_var_delete(&data);
116  amxd_object_set_action_cb_data(object, reason, test_mib_cleanup_data, NULL);
117  }
118  } else {
119  if(amxd_param_has_action_cb(param, reason, test_mib_cleanup_data)) {
120  amxc_var_delete(&data);
121  amxd_param_set_action_cb_data(param, reason, test_mib_cleanup_data, NULL);
122  }
123  }
124 
125  return status;
126 }
127 
128 static amxd_object_t* test_build_dm(void) {
129  amxd_object_t* object = NULL;
130  amxd_param_t* param = NULL;
131  amxd_function_t* func = NULL;
132  amxd_object_t* templ_obj = NULL;
133 
134  assert_int_equal(amxd_dm_init(&dm), 0);
135 
136  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "TestObject"), 0);
137  assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
138 
139  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
140  assert_int_equal(amxd_object_add_param(object, param), 0);
141  assert_int_equal(amxd_param_new(&param, "Param2", AMXC_VAR_ID_BOOL), 0);
142  assert_int_equal(amxd_object_add_param(object, param), 0);
143  amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
144  assert_int_equal(amxd_object_add_function(object, func), 0);
145 
146  assert_int_equal(amxd_object_new(&templ_obj, amxd_object_template, "TemplObject"), 0);
147  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
148  assert_int_equal(amxd_object_add_param(templ_obj, param), 0);
149  amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
150  assert_int_equal(amxd_object_add_function(templ_obj, func), 0);
151  assert_int_equal(amxd_object_add_object(object, templ_obj), 0);
152 
153  return object;
154 }
155 
156 void test_can_define_and_store_mib(UNUSED void** state) {
157  amxd_object_t* mib = NULL;
158  amxd_object_t* fetch_mib = NULL;
159  amxd_object_t* object = NULL;
160  amxd_param_t* param = NULL;
161 
162  test_build_dm();
163 
164  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
165  assert_ptr_not_equal(mib, NULL);
166  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
167  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
168  assert_int_equal(amxd_object_add_param(mib, param), 0);
169  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
170  fetch_mib = amxd_dm_get_mib(&dm, "TestMib");
171  assert_ptr_not_equal(fetch_mib, NULL);
172  assert_ptr_equal(fetch_mib, mib);
173 
174  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
175  assert_int_not_equal(amxd_dm_store_mib(&dm, mib), 0);
176  amxd_mib_delete(&mib);
177 
178  assert_int_equal(amxd_mib_new(&mib, "TestMib2"), 0);
179  assert_ptr_not_equal(mib, NULL);
180  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
181 
182  assert_int_not_equal(amxd_dm_store_mib(NULL, mib), 0);
183  assert_int_not_equal(amxd_dm_store_mib(&dm, NULL), 0);
184  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "NotAMib"), 0);
185  assert_int_not_equal(amxd_dm_store_mib(&dm, object), 0);
186 
187  assert_ptr_equal(amxd_dm_get_mib(&dm, "NotStoredMib"), NULL);
188  assert_ptr_equal(amxd_dm_get_mib(NULL, "TestMib"), NULL);
189  assert_ptr_equal(amxd_dm_get_mib(&dm, ""), NULL);
190  assert_ptr_equal(amxd_dm_get_mib(&dm, NULL), NULL);
191 
192  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
193  fetch_mib = amxd_dm_get_mib(&dm, "TestMib2");
194  assert_ptr_not_equal(fetch_mib, NULL);
195  assert_ptr_equal(fetch_mib, mib);
196 
197  amxd_object_delete(&mib);
198  amxd_object_delete(&object);
199  amxd_dm_clean(&dm);
200 }
201 
202 static int count_objects(UNUSED amxd_object_t* templ, UNUSED amxd_object_t* obj, void* priv) {
203  int* count = (int*) priv;
204  *count = *count + 1;
205  return 1;
206 }
207 
208 void test_can_add_remove_mib_to_from_object(UNUSED void** state) {
209  amxd_object_t* mib = NULL;
210  amxd_object_t* object = NULL;
211  amxd_object_t* mibobject = NULL;
212  amxd_object_t* child = NULL;
213  amxd_param_t* param = NULL;
214  amxd_function_t* func = NULL;
215 
216  object = test_build_dm();
217 
218  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
219  assert_ptr_not_equal(mib, NULL);
220  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
221  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
222  assert_int_equal(amxd_object_add_param(mib, param), 0);
223  assert_int_equal(amxd_function_new(&func, "MibFunc1", AMXC_VAR_ID_NULL, NULL), 0);
224  assert_int_equal(amxd_object_add_function(mib, func), 0);
225  assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "MibObject"), 0);
226  assert_int_equal(amxd_object_add_object(mib, child), 0);
227 
228  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
229 
230  assert_int_equal(amxd_object_add_mib(object, "TestMib"), 0);
231  assert_true(amxd_object_has_mib(object, "TestMib"));
232  assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
233  assert_ptr_not_equal(amxd_object_get_function(object, "MibFunc1"), NULL);
234  assert_ptr_not_equal(amxd_object_get_child(object, "MibObject"), NULL);
235  assert_int_not_equal(amxd_object_add_mib(object, "TestMib"), 0);
236  assert_true(amxd_object_has_mib(object, "TestMib"));
237 
238  int count = 0;
239  amxd_object_for_all(object, "MibObject", count_objects, &count);
240  assert_int_equal(count, 1);
241 
242  assert_int_equal(amxd_object_remove_mib(object, "TestMib"), 0);
243  assert_false(amxd_object_has_mib(object, "TestMib"));
244  assert_ptr_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
245  assert_ptr_equal(amxd_object_get_function(object, "MibFunc1"), NULL);
246  assert_ptr_equal(amxd_object_get_child(object, "MibObject"), NULL);
247  assert_int_equal(amxd_object_remove_mib(object, "TestMib"), 0);
248 
249  assert_int_equal(amxd_object_add_mib(object, "TestMib"), 0);
250  assert_int_not_equal(amxd_object_add_mib(object, "TestMib"), 0);
251  func = amxd_object_get_function(object, "MibFunc1");
252  amxd_function_delete(&func);
253  param = amxd_object_get_param_def(object, "MibParam1");
254  amxd_param_delete(&param);
255  mibobject = amxd_object_get_child(object, "MibObject");
256  amxd_object_delete(&mibobject);
257  assert_int_equal(amxd_object_remove_mib(object, "TestMib"), 0);
258 
259  amxd_dm_clean(&dm);
260 }
261 
262 void test_can_add_remove_mib_to_from_object2(UNUSED void** state) {
263  amxd_object_t* mib = NULL;
264  amxd_object_t* object = NULL;
265  amxd_object_t* mibobject = NULL;
266  amxd_object_t* template = NULL;
267  amxd_object_t* template2 = NULL;
268  amxd_object_t* child = NULL;
269  amxd_object_t* child2 = NULL;
270  amxd_object_t* child3 = NULL;
271  amxd_param_t* param = NULL;
272  amxd_param_t* instParam = NULL;
273  amxd_function_t* func = NULL;
274 
275  object = test_build_dm();
276 
277  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
278  assert_ptr_not_equal(mib, NULL);
279  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
280  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
281  assert_int_equal(amxd_object_add_param(mib, param), 0);
282  assert_int_equal(amxd_function_new(&func, "MibFunc1", AMXC_VAR_ID_NULL, NULL), 0);
283  assert_int_equal(amxd_object_add_function(mib, func), 0);
284  assert_int_equal(amxd_object_new(&template, amxd_object_template, "MibObject"), 0);
285  assert_int_equal(amxd_object_add_object(mib, template), 0);
286  assert_int_equal(amxd_param_new(&instParam, "InstParam1", AMXC_VAR_ID_UINT32), 0);
287  assert_int_equal(amxd_object_add_param(template, instParam), 0);
288 
289  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
290 
291  assert_int_equal(amxd_object_new(&template2, amxd_object_template, "Templ"), 0);
292  assert_int_equal(amxd_object_add_object(object, template2), 0);
293  assert_int_equal(amxd_object_new_instance(&child2, amxd_object_get_child(object, "Templ"), "TestInst1", 0, NULL), 0);
294  assert_int_equal(amxd_object_new_instance(&child3, amxd_object_get_child(object, "Templ"), "TestInst2", 0, NULL), 0);
295 
296  assert_int_equal(amxd_object_add_mib(child2, "TestMib"), 0);
297  assert_true(amxd_object_has_mib(child2, "TestMib"));
298  assert_ptr_not_equal(amxd_object_get_param_def(child2, "MibParam1"), NULL);
299  assert_ptr_not_equal(amxd_object_get_function(child2, "MibFunc1"), NULL);
300  assert_ptr_not_equal(amxd_object_get_child(child2, "MibObject"), NULL);
301  assert_int_not_equal(amxd_object_add_mib(child2, "TestMib"), 0);
302  assert_true(amxd_object_has_mib(child2, "TestMib"));
303 
304  assert_int_equal(amxd_object_new_instance(&child, amxd_object_get_child(child2, "MibObject"), "MibInst1", 0, NULL), 0);
305 
306  int count = 0;
307  amxd_object_for_all(object, "Templ.*.MibObject.[InstParam1==0].", count_objects, &count);
308  assert_int_equal(count, 1);
309 
310  assert_int_equal(amxd_object_remove_mib(child2, "TestMib"), 0);
311  assert_false(amxd_object_has_mib(child2, "TestMib"));
312  assert_ptr_equal(amxd_object_get_param_def(child2, "MibParam1"), NULL);
313  assert_ptr_equal(amxd_object_get_function(child2, "MibFunc1"), NULL);
314  assert_ptr_equal(amxd_object_get_child(child2, "MibObject"), NULL);
315  assert_int_equal(amxd_object_remove_mib(child2, "TestMib"), 0);
316 
317  assert_int_equal(amxd_object_add_mib(child2, "TestMib"), 0);
318  assert_int_not_equal(amxd_object_add_mib(child2, "TestMib"), 0);
319  func = amxd_object_get_function(child2, "MibFunc1");
320  amxd_function_delete(&func);
321  param = amxd_object_get_param_def(child2, "MibParam1");
322  amxd_param_delete(&param);
323  mibobject = amxd_object_get_child(child2, "MibObject");
324  amxd_object_delete(&mibobject);
325  assert_int_equal(amxd_object_remove_mib(child2, "TestMib"), 0);
326 
327  amxd_dm_clean(&dm);
328 }
329 
330 void test_can_add_multiple_mibs(UNUSED void** state) {
331  amxd_object_t* mib = NULL;
332  amxd_object_t* object = NULL;
333  amxd_param_t* param = NULL;
334 
335  object = test_build_dm();
336 
337  assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
338  assert_ptr_not_equal(mib, NULL);
339  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
340  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
341  assert_int_equal(amxd_object_add_param(mib, param), 0);
342  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
343 
344  assert_int_equal(amxd_mib_new(&mib, "TestMib2"), 0);
345  assert_ptr_not_equal(mib, NULL);
346  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
347  assert_int_equal(amxd_param_new(&param, "MibParam2", AMXC_VAR_ID_CSTRING), 0);
348  assert_int_equal(amxd_object_add_param(mib, param), 0);
349  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
350 
351  assert_int_equal(amxd_object_add_mib(object, "TestMib1"), 0);
352  assert_int_equal(amxd_object_add_mib(object, "TestMib2"), 0);
353  assert_true(amxd_object_has_mib(object, "TestMib1"));
354  assert_true(amxd_object_has_mib(object, "TestMib2"));
355  assert_false(amxd_object_has_mib(object, "NotExisting"));
356  assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
357  assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam2"), NULL);
358 
359  assert_int_equal(amxd_object_remove_mib(object, "TestMib1"), 0);
360  assert_false(amxd_object_has_mib(object, "TestMib1"));
361  assert_true(amxd_object_has_mib(object, "TestMib2"));
362  assert_false(amxd_object_has_mib(object, "NotExisting"));
363  assert_ptr_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
364  assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam2"), NULL);
365 
366  assert_int_equal(amxd_object_add_mib(object, "TestMib1"), 0);
367  assert_true(amxd_object_has_mib(object, "TestMib1"));
368  assert_true(amxd_object_has_mib(object, "TestMib2"));
369  assert_false(amxd_object_has_mib(object, "NotExisting"));
370  assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
371  assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam2"), NULL);
372 
373  assert_int_equal(amxd_object_remove_mib(object, "TestMib2"), 0);
374  assert_true(amxd_object_has_mib(object, "TestMib1"));
375  assert_false(amxd_object_has_mib(object, "TestMib2"));
376  assert_false(amxd_object_has_mib(object, "NotExisting"));
377  assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
378  assert_ptr_equal(amxd_object_get_param_def(object, "MibParam2"), NULL);
379 
380  assert_int_not_equal(amxd_object_add_mib(object, "NotExisting"), 0);
381 
382  amxd_dm_clean(&dm);
383 }
384 
385 void test_add_mib_fails_when_duplicates(UNUSED void** state) {
386  amxd_object_t* mib = NULL;
387  amxd_object_t* object = NULL;
388  amxd_param_t* param = NULL;
389 
390  object = test_build_dm();
391 
392  assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
393  assert_ptr_not_equal(mib, NULL);
394  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
395  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_UINT32), 0);
396  assert_int_equal(amxd_object_add_param(mib, param), 0);
397  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
398 
399  assert_int_not_equal(amxd_object_add_mib(object, "TestMib1"), 0);
400  assert_false(amxd_object_has_mib(object, "TestMib1"));
401  assert_ptr_not_equal(amxd_object_get_param_def(object, "Param1"), NULL);
402 
403  amxd_dm_clean(&dm);
404 }
405 
406 void test_add_mib_fails_when_object_not_in_dm(UNUSED void** state) {
407  amxd_object_t* mib = NULL;
408  amxd_object_t* object = NULL;
409  amxd_param_t* param = NULL;
410 
411  assert_int_equal(amxd_dm_init(&dm), 0);
412 
413  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "TestObject"), 0);
414 
415  assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
416  assert_ptr_not_equal(mib, NULL);
417  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
418  assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_UINT32), 0);
419  assert_int_equal(amxd_object_add_param(mib, param), 0);
420  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
421 
422  assert_int_not_equal(amxd_object_add_mib(object, "TestMib1"), 0);
423  assert_false(amxd_object_has_mib(object, "TestMib1"));
424  assert_ptr_equal(amxd_object_get_param_def(object, "Param1"), NULL);
425 
426  amxd_object_delete(&object);
427  amxd_dm_clean(&dm);
428 }
429 
430 void test_functions_check_input_args(UNUSED void** state) {
431  amxd_object_t* mib = NULL;
432  amxd_object_t* object = NULL;
433 
434  assert_int_not_equal(amxd_mib_new(NULL, "TestMib1"), 0);
435  assert_int_not_equal(amxd_mib_new(&mib, ""), 0);
436  assert_int_not_equal(amxd_mib_new(&mib, "12345"), 0);
437  assert_int_not_equal(amxd_mib_new(&mib, "A.b,%t"), 0);
438  assert_int_not_equal(amxd_mib_new(&mib, NULL), 0);
439 
440  object = test_build_dm();
441  assert_false(amxd_object_has_mib(NULL, "TestMib1"));
442  assert_false(amxd_object_has_mib(object, ""));
443  assert_false(amxd_object_has_mib(object, NULL));
444 
445  assert_int_not_equal(amxd_object_add_mib(object, NULL), 0);
446  assert_int_not_equal(amxd_object_add_mib(object, ""), 0);
447  assert_int_not_equal(amxd_object_add_mib(NULL, ""), 0);
448 
449  assert_int_not_equal(amxd_object_remove_mib(object, NULL), 0);
450  assert_int_not_equal(amxd_object_remove_mib(object, ""), 0);
451  assert_int_not_equal(amxd_object_remove_mib(NULL, ""), 0);
452 
453  amxd_dm_clean(&dm);
454 }
455 
456 void test_get_root_of_mib_is_null(UNUSED void** state) {
457  amxd_object_t* mib = NULL;
458  amxd_object_t* mib_object = NULL;
459  amxd_param_t* param = NULL;
460 
461  test_build_dm();
462 
463  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
464  assert_ptr_not_equal(mib, NULL);
465  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
466  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
467  assert_int_equal(amxd_object_add_param(mib, param), 0);
468  assert_int_equal(amxd_object_new(&mib_object, amxd_object_singleton, "MibChild"), 0);
469  assert_int_equal(amxd_object_add_object(mib, mib_object), 0);
470  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
471 
472  assert_ptr_equal(amxd_object_get_root(mib), NULL);
473 
474  amxd_dm_clean(&dm);
475 }
476 
477 void test_set_attrs_on_mib_fails(UNUSED void** state) {
478  amxd_object_t* mib = NULL;
479  amxd_object_t* mib_object = NULL;
480  amxd_param_t* param = NULL;
481 
482  test_build_dm();
483 
484  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
485  assert_ptr_not_equal(mib, NULL);
486  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
487  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
488  assert_int_equal(amxd_object_add_param(mib, param), 0);
489  assert_int_equal(amxd_object_new(&mib_object, amxd_object_singleton, "MibChild"), 0);
490  assert_int_equal(amxd_object_add_object(mib, mib_object), 0);
491  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
492 
493  assert_int_not_equal(amxd_object_set_attr(mib, amxd_oattr_read_only, true), 0);
494  assert_int_equal(amxd_object_set_attr(mib_object, amxd_oattr_read_only, true), 0);
495 
496  amxd_dm_clean(&dm);
497 }
498 
499 void test_add_mib_to_object_fails_when_leads_to_function_duplicate(UNUSED void** state) {
500  amxd_object_t* mib = NULL;
501  amxd_object_t* mib_object = NULL;
502  amxd_object_t* object = NULL;
503  amxd_param_t* param = NULL;
504  amxd_function_t* func = NULL;
505 
506  object = test_build_dm();
507 
508  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
509  assert_ptr_not_equal(mib, NULL);
510  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
511  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
512  assert_int_equal(amxd_object_add_param(mib, param), 0);
513  assert_int_equal(amxd_object_new(&mib_object, amxd_object_singleton, "MibChild"), 0);
514  assert_int_equal(amxd_object_add_object(mib, mib_object), 0);
515  amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
516  assert_int_equal(amxd_object_add_function(mib, func), 0);
517  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
518 
519  assert_int_not_equal(amxd_object_add_mib(object, "TestMib"), 0);
520 
521  amxd_dm_clean(&dm);
522 }
523 
524 void test_add_mib_can_override_function(UNUSED void** state) {
525  amxd_object_t* mib = NULL;
526  amxd_object_t* object = NULL;
527  amxd_object_t* instance = NULL;
528  amxd_function_t* func = NULL;
529 
530  test_build_dm();
531 
532  object = amxd_dm_findf(&dm, "TestObject.TemplObject");
533  assert_ptr_not_equal(object, NULL);
534  assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
535 
536  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
537  assert_ptr_not_equal(mib, NULL);
538  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
539  amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
540  assert_int_equal(amxd_object_add_function(mib, func), 0);
541  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
542 
543  assert_int_equal(amxd_object_add_mib(instance, "TestMib"), 0);
544 
545  amxd_dm_clean(&dm);
546 }
547 
548 void test_add_mib_function_inherits_argument_attrs(UNUSED void** state) {
549  amxd_object_t* mib = NULL;
550  amxd_object_t* object = NULL;
551  amxd_object_t* instance = NULL;
552  amxd_function_t* func = NULL;
553  amxc_var_t def_val;
554 
555  amxc_var_init(&def_val);
556  amxc_var_set(bool, &def_val, true);
557 
558  test_build_dm();
559 
560  object = amxd_dm_findf(&dm, "TestObject.TemplObject");
561  assert_ptr_not_equal(object, NULL);
562  assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
563 
564  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
565  assert_ptr_not_equal(mib, NULL);
566  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
567  amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
568  assert_int_equal(amxd_function_new_arg(func, "parameters", AMXC_VAR_ID_BOOL, &def_val), 0);
569  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_in, true);
570  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_out, true);
571  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_mandatory, true);
572  amxd_function_arg_set_attr(func, "parameters", amxd_aattr_strict, true);
573  assert_int_equal(amxd_object_add_function(mib, func), 0);
574  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
575 
576  assert_int_equal(amxd_object_add_mib(instance, "TestMib"), 0);
577 
578  func = amxd_object_get_function(instance, "Func1");
579  assert_non_null(func);
580 
581  assert_true(amxd_function_arg_is_attr_set(func, "parameters", amxd_aattr_in));
582  assert_true(amxd_function_arg_is_attr_set(func, "parameters", amxd_aattr_out));
583  assert_true(amxd_function_arg_is_attr_set(func, "parameters", amxd_aattr_mandatory));
584  assert_true(amxd_function_arg_is_attr_set(func, "parameters", amxd_aattr_strict));
585 
586  amxd_dm_clean(&dm);
587 }
588 
589 
590 void test_add_mib_to_instance(UNUSED void** state) {
591  amxd_object_t* mib = NULL;
592  amxd_object_t* object = NULL;
593  amxd_object_t* instance = NULL;
594  amxd_param_t* param = NULL;
595  amxc_var_t* data = NULL;
596  amxd_function_t* func = NULL;
597 
598  amxc_var_new(&data);
599  amxc_var_set(uint32_t, data, 0);
600  test_build_dm();
601 
602  object = amxd_dm_findf(&dm, "TestObject.TemplObject");
603  assert_ptr_not_equal(object, NULL);
604  assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
605 
606  assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
607  assert_ptr_not_equal(mib, NULL);
608  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
609  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
610  assert_int_equal(amxd_object_add_param(mib, param), 0);
611  assert_int_equal(amxd_param_new(&param, "MibParamB", AMXC_VAR_ID_UINT32), 0);
612  assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_minimum, data), 0);
613  assert_int_equal(amxd_param_add_action_cb(param, action_param_destroy, test_mib_cleanup_data, data), 0);
614  assert_int_equal(amxd_object_add_param(mib, param), 0);
615  amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
616  amxd_function_set_attr(func, amxd_fattr_template, true);
617  assert_int_equal(amxd_object_add_function(mib, func), 0);
618  amxd_function_new(&func, "Func2", AMXC_VAR_ID_CSTRING, NULL);
619  amxd_function_set_attr(func, amxd_fattr_instance, true);
620  assert_int_equal(amxd_object_add_function(mib, func), 0);
621  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
622 
623  assert_int_equal(amxd_mib_new(&mib, "TestMib2"), 0);
624  assert_ptr_not_equal(mib, NULL);
625  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
626  assert_int_equal(amxd_param_new(&param, "MibParam2", AMXC_VAR_ID_UINT32), 0);
627  assert_int_equal(amxd_param_set_attr(param, amxd_pattr_template, true), 0);
628  assert_int_equal(amxd_object_add_param(mib, param), 0);
629  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
630 
631  assert_int_equal(amxd_object_add_mib(instance, "TestMib1"), 0);
632  param = amxd_object_get_param_def(instance, "MibParam1");
633  assert_non_null(param);
634 
635  assert_int_equal(amxd_object_add_mib(instance, "TestMib2"), 0);
636  param = amxd_object_get_param_def(instance, "MibParam2");
637  assert_null(param);
638 
639  amxd_dm_clean(&dm);
640 }
641 
642 void test_add_mib_using_transaction(UNUSED void** state) {
643  amxd_object_t* mib = NULL;
644  amxd_param_t* param = NULL;
645  amxd_object_t* object = NULL;
646  amxd_trans_t transaction;
647 
648  test_build_dm();
649 
650  assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
651  assert_ptr_not_equal(mib, NULL);
652  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
653  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
654  assert_int_equal(amxd_object_add_param(mib, param), 0);
655  assert_int_equal(amxd_param_new(&param, "MibParamB", AMXC_VAR_ID_UINT32), 0);
656  assert_int_equal(amxd_object_add_param(mib, param), 0);
657  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
658 
659  assert_int_equal(amxd_trans_init(&transaction), 0);
660  assert_int_equal(amxd_trans_select_pathf(&transaction, "TestObject.TemplObject."), 0);
661  assert_int_equal(amxd_trans_add_inst(&transaction, 0, NULL), 0);
662  assert_int_equal(amxd_trans_add_mib(&transaction, "TestMib1"), 0);
663  assert_int_equal(amxd_trans_set_value(cstring_t, &transaction, "Param1", "Test"), 0);
664  amxd_trans_dump(&transaction, STDOUT_FILENO, false);
665  assert_int_equal(amxd_trans_apply(&transaction, &dm), 0);
666 
667  object = amxd_dm_findf(&dm, "TestObject.TemplObject.1.");
668  assert_non_null(object);
669  param = amxd_object_get_param_def(object, "MibParam1");
670  assert_non_null(param);
671 
672  amxd_trans_clean(&transaction);
673 
674  assert_int_equal(amxd_trans_init(&transaction), 0);
675  amxd_trans_select_pathf(&transaction, "TestObject.TemplObject.1.");
676  assert_int_equal(amxd_trans_set_value(uint32_t, &transaction, "MibParam1", 102), 0);
677  assert_int_equal(amxd_trans_add_mib(&transaction, "TestMib1"), 0);
678  amxd_trans_dump(&transaction, STDOUT_FILENO, true);
679  assert_int_equal(amxd_trans_apply(&transaction, &dm), 0);
680 
681  amxd_trans_clean(&transaction);
682  amxd_dm_clean(&dm);
683 }
684 
685 void test_add_mib_to_template(UNUSED void** state) {
686  amxd_object_t* mib = NULL;
687  amxd_object_t* object = NULL;
688  amxd_object_t* instance = NULL;
689  amxd_param_t* param = NULL;
690  amxd_function_t* func = NULL;
691 
692  test_build_dm();
693 
694  object = amxd_dm_findf(&dm, "TestObject.TemplObject");
695  assert_ptr_not_equal(object, NULL);
696 
697  assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
698  assert_ptr_not_equal(mib, NULL);
699  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
700  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
701  assert_int_equal(amxd_object_add_param(mib, param), 0);
702 
703  amxd_function_new(&func, "Func2", AMXC_VAR_ID_CSTRING, NULL);
704  amxd_function_set_attr(func, amxd_fattr_instance, true);
705  assert_int_equal(amxd_object_add_function(mib, func), 0);
706  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
707 
708  assert_int_equal(amxd_object_add_mib(object, "TestMib1"), 0);
709  param = amxd_object_get_param_def(object, "MibParam1");
710  assert_non_null(param);
711 
712  assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
713  param = amxd_object_get_param_def(instance, "MibParam1");
714  assert_non_null(param);
715 
716  amxd_dm_clean(&dm);
717 }
718 
719 void test_mib_not_removed_when_not_added(UNUSED void** state) {
720  amxd_object_t* mib = NULL;
721  amxd_object_t* object = NULL;
722  amxd_param_t* param = NULL;
723 
724  object = test_build_dm();
725 
726  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
727  assert_ptr_not_equal(mib, NULL);
728  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
729  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
730  assert_int_equal(amxd_object_add_param(mib, param), 0);
731  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
732 
733  assert_int_equal(amxd_mib_new(&mib, "TestMib2"), 0);
734  assert_ptr_not_equal(mib, NULL);
735  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
736  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
737  assert_int_equal(amxd_object_add_param(mib, param), 0);
738  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
739 
740  assert_int_equal(amxd_object_add_mib(object, "TestMib"), 0);
741  assert_true(amxd_object_has_mib(object, "TestMib"));
742  assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
743 
744  assert_false(amxd_object_has_mib(object, "TestMib2"));
745  assert_int_equal(amxd_object_remove_mib(object, "TestMib2"), 0);
746  assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
747 
748  amxd_dm_clean(&dm);
749 }
750 
751 void test_mib_events(UNUSED void** state) {
752  amxd_object_t* mib = NULL;
753  amxd_object_t* object = NULL;
754  amxd_object_t* instance = NULL;
755  amxd_param_t* param = NULL;
756  int counter = 0;
757 
758  test_build_dm();
759 
760  amxp_slot_connect_filtered(&dm.sigmngr, "dm:mib-*", NULL, test_event_handler, &counter);
761 
762  object = amxd_dm_findf(&dm, "TestObject.TemplObject");
763  assert_ptr_not_equal(object, NULL);
764  assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
765 
766  assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
767  assert_ptr_not_equal(mib, NULL);
768  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
769  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
770  assert_int_equal(amxd_object_add_param(mib, param), 0);
771  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
772 
773  assert_int_equal(amxd_object_add_mib(instance, "TestMib1"), 0);
774  while(amxp_signal_read() == 0) {
775  }
776  assert_int_equal(counter, 1);
777 
778  assert_int_equal(amxd_object_remove_mib(instance, "TestMib1"), 0);
779  while(amxp_signal_read() == 0) {
780  }
781  assert_int_equal(counter, 0);
782 
783  amxd_dm_clean(&dm);
784 }
785 
786 void test_can_fetch_dm_from_mib(UNUSED void** state) {
787  amxd_object_t* mib = NULL;
788  amxd_param_t* param = NULL;
789  amxd_object_t* object = NULL;
790 
791  test_build_dm();
792 
793  assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
794  assert_ptr_not_equal(mib, NULL);
795  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
796  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
797  assert_int_equal(amxd_object_add_param(mib, param), 0);
798  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "MibSubObject"), 0);
799  assert_int_equal(amxd_object_add_object(mib, object), 0);
800 
801  assert_null(amxd_object_get_dm(mib));
802 
803  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
804 
805  assert_ptr_equal(&dm, amxd_object_get_dm(mib));
806  assert_ptr_equal(&dm, amxd_object_get_dm(object));
807 
808  amxd_dm_clean(&dm);
809 }
810 
811 void test_can_declare_event_in_mib(UNUSED void** state) {
812  amxd_object_t* mib = NULL;
813  amxd_param_t* param = NULL;
814  amxd_object_t* object = NULL;
815  amxd_object_t* instance = NULL;
816  amxc_var_t* event = NULL;
817 
818  test_build_dm();
819 
820  object = amxd_dm_findf(&dm, "TestObject.TemplObject");
821  assert_ptr_not_equal(object, NULL);
822  assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
823 
824  assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
825  assert_ptr_not_equal(mib, NULL);
826  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
827  assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
828  assert_int_equal(amxd_object_add_param(mib, param), 0);
829  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "MibSubObject"), 0);
830  assert_int_equal(amxd_object_add_object(mib, object), 0);
831 
832  assert_null(amxd_object_get_dm(mib));
833 
834  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
835  assert_int_equal(amxd_object_add_event_ext(mib, "Event1!", NULL), 0);
836  assert_int_equal(amxd_object_add_event_ext(object, "Event2!", NULL), 0);
837 
838  assert_int_equal(amxd_object_add_mib(instance, "TestMib1"), 0);
839  event = amxd_object_new_event_data(instance, "Event1!");
840  assert_non_null(event);
841  free(event);
842  object = amxd_object_findf(instance, "MibSubObject");
843  assert_non_null(object);
844  event = amxd_object_new_event_data(object, "Event2!");
845  assert_non_null(event);
846  free(event);
847 
848  assert_int_equal(amxd_object_remove_mib(instance, "TestMib1"), 0);
849  event = amxd_object_new_event_data(instance, "Event1!");
850  assert_null(event);
851 
852  amxd_dm_clean(&dm);
853 }
854 
855 void test_add_mib_object_can_be_read_using_name_path(UNUSED void** state) {
856  amxd_object_t* mib = NULL;
857  amxd_object_t* object = NULL;
858  amxd_param_t* param = NULL;
859  amxd_object_t* instance = NULL;
860  amxc_var_t ret;
861  amxc_var_t args;
862 
863  amxc_var_init(&ret);
864  amxc_var_init(&args);
865 
866  object = test_build_dm();
867 
868  assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
869  assert_ptr_not_equal(mib, NULL);
870  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
871  assert_int_equal(amxd_param_new(&param, "MParam1", AMXC_VAR_ID_UINT32), 0);
872  assert_int_equal(amxd_object_add_param(mib, param), 0);
873  assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "TestObj"), 0);
874  assert_int_equal(amxd_param_new(&param, "MParam1", AMXC_VAR_ID_UINT32), 0);
875  assert_int_equal(amxd_object_add_param(object, param), 0);
876  assert_int_equal(amxd_object_add_object(mib, object), 0);
877  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
878 
879  object = amxd_dm_findf(&dm, "TestObject.TemplObject");
880  assert_ptr_not_equal(object, NULL);
881  assert_int_equal(amxd_object_new_instance(&instance, object, "TestInstance", 0, NULL), 0);
882  assert_int_equal(amxd_object_add_mib(instance, "TestMib1"), 0);
883  assert_true(amxd_object_has_mib(instance, "TestMib1"));
884  assert_ptr_not_equal(amxd_object_get_param_def(object, "Param1"), NULL);
885 
886  object = amxd_dm_findf(&dm, "TestObject.");
887  amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
888  amxc_var_add_key(cstring_t, &args, "rel_path", "TemplObject.TestInstance.TestObj.");
889  assert_int_equal(amxd_object_invoke_function(object, "_get", &args, &ret), 0);
890 
891  amxd_dm_clean(&dm);
892 
893  amxc_var_clean(&ret);
894  amxc_var_clean(&args);
895 }
896 
897 void test_object_get_mibs(UNUSED void** state) {
898  amxd_object_t* mib = NULL;
899  amxd_object_t* object = NULL;
900  char* mib_names = NULL;
901 
902  object = test_build_dm();
903 
904  assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
905  assert_ptr_not_equal(mib, NULL);
906  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
907  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
908 
909  assert_int_equal(amxd_mib_new(&mib, "TestMib2"), 0);
910  assert_ptr_not_equal(mib, NULL);
911  assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
912  assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
913 
914  mib_names = amxd_object_get_mibs(object);
915  assert_null(mib_names);
916 
917  assert_int_equal(amxd_object_add_mib(object, "TestMib"), 0);
918  assert_true(amxd_object_has_mib(object, "TestMib"));
919 
920  mib_names = amxd_object_get_mibs(object);
921  assert_non_null(mib_names);
922  assert_string_equal(mib_names, "TestMib");
923  free(mib_names);
924 
925  assert_int_equal(amxd_object_add_mib(object, "TestMib2"), 0);
926  assert_true(amxd_object_has_mib(object, "TestMib2"));
927 
928  mib_names = amxd_object_get_mibs(object);
929  assert_non_null(mib_names);
930  assert_string_equal(mib_names, "TestMib TestMib2");
931  free(mib_names);
932 
933  assert_int_equal(amxd_object_remove_mib(object, "TestMib"), 0);
934  assert_false(amxd_object_has_mib(object, "TestMib"));
935 
936  mib_names = amxd_object_get_mibs(object);
937  assert_non_null(mib_names);
938  assert_string_equal(mib_names, "TestMib2");
939  free(mib_names);
940 
941  assert_int_equal(amxd_object_remove_mib(object, "TestMib2"), 0);
942  assert_false(amxd_object_has_mib(object, "TestMib2"));
943 
944  mib_names = amxd_object_get_mibs(object);
945  assert_null(mib_names);
946 
947  amxd_dm_clean(&dm);
948 }
949 
950 
amxd_action.h
Ambiorix Data Model Default actions header file.
amxd_common.h
amxd_dm.h
Ambiorix Data Model API header file.
amxd_dm_store_mib
amxd_status_t amxd_dm_store_mib(amxd_dm_t *const dm, amxd_object_t *const object)
Definition: amxd_dm.c:378
amxd_dm_get_mib
amxd_object_t * amxd_dm_get_mib(amxd_dm_t *const dm, const char *name)
Definition: amxd_dm.c:397
amxd_dm_findf
amxd_object_t * amxd_dm_findf(amxd_dm_t *const dm, const char *abs_path,...) __attribute__((format(printf
amxd_function.h
Ambiorix Data Model RPC methods API header file.
amxd_mib.h
amxd_mib_delete
void amxd_mib_delete(amxd_object_t **object)
Definition: amxd_object_mib.c:314
amxd_mib_new
static amxd_status_t amxd_mib_new(amxd_object_t **object, const char *name)
Definition: amxd_mib.h:67
amxd_object.h
Ambiorix Data Model API header file.
amxd_object_has_action_cb
bool amxd_object_has_action_cb(amxd_object_t *const object, const amxd_action_t reason, amxd_action_fn_t fn)
Definition: amxd_object_action.c:139
amxd_object_set_action_cb_data
void amxd_object_set_action_cb_data(amxd_object_t *const object, const amxd_action_t reason, amxd_action_fn_t fn, void *data)
Definition: amxd_object_action.c:202
amxd_object_event.h
Ambiorix Data Model API header file.
amxd_parameter.h
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_delete
amxd_status_t amxd_param_delete(amxd_param_t **param)
Definition: amxd_action_param_destroy.c:109
amxd_param_has_action_cb
bool amxd_param_has_action_cb(amxd_param_t *const param, const amxd_action_t reason, amxd_action_fn_t fn)
Definition: amxd_parameter_action.c:135
amxd_param_set_action_cb_data
void amxd_param_set_action_cb_data(amxd_param_t *const param, const amxd_action_t reason, amxd_action_fn_t fn, void *data)
Definition: amxd_parameter_action.c:202
amxd_param_add_action_cb
amxd_status_t amxd_param_add_action_cb(amxd_param_t *const param, const amxd_action_t reason, amxd_action_fn_t fn, void *priv)
Definition: amxd_parameter_action.c:67
amxd_priv.h
amxd_transaction.h
Ambiorix Data Model API header file.
amxd_trans_add_mib
amxd_status_t amxd_trans_add_mib(amxd_trans_t *const trans, const char *mib_name)
Definition: amxd_transaction.c:815
amxd_pattr_template
@ amxd_pattr_template
Definition: amxd_types.h:355
action_param_destroy
@ action_param_destroy
Definition: amxd_types.h:116
action_object_destroy
@ action_object_destroy
Definition: amxd_types.h:125
action_param_validate
@ action_param_validate
Definition: amxd_types.h:114
amxd_action_t
enum _amxd_action amxd_action_t
amxd_status_t
enum _amxd_status amxd_status_t
amxd_status_ok
@ amxd_status_ok
Definition: amxd_types.h:78
amxd_fattr_template
@ amxd_fattr_template
Definition: amxd_types.h:311
amxd_fattr_instance
@ amxd_fattr_instance
Definition: amxd_types.h:312
amxd_aattr_strict
@ amxd_aattr_strict
Definition: amxd_types.h:286
amxd_aattr_in
@ amxd_aattr_in
Definition: amxd_types.h:283
amxd_aattr_mandatory
@ amxd_aattr_mandatory
Definition: amxd_types.h:285
amxd_aattr_out
@ amxd_aattr_out
Definition: amxd_types.h:284
amxd_oattr_read_only
@ amxd_oattr_read_only
Definition: amxd_types.h:199
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_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_add_event_ext
amxd_status_t amxd_object_add_event_ext(amxd_object_t *const object, const char *event_name, amxc_var_t *event_data)
Adds an event definition to the object.
Definition: amxd_object_event.c:376
amxd_object_new_event_data
amxc_var_t * amxd_object_new_event_data(const amxd_object_t *object, const char *event_name)
Allocates a variant that contains the predefined event data.
Definition: amxd_object_event.c:424
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_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_for_all
void amxd_object_for_all(amxd_object_t *object, const char *rel_spath, amxd_mobject_cb_t fn, void *priv)
Executes a task for all matching objects in an object tree.
Definition: amxd_object_hierarchy.c:554
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_has_mib
bool amxd_object_has_mib(amxd_object_t *object, const char *mib_name)
Checks if a mib has been added to a data model object.
Definition: amxd_object_mib.c:230
amxd_object_get_mibs
char * amxd_object_get_mibs(amxd_object_t *object)
Get the names of all mibs attached to this object.
Definition: amxd_object_mib.c:205
amxd_object_add_mib
amxd_status_t amxd_object_add_mib(amxd_object_t *const object, const char *mib_name)
Adds a mib to an object.
Definition: amxd_object_mib.c:254
amxd_object_remove_mib
amxd_status_t amxd_object_remove_mib(amxd_object_t *const object, const char *mib_name)
Removes a mib from an object.
Definition: amxd_object_mib.c:290
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_add_function
amxd_status_t amxd_object_add_function(amxd_object_t *const object, amxd_function_t *const func)
Adds an RPC method definition to the object definition.
Definition: amxd_object_function.c:140
amxd_object_get_function
amxd_function_t * amxd_object_get_function(const amxd_object_t *const object, const char *name)
Get the definition of a RPC method from an object.
Definition: amxd_object_function.c:210
amxd_object_invoke_function
amxd_status_t amxd_object_invoke_function(amxd_object_t *const object, const char *func_name, amxc_var_t *const args, amxc_var_t *const ret)
Calls an object RPC method.
Definition: amxd_object_function.c:245
amxd_object_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_object_get_type
static amxd_object_type_t amxd_object_get_type(const amxd_object_t *const object)
Returns the object type.
Definition: amxd_object.h:586
amxd_action_param_check_minimum
amxd_status_t amxd_action_param_check_minimum(amxd_object_t *object, amxd_param_t *param, amxd_action_t reason, const amxc_var_t *const args, amxc_var_t *const retval, void *priv)
Default check minimum parameter validate action implementation.
Definition: amxd_action_param_validate.c:302
amxd_function_set_attr
amxd_status_t amxd_function_set_attr(amxd_function_t *func, const amxd_fattr_id_t attr, const bool enable)
Sets or unsets a method attribute.
Definition: amxd_function.c:283
amxd_function_delete
void amxd_function_delete(amxd_function_t **func)
Data model RPC method destructor function.
Definition: amxd_function.c:169
amxd_function_arg_set_attr
amxd_status_t amxd_function_arg_set_attr(amxd_function_t *const func, const char *name, const amxd_aattr_id_t attr, const bool enable)
Sets or unsets a method argument attribute.
Definition: amxd_function_args.c:183
amxd_function_arg_is_attr_set
bool amxd_function_arg_is_attr_set(const amxd_function_t *const func, const char *name, const amxd_aattr_id_t attr)
Checks if a method argument attribute is set.
Definition: amxd_function_args.c:260
amxd_function_new
amxd_status_t amxd_function_new(amxd_function_t **func, const char *name, const uint32_t ret_type, amxd_object_fn_t impl)
Data model RPC method constructor function.
Definition: amxd_function.c:146
amxd_function_new_arg
amxd_status_t amxd_function_new_arg(amxd_function_t *func, const char *name, const uint32_t type, amxc_var_t *default_value)
Adds an argument definition to a RPC method definition.
Definition: amxd_function_args.c:140
amxd_trans_dump
void amxd_trans_dump(const amxd_trans_t *const trans, const int fd, const bool reverse)
Dumps the transaction to a file descriptor.
Definition: amxd_transaction.c:882
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_set_value
#define amxd_trans_set_value(type, trans, name, value)
Helper macro for setting a value.
Definition: amxd_transaction.h:144
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_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_dm::sigmngr
amxp_signal_mngr_t sigmngr
Definition: amxd_types.h:261
_amxd_function
RPC method structure.
Definition: amxd_types.h:341
_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_get_root_of_mib_is_null
void test_get_root_of_mib_is_null(UNUSED void **state)
Definition: test_amxd_mib.c:456
test_add_mib_to_instance
void test_add_mib_to_instance(UNUSED void **state)
Definition: test_amxd_mib.c:590
test_can_add_multiple_mibs
void test_can_add_multiple_mibs(UNUSED void **state)
Definition: test_amxd_mib.c:330
test_event_handler
static void test_event_handler(const char *const sig_name, UNUSED const amxc_var_t *const data, void *const priv)
Definition: test_amxd_mib.c:86
test_add_mib_function_inherits_argument_attrs
void test_add_mib_function_inherits_argument_attrs(UNUSED void **state)
Definition: test_amxd_mib.c:548
test_can_add_remove_mib_to_from_object
void test_can_add_remove_mib_to_from_object(UNUSED void **state)
Definition: test_amxd_mib.c:208
test_set_attrs_on_mib_fails
void test_set_attrs_on_mib_fails(UNUSED void **state)
Definition: test_amxd_mib.c:477
test_object_get_mibs
void test_object_get_mibs(UNUSED void **state)
Definition: test_amxd_mib.c:897
dm
static amxd_dm_t dm
Definition: test_amxd_mib.c:84
test_can_add_remove_mib_to_from_object2
void test_can_add_remove_mib_to_from_object2(UNUSED void **state)
Definition: test_amxd_mib.c:262
test_add_mib_fails_when_object_not_in_dm
void test_add_mib_fails_when_object_not_in_dm(UNUSED void **state)
Definition: test_amxd_mib.c:406
test_add_mib_using_transaction
void test_add_mib_using_transaction(UNUSED void **state)
Definition: test_amxd_mib.c:642
test_add_mib_to_object_fails_when_leads_to_function_duplicate
void test_add_mib_to_object_fails_when_leads_to_function_duplicate(UNUSED void **state)
Definition: test_amxd_mib.c:499
test_add_mib_object_can_be_read_using_name_path
void test_add_mib_object_can_be_read_using_name_path(UNUSED void **state)
Definition: test_amxd_mib.c:855
test_can_fetch_dm_from_mib
void test_can_fetch_dm_from_mib(UNUSED void **state)
Definition: test_amxd_mib.c:786
test_mib_events
void test_mib_events(UNUSED void **state)
Definition: test_amxd_mib.c:751
test_functions_check_input_args
void test_functions_check_input_args(UNUSED void **state)
Definition: test_amxd_mib.c:430
test_add_mib_to_template
void test_add_mib_to_template(UNUSED void **state)
Definition: test_amxd_mib.c:685
count_objects
static int count_objects(UNUSED amxd_object_t *templ, UNUSED amxd_object_t *obj, void *priv)
Definition: test_amxd_mib.c:202
test_mib_not_removed_when_not_added
void test_mib_not_removed_when_not_added(UNUSED void **state)
Definition: test_amxd_mib.c:719
test_mib_cleanup_data
static amxd_status_t test_mib_cleanup_data(amxd_object_t *const object, amxd_param_t *const param, amxd_action_t reason, UNUSED const amxc_var_t *const args, UNUSED amxc_var_t *const retval, void *priv)
Definition: test_amxd_mib.c:100
test_add_mib_can_override_function
void test_add_mib_can_override_function(UNUSED void **state)
Definition: test_amxd_mib.c:524
test_can_define_and_store_mib
void test_can_define_and_store_mib(UNUSED void **state)
Definition: test_amxd_mib.c:156
test_add_mib_fails_when_duplicates
void test_add_mib_fails_when_duplicates(UNUSED void **state)
Definition: test_amxd_mib.c:385
test_build_dm
static amxd_object_t * test_build_dm(void)
Definition: test_amxd_mib.c:128
test_can_declare_event_in_mib
void test_can_declare_event_in_mib(UNUSED void **state)
Definition: test_amxd_mib.c:811
test_amxd_mib.h
status
static amxd_status_t status
Definition: test_amxd_object_action.c:83