libamxo  4.3.4
Object Definition Language (ODL) parsing
Functions
test_mibs.c File Reference
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <inttypes.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include <cmocka.h>
#include <amxc/amxc.h>
#include <amxp/amxp.h>
#include <amxp/amxp_signal.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_object_expression.h>
#include <amxd/amxd_parameter.h>
#include <amxo/amxo.h>
#include <amxo/amxo_mibs.h>
#include "test_mibs.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

void test_can_scan_mib_dir (UNUSED void **state)
 
void test_scan_mib_dir_fails_when_invalid_expr (UNUSED void **state)
 
void test_scan_mib_dir_skips_mib_when_already_known (UNUSED void **state)
 
void test_scan_mib_dir_fails_with_invalid_arguments (UNUSED void **state)
 
void test_can_scan_mib_dirs (UNUSED void **state)
 
void test_can_scan_mib_dirs_using_config (UNUSED void **state)
 
void test_scan_mib_dirs_fails_with_invalid_arguments (UNUSED void **state)
 
void test_can_apply_mib_to_object (UNUSED void **state)
 
void test_apply_unknown_mib_fails (UNUSED void **state)
 
void test_apply_fails_with_invalid_arguments (UNUSED void **state)
 
void test_can_apply_mibs_to_object (UNUSED void **state)
 
void test_can_add_mibs_to_object (UNUSED void **state)
 
void test_can_remove_mibs_from_object (UNUSED void **state)
 
void test_can_add_mibs_from_include (UNUSED void **state)
 

Function Documentation

◆ test_apply_fails_with_invalid_arguments()

void test_apply_fails_with_invalid_arguments ( UNUSED void **  state)

Definition at line 276 of file test_mibs.c.

276  {
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 }
odl
include test_include odl
Definition: test_valid.odl:66
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_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_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

◆ test_apply_unknown_mib_fails()

void test_apply_unknown_mib_fails ( UNUSED void **  state)

Definition at line 252 of file test_mibs.c.

252  {
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 }

◆ test_can_add_mibs_from_include()

void test_can_add_mibs_from_include ( UNUSED void **  state)

Definition at line 431 of file test_mibs.c.

431  {
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 }

◆ test_can_add_mibs_to_object()

void test_can_add_mibs_to_object ( UNUSED void **  state)

Definition at line 349 of file test_mibs.c.

349  {
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 }
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

◆ test_can_apply_mib_to_object()

void test_can_apply_mib_to_object ( UNUSED void **  state)

Definition at line 219 of file test_mibs.c.

219  {
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 }

◆ test_can_apply_mibs_to_object()

void test_can_apply_mibs_to_object ( UNUSED void **  state)

Definition at line 308 of file test_mibs.c.

308  {
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 }
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

◆ test_can_remove_mibs_from_object()

void test_can_remove_mibs_from_object ( UNUSED void **  state)

Definition at line 390 of file test_mibs.c.

390  {
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 }
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

◆ test_can_scan_mib_dir()

void test_can_scan_mib_dir ( UNUSED void **  state)

Definition at line 84 of file test_mibs.c.

84  {
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 }

◆ test_can_scan_mib_dirs()

void test_can_scan_mib_dirs ( UNUSED void **  state)

Definition at line 147 of file test_mibs.c.

147  {
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 }
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_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

◆ test_can_scan_mib_dirs_using_config()

void test_can_scan_mib_dirs_using_config ( UNUSED void **  state)

Definition at line 173 of file test_mibs.c.

173  {
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 }

◆ test_scan_mib_dir_fails_when_invalid_expr()

void test_scan_mib_dir_fails_when_invalid_expr ( UNUSED void **  state)

Definition at line 99 of file test_mibs.c.

99  {
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 }

◆ test_scan_mib_dir_fails_with_invalid_arguments()

void test_scan_mib_dir_fails_with_invalid_arguments ( UNUSED void **  state)

Definition at line 130 of file test_mibs.c.

130  {
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 }

◆ test_scan_mib_dir_skips_mib_when_already_known()

void test_scan_mib_dir_skips_mib_when_already_known ( UNUSED void **  state)

Definition at line 113 of file test_mibs.c.

113  {
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 }

◆ test_scan_mib_dirs_fails_with_invalid_arguments()

void test_scan_mib_dirs_fails_with_invalid_arguments ( UNUSED void **  state)

Definition at line 193 of file test_mibs.c.

193  {
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 }