libamxo  4.3.4
Object Definition Language (ODL) parsing
test_mibs.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 #include <sys/time.h>
55 #include <sys/resource.h>
56 #include <sys/types.h>
57 #include <sys/stat.h>
58 
59 #include <string.h>
60 #include <stdlib.h>
61 #include <stdio.h>
62 #include <stdarg.h>
63 #include <stddef.h>
64 #include <setjmp.h>
65 #include <inttypes.h>
66 #include <limits.h>
67 #include <unistd.h>
68 #include <fcntl.h>
69 #include <cmocka.h>
70 
71 #include <amxc/amxc.h>
72 #include <amxp/amxp.h>
73 #include <amxp/amxp_signal.h>
74 #include <amxd/amxd_dm.h>
75 #include <amxd/amxd_object.h>
76 #include <amxd/amxd_object_expression.h>
77 #include <amxd/amxd_parameter.h>
78 #include <amxo/amxo.h>
79 #include <amxo/amxo_mibs.h>
80 
81 #include "test_mibs.h"
82 
83 #include <amxc/amxc_macros.h>
84 void test_can_scan_mib_dir(UNUSED void** state) {
85  amxd_dm_t dm;
86  amxo_parser_t parser;
87 
88  amxd_dm_init(&dm);
89  amxo_parser_init(&parser);
90 
91  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs"), 0);
92  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs/test_mib_valid"), 0);
93  assert_int_equal(amxc_htable_size(&parser.mibs), 5);
94 
95  amxo_parser_clean(&parser);
96  amxd_dm_clean(&dm);
97 }
98 
99 void test_scan_mib_dir_fails_when_invalid_expr(UNUSED void** state) {
100  amxd_dm_t dm;
101  amxo_parser_t parser;
102 
103  amxd_dm_init(&dm);
104  amxo_parser_init(&parser);
105 
106  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs/test_mib_dir.odl"), 0);
107  assert_int_equal(amxc_htable_size(&parser.mibs), 0);
108 
109  amxo_parser_clean(&parser);
110  amxd_dm_clean(&dm);
111 }
112 
113 void test_scan_mib_dir_skips_mib_when_already_known(UNUSED void** state) {
114  amxd_dm_t dm;
115  amxo_parser_t parser;
116 
117  amxd_dm_init(&dm);
118  amxo_parser_init(&parser);
119 
120  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs"), 0);
121  assert_int_equal(amxc_htable_size(&parser.mibs), 4);
122 
123  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs"), 0);
124  assert_int_equal(amxc_htable_size(&parser.mibs), 4);
125 
126  amxo_parser_clean(&parser);
127  amxd_dm_clean(&dm);
128 }
129 
130 void test_scan_mib_dir_fails_with_invalid_arguments(UNUSED void** state) {
131  amxd_dm_t dm;
132  amxo_parser_t parser;
133 
134  amxd_dm_init(&dm);
135  amxo_parser_init(&parser);
136 
137  assert_int_not_equal(amxo_parser_scan_mib_dir(NULL, "./mibs"), 0);
138  assert_int_not_equal(amxo_parser_scan_mib_dir(&parser, "./not_existing_dir"), 0);
139  assert_int_not_equal(amxo_parser_scan_mib_dir(&parser, NULL), 0);
140  assert_int_not_equal(amxo_parser_scan_mib_dir(&parser, ""), 0);
141  assert_int_not_equal(amxo_parser_scan_mib_dir(&parser, "./mibs/test_mib1.odl"), 0);
142 
143  amxo_parser_clean(&parser);
144  amxd_dm_clean(&dm);
145 }
146 
147 void test_can_scan_mib_dirs(UNUSED void** state) {
148  amxd_dm_t dm;
149  amxo_parser_t parser;
150  amxc_var_t dirs;
151  amxc_var_t* mib_dir = NULL;
152 
153  amxc_var_init(&dirs);
154  amxc_var_set_type(&dirs, AMXC_VAR_ID_LIST);
155  amxc_var_add(cstring_t, &dirs, "./mibs");
156  amxc_var_add(cstring_t, &dirs, "./mibs/test_mib_valid");
157  amxc_var_add(cstring_t, &dirs, "./${mib-dir}/test_mib_valid");
158 
159  amxd_dm_init(&dm);
160  amxo_parser_init(&parser);
161 
162  mib_dir = amxo_parser_claim_config(&parser, "mib-dir");
163  amxc_var_set(cstring_t, mib_dir, "mibs");
164 
165  assert_int_equal(amxo_parser_scan_mib_dirs(&parser, &dirs), 0);
166  assert_int_equal(amxc_htable_size(&parser.mibs), 5);
167 
168  amxc_var_clean(&dirs);
169  amxo_parser_clean(&parser);
170  amxd_dm_clean(&dm);
171 }
172 
173 void test_can_scan_mib_dirs_using_config(UNUSED void** state) {
174  amxd_dm_t dm;
175  amxo_parser_t parser;
176  amxc_var_t* dirs = NULL;
177 
178  amxd_dm_init(&dm);
179  amxo_parser_init(&parser);
180 
181  dirs = amxo_parser_claim_config(&parser, "mib-dirs");
182  amxc_var_set_type(dirs, AMXC_VAR_ID_LIST);
183  amxc_var_add(cstring_t, dirs, "./mibs");
184  amxc_var_add(cstring_t, dirs, "./mibs/test_mib_valid");
185 
186  assert_int_equal(amxo_parser_scan_mib_dirs(&parser, NULL), 0);
187  assert_int_equal(amxc_htable_size(&parser.mibs), 5);
188 
189  amxo_parser_clean(&parser);
190  amxd_dm_clean(&dm);
191 }
192 
193 void test_scan_mib_dirs_fails_with_invalid_arguments(UNUSED void** state) {
194  amxd_dm_t dm;
195  amxo_parser_t parser;
196  amxc_var_t dirs;
197 
198  amxc_var_init(&dirs);
199  amxd_dm_init(&dm);
200  amxo_parser_init(&parser);
201 
202  assert_int_not_equal(amxo_parser_scan_mib_dirs(NULL, NULL), 0);
203  assert_int_not_equal(amxo_parser_scan_mib_dirs(&parser, NULL), 0);
204  assert_int_not_equal(amxo_parser_scan_mib_dirs(&parser, &dirs), 0);
205 
206  amxc_var_set_type(&dirs, AMXC_VAR_ID_LIST);
207  amxc_var_add(cstring_t, &dirs, "");
208  assert_int_not_equal(amxo_parser_scan_mib_dirs(&parser, &dirs), 0);
209  amxc_var_clean(&dirs);
210  amxc_var_set_type(&dirs, AMXC_VAR_ID_LIST);
211  amxc_var_add(uint32_t, &dirs, 123);
212  assert_int_not_equal(amxo_parser_scan_mib_dirs(&parser, &dirs), 0);
213 
214  amxc_var_clean(&dirs);
215  amxo_parser_clean(&parser);
216  amxd_dm_clean(&dm);
217 }
218 
219 void test_can_apply_mib_to_object(UNUSED void** state) {
220  amxd_dm_t dm;
221  amxo_parser_t parser;
222  amxd_object_t* object = NULL;
223  const char* odl = "%define { object Test { string MyParam; } }";
224 
225  amxd_dm_init(&dm);
226  amxo_parser_init(&parser);
227 
228  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs"), 0);
229  assert_int_equal(amxc_htable_size(&parser.mibs), 4);
230 
231  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
232  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
233 
234  object = amxd_dm_get_object(&dm, "Test");
235  assert_non_null(object);
236 
237  assert_null(amxd_object_get_param_def(object, "Mib1Text"));
238  assert_int_equal(amxo_parser_apply_mib(&parser, object, "test_mib1"), 0);
239  assert_non_null(amxd_object_get_param_def(object, "Mib1Text"));
240 
241  assert_true(amxd_object_has_mib(object, "test_mib1"));
242  assert_int_equal(amxd_object_remove_mib(object, "test_mib1"), 0);
243  assert_null(amxd_object_get_param_def(object, "Mib1Text"));
244 
245  assert_int_equal(amxo_parser_apply_mib(&parser, object, "test_mib1"), 0);
246  assert_non_null(amxd_object_get_param_def(object, "Mib1Text"));
247 
248  amxo_parser_clean(&parser);
249  amxd_dm_clean(&dm);
250 }
251 
252 void test_apply_unknown_mib_fails(UNUSED void** state) {
253  amxd_dm_t dm;
254  amxo_parser_t parser;
255  amxd_object_t* object = NULL;
256  const char* odl = "%define { object Test { string MyParam; } }";
257 
258  amxd_dm_init(&dm);
259  amxo_parser_init(&parser);
260 
261  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs"), 0);
262  assert_int_equal(amxc_htable_size(&parser.mibs), 4);
263 
264  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
265  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
266 
267  object = amxd_dm_get_object(&dm, "Test");
268  assert_non_null(object);
269 
270  assert_int_not_equal(amxo_parser_apply_mib(&parser, object, "unknown_mib1"), 0);
271 
272  amxo_parser_clean(&parser);
273  amxd_dm_clean(&dm);
274 }
275 
276 void test_apply_fails_with_invalid_arguments(UNUSED void** state) {
277  amxd_dm_t dm;
278  amxo_parser_t parser;
279  amxd_object_t* object = NULL;
280  amxd_object_t* not_in_dm = NULL;
281  const char* odl = "%define { object Test { string MyParam; } }";
282 
283  amxd_dm_init(&dm);
284  amxo_parser_init(&parser);
285 
286  amxd_object_new(&not_in_dm, amxd_object_singleton, "Test");
287 
288  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs"), 0);
289  assert_int_equal(amxc_htable_size(&parser.mibs), 4);
290 
291  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
292  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
293 
294  object = amxd_dm_get_object(&dm, "Test");
295  assert_non_null(object);
296 
297  assert_int_not_equal(amxo_parser_apply_mib(NULL, object, "test_mib1"), 0);
298  assert_int_not_equal(amxo_parser_apply_mib(&parser, NULL, "test_mib1"), 0);
299  assert_int_not_equal(amxo_parser_apply_mib(&parser, object, NULL), 0);
300  assert_int_not_equal(amxo_parser_apply_mib(&parser, object, ""), 0);
301  assert_int_not_equal(amxo_parser_apply_mib(&parser, not_in_dm, "tesT_mib1"), 0);
302 
303  amxd_object_delete(&not_in_dm);
304  amxo_parser_clean(&parser);
305  amxd_dm_clean(&dm);
306 }
307 
308 void test_can_apply_mibs_to_object(UNUSED void** state) {
309  amxd_dm_t dm;
310  amxo_parser_t parser;
311  amxd_object_t* object = NULL;
312 
313  const char* odl = "%define { object Test { string MyParam = 'ADD'; } }";
314 
315  amxd_dm_init(&dm);
316  amxo_parser_init(&parser);
317 
318  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs"), 0);
319  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs/test_mib_valid"), 0);
320  assert_int_equal(amxc_htable_size(&parser.mibs), 5);
321 
322  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
323  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
324 
325  object = amxd_dm_get_object(&dm, "Test");
326  assert_non_null(object);
327 
328  assert_null(amxd_object_get_param_def(object, "Mib1Text"));
329  assert_null(amxd_object_get_param_def(object, "Mib3Text"));
330  assert_null(amxd_object_get_param_def(object, "Mib6Text"));
331  assert_int_equal(amxo_parser_apply_mibs(&parser, object, amxd_object_matches_expr), 2);
332  assert_null(amxd_object_get_param_def(object, "Mib1Text"));
333  assert_non_null(amxd_object_get_param_def(object, "Mib3Text"));
334  assert_non_null(amxd_object_get_param_def(object, "Mib6Text"));
335  assert_true(amxd_object_has_mib(object, "test_mib3"));
336  assert_true(amxd_object_has_mib(object, "test_mib6"));
337 
338  amxd_object_set_value(cstring_t, object, "MyParam", "HELLO");
339  assert_int_equal(amxo_parser_apply_mibs(&parser, object, amxd_object_matches_expr), 2);
340  assert_false(amxd_object_has_mib(object, "test_mib3"));
341  assert_false(amxd_object_has_mib(object, "test_mib6"));
342  assert_null(amxd_object_get_param_def(object, "Mib3Text"));
343  assert_null(amxd_object_get_param_def(object, "Mib6Text"));
344 
345  amxo_parser_clean(&parser);
346  amxd_dm_clean(&dm);
347 }
348 
349 void test_can_add_mibs_to_object(UNUSED void** state) {
350  amxd_dm_t dm;
351  amxo_parser_t parser;
352  amxd_object_t* object = NULL;
353 
354  const char* odl = "%define { object Test { string MyParam = 'ADD'; } }";
355 
356  amxd_dm_init(&dm);
357  amxo_parser_init(&parser);
358 
359  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs"), 0);
360  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs/test_mib_valid"), 0);
361  assert_int_equal(amxc_htable_size(&parser.mibs), 5);
362 
363  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
364  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
365 
366  object = amxd_dm_get_object(&dm, "Test");
367  assert_non_null(object);
368 
369  assert_null(amxd_object_get_param_def(object, "Mib1Text"));
370  assert_null(amxd_object_get_param_def(object, "Mib3Text"));
371  assert_null(amxd_object_get_param_def(object, "Mib6Text"));
372  assert_int_equal(amxo_parser_add_mibs(&parser, object, amxd_object_matches_expr), 2);
373  assert_null(amxd_object_get_param_def(object, "Mib1Text"));
374  assert_non_null(amxd_object_get_param_def(object, "Mib3Text"));
375  assert_non_null(amxd_object_get_param_def(object, "Mib6Text"));
376  assert_true(amxd_object_has_mib(object, "test_mib3"));
377  assert_true(amxd_object_has_mib(object, "test_mib6"));
378 
379  amxd_object_set_value(cstring_t, object, "MyParam", "HELLO");
380  assert_int_equal(amxo_parser_add_mibs(&parser, object, amxd_object_matches_expr), 0);
381  assert_non_null(amxd_object_get_param_def(object, "Mib3Text"));
382  assert_non_null(amxd_object_get_param_def(object, "Mib6Text"));
383  assert_true(amxd_object_has_mib(object, "test_mib3"));
384  assert_true(amxd_object_has_mib(object, "test_mib6"));
385 
386  amxo_parser_clean(&parser);
387  amxd_dm_clean(&dm);
388 }
389 
390 void test_can_remove_mibs_from_object(UNUSED void** state) {
391  amxd_dm_t dm;
392  amxo_parser_t parser;
393  amxd_object_t* object = NULL;
394 
395  const char* odl = "%define { object Test { string MyParam = 'ADD'; } }";
396 
397  amxd_dm_init(&dm);
398  amxo_parser_init(&parser);
399 
400  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs"), 0);
401  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs/test_mib_valid"), 0);
402  assert_int_equal(amxc_htable_size(&parser.mibs), 5);
403 
404  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
405  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
406 
407  object = amxd_dm_get_object(&dm, "Test");
408  assert_non_null(object);
409 
410  assert_null(amxd_object_get_param_def(object, "Mib1Text"));
411  assert_null(amxd_object_get_param_def(object, "Mib3Text"));
412  assert_null(amxd_object_get_param_def(object, "Mib6Text"));
413  assert_int_equal(amxo_parser_add_mibs(&parser, object, amxd_object_matches_expr), 2);
414  assert_null(amxd_object_get_param_def(object, "Mib1Text"));
415  assert_non_null(amxd_object_get_param_def(object, "Mib3Text"));
416  assert_non_null(amxd_object_get_param_def(object, "Mib6Text"));
417  assert_true(amxd_object_has_mib(object, "test_mib3"));
418  assert_true(amxd_object_has_mib(object, "test_mib6"));
419 
420  amxd_object_set_value(cstring_t, object, "MyParam", "HELLO");
421  assert_int_equal(amxo_parser_remove_mibs(&parser, object, amxd_object_matches_expr), 2);
422  assert_null(amxd_object_get_param_def(object, "Mib3Text"));
423  assert_null(amxd_object_get_param_def(object, "Mib6Text"));
424  assert_false(amxd_object_has_mib(object, "test_mib3"));
425  assert_false(amxd_object_has_mib(object, "test_mib6"));
426 
427  amxo_parser_clean(&parser);
428  amxd_dm_clean(&dm);
429 }
430 
431 void test_can_add_mibs_from_include(UNUSED void** state) {
432  amxd_dm_t dm;
433  amxo_parser_t parser;
434  amxd_object_t* object = NULL;
435 
436  const char* odl = "%define { object Test { string MyParam = 'ADD'; } } "
437  "include \"add_mid.odl\";";
438 
439  amxd_dm_init(&dm);
440  amxo_parser_init(&parser);
441 
442  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs"), 0);
443  assert_int_equal(amxo_parser_scan_mib_dir(&parser, "./mibs/test_mib_valid"), 0);
444  assert_int_equal(amxc_htable_size(&parser.mibs), 5);
445 
446  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
447  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
448 
449  object = amxd_dm_get_object(&dm, "Test");
450  assert_non_null(object);
451 
452  assert_true(amxd_object_has_mib(object, "test_mib1"));
453  assert_non_null(amxd_object_get_param_def(object, "Mib1Text"));
454 
455  amxo_parser_clean(&parser);
456  amxd_dm_clean(&dm);
457 }
amxo.h
Ambiorix ODL parser header file.
odl
include test_include odl
Definition: test_valid.odl:66
amxo_mibs.h
amxo_parser_claim_config
amxc_var_t * amxo_parser_claim_config(amxo_parser_t *parser, const char *path)
Gets or creates a configuration option.
Definition: amxo_parser_main.c:410
amxo_parser_remove_mibs
int amxo_parser_remove_mibs(amxo_parser_t *parser, amxd_object_t *object, amxo_evaluate_expr_fn_t fn)
Removes zero, one or more MIBs from a data model object.
Definition: amxo_parser_mibs.c:341
amxo_parser_scan_mib_dir
int amxo_parser_scan_mib_dir(amxo_parser_t *parser, const char *path)
Scans a directory for MIB odl files.
Definition: amxo_parser_mibs.c:186
amxo_parser_scan_mib_dirs
int amxo_parser_scan_mib_dirs(amxo_parser_t *parser, amxc_var_t *dirs)
Scans multiple directories for MIB odl files.
Definition: amxo_parser_mibs.c:209
amxo_parser_apply_mibs
int amxo_parser_apply_mibs(amxo_parser_t *parser, amxd_object_t *object, amxo_evaluate_expr_fn_t fn)
Applies zero, one or more MIBs to a data model object.
Definition: amxo_parser_mibs.c:370
amxo_parser_apply_mib
int amxo_parser_apply_mib(amxo_parser_t *parser, amxd_object_t *object, const char *mib_name)
Unconditionally applies a MIB to a data model object.
Definition: amxo_parser_mibs.c:291
amxo_parser_add_mibs
int amxo_parser_add_mibs(amxo_parser_t *parser, amxd_object_t *object, amxo_evaluate_expr_fn_t fn)
Adds zero, one or more MIBs to a data model object.
Definition: amxo_parser_mibs.c:315
amxo_parser_parse_string
int amxo_parser_parse_string(amxo_parser_t *parser, const char *text, amxd_object_t *object)
Parses a string containing a valid ODL part.
Definition: amxo_parser_main.c:379
amxo_parser_clean
void amxo_parser_clean(amxo_parser_t *parser)
Cleans up the odl parser instance.
Definition: amxo_parser_main.c:238
amxo_parser_get_status
static amxd_status_t amxo_parser_get_status(amxo_parser_t *parser)
Get the status of the odl parser.
Definition: amxo.h:414
amxo_parser_init
int amxo_parser_init(amxo_parser_t *parser)
Initializes a new odl parser instance.
Definition: amxo_parser_main.c:219
_amxo_parser
The ODL parser structure.
Definition: amxo_types.h:245
_amxo_parser::mibs
amxc_htable_t mibs
Definition: amxo_types.h:282
UNUSED
#define UNUSED
Definition: test_issue_48.c:84
test_apply_fails_with_invalid_arguments
void test_apply_fails_with_invalid_arguments(UNUSED void **state)
Definition: test_mibs.c:276
test_can_apply_mib_to_object
void test_can_apply_mib_to_object(UNUSED void **state)
Definition: test_mibs.c:219
test_can_add_mibs_to_object
void test_can_add_mibs_to_object(UNUSED void **state)
Definition: test_mibs.c:349
test_can_add_mibs_from_include
void test_can_add_mibs_from_include(UNUSED void **state)
Definition: test_mibs.c:431
test_scan_mib_dir_fails_when_invalid_expr
void test_scan_mib_dir_fails_when_invalid_expr(UNUSED void **state)
Definition: test_mibs.c:99
test_scan_mib_dir_fails_with_invalid_arguments
void test_scan_mib_dir_fails_with_invalid_arguments(UNUSED void **state)
Definition: test_mibs.c:130
test_can_apply_mibs_to_object
void test_can_apply_mibs_to_object(UNUSED void **state)
Definition: test_mibs.c:308
test_scan_mib_dirs_fails_with_invalid_arguments
void test_scan_mib_dirs_fails_with_invalid_arguments(UNUSED void **state)
Definition: test_mibs.c:193
test_can_scan_mib_dirs
void test_can_scan_mib_dirs(UNUSED void **state)
Definition: test_mibs.c:147
test_can_scan_mib_dirs_using_config
void test_can_scan_mib_dirs_using_config(UNUSED void **state)
Definition: test_mibs.c:173
test_scan_mib_dir_skips_mib_when_already_known
void test_scan_mib_dir_skips_mib_when_already_known(UNUSED void **state)
Definition: test_mibs.c:113
test_can_remove_mibs_from_object
void test_can_remove_mibs_from_object(UNUSED void **state)
Definition: test_mibs.c:390
test_apply_unknown_mib_fails
void test_apply_unknown_mib_fails(UNUSED void **state)
Definition: test_mibs.c:252
test_can_scan_mib_dir
void test_can_scan_mib_dir(UNUSED void **state)
Definition: test_mibs.c:84
test_mibs.h