libamxo  4.3.4
Object Definition Language (ODL) parsing
Functions
test_valid_odl.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_signal.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_object_event.h>
#include <amxd/amxd_parameter.h>
#include <amxo/amxo.h>
#include "test_valid_odl.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

static void check_options_are_available (amxo_parser_t *parser)
 
static void check_objects_exist (amxd_dm_t *dm)
 
static void check_parameters_exist (amxd_dm_t *dm)
 
static void check_functions_exist (amxd_dm_t *dm)
 
static void check_mib_extions_work (amxd_dm_t *dm)
 
void test_can_parse_odl_file (UNUSED void **state)
 
void test_can_parse_odl_file_no_resolve (UNUSED void **state)
 
void test_can_parse_empty_file (UNUSED void **state)
 
void test_can_parse_fd (UNUSED void **state)
 
void test_can_parse_string (UNUSED void **state)
 
void test_duplicate_func_name (UNUSED void **state)
 
void test_object_has_event (UNUSED void **state)
 

Function Documentation

◆ check_functions_exist()

static void check_functions_exist ( amxd_dm_t *  dm)
static

Definition at line 212 of file test_valid_odl.c.

212  {
213  amxd_object_t* root = amxd_dm_get_root(dm);
214  amxd_object_t* object = NULL;
215  amxd_function_t* func = NULL;
216  static const char* obj_funcs[] = {
217  "func1",
218  "func2",
219  "func3",
220  "func4",
221  "func5",
222  "func6",
223  "func7",
224  "func8",
225  "func9",
226  "func10",
227  "func11",
228  "func12",
229  "func13",
230  "func14",
231  "func15",
232  "func16",
233  NULL
234  };
235 
236  object = amxd_object_findf(root, "TestObjectRoot.TestObjectFunctions");
237  assert_int_equal(amxd_object_get_function_count(object, amxd_dm_access_private), 25);
238  for(int i = 0; obj_funcs[i] != NULL; i++) {
239  assert_ptr_not_equal(amxd_object_get_function(object, obj_funcs[i]), NULL);
240  }
241 
242  object = amxd_object_findf(root, "TestObjectRoot.TestSingletonFuncAttr");
243  assert_int_equal(amxd_object_get_function_count(object, amxd_dm_access_private), 11);
244  func = amxd_object_get_function(object, "TestFunc1");
245  assert_true(amxd_function_is_attr_set(func, amxd_fattr_template));
246  assert_true(amxd_function_is_attr_set(func, amxd_fattr_instance));
247  assert_true(amxd_function_is_attr_set(func, amxd_fattr_private));
248 
249  func = amxd_object_get_function(object, "TestFunc2");
250  assert_false(amxd_function_is_attr_set(func, amxd_fattr_template));
251  assert_false(amxd_function_is_attr_set(func, amxd_fattr_instance));
252  assert_false(amxd_function_is_attr_set(func, amxd_fattr_private));
253 }

◆ check_mib_extions_work()

static void check_mib_extions_work ( amxd_dm_t *  dm)
static

Definition at line 255 of file test_valid_odl.c.

255  {
256  amxd_object_t* object = amxd_dm_findf(dm, "TestObjectRoot.ExtendWithTestMib");
257 
258  assert_ptr_not_equal(object, NULL);
259  assert_true(amxd_object_has_mib(object, "TestMib"));
260  assert_ptr_not_equal(amxd_object_get_param_def(object, "mibparam"), NULL);
261  assert_ptr_not_equal(amxd_object_get_function(object, "mibfunc"), NULL);
262 }

◆ check_objects_exist()

static void check_objects_exist ( amxd_dm_t *  dm)
static

Definition at line 96 of file test_valid_odl.c.

96  {
97  amxd_object_t* root = amxd_dm_get_root(dm);
98  static const char* paths[] = {
99  "TestObjectRoot",
100  "TestObjectRoot.TestObjectSingelton",
101  "TestObjectRoot.TestObjSingletonAttr",
102  "TestObjectRoot.TestObjectTemplate",
103  "TestObjectRoot.TestObjTemplateAttr",
104  "TestObjectRoot.TestObjectParamTypes",
105  "TestObjectRoot.TestObjectFunctions",
106  "TestObjectRoot.TestSingeltonParamAttr",
107  "TestObjectRoot.TestTemplateParamAttr.99",
108  "TestObjectRoot.TestTemplateParamAttr.100",
109  "TestObjectRoot.TestSingletonFuncAttr",
110  "TestObjectRoot.TestTemplateFuncAttr",
111  "TestObjectRoot.TestObjectTemplateWithChild",
112  "TestObjectRoot.TestObjectTemplateWithChild.TemplateChildObject",
113  "TestObjectRoot.TestObjectTemplateWithChild.Name1",
114  "TestObjectRoot.TestObjectTemplateWithChild.Name1.TemplateChildObject",
115  "TestObjectRoot.TestObjectTemplateWithChild.Name2",
116  "TestObjectRoot.TestObjectTemplateWithChild.Name2.MibObject",
117  "TestObjectRoot.TestObjectTemplateWithChild.Name2.TemplateChildObject",
118  "TestObjectRoot.ExtendWithTestMib",
119  "TestObjectRoot.ExtendWithTestMib.MibObject",
120  NULL
121  };
122 
123  for(int i = 0; paths[i] != NULL; i++) {
124  printf("Checking %s exists\n", paths[i]);
125  assert_ptr_not_equal(amxd_object_findf(root, paths[i]), NULL);
126  }
127 }

◆ check_options_are_available()

static void check_options_are_available ( amxo_parser_t *  parser)
static

Definition at line 82 of file test_valid_odl.c.

82  {
83  amxc_var_t* option = amxo_parser_get_config(parser, "test_option_number");
84  assert_ptr_not_equal(option, NULL);
85  assert_int_equal(amxc_var_type_of(option), AMXC_VAR_ID_INT64);
86 
87  option = amxo_parser_get_config(parser, "test_option_string");
88  assert_ptr_not_equal(option, NULL);
89  assert_int_equal(amxc_var_type_of(option), AMXC_VAR_ID_CSTRING);
90 
91  option = amxo_parser_get_config(parser, "test_option_bool");
92  assert_ptr_not_equal(option, NULL);
93  assert_int_equal(amxc_var_type_of(option), AMXC_VAR_ID_BOOL);
94 }
amxo_parser_get_config
amxc_var_t * amxo_parser_get_config(amxo_parser_t *parser, const char *path)
Gets a configuration option.
Definition: amxo_parser_main.c:430

◆ check_parameters_exist()

static void check_parameters_exist ( amxd_dm_t *  dm)
static

Definition at line 129 of file test_valid_odl.c.

129  {
130  amxd_object_t* root = amxd_dm_get_root(dm);
131  amxd_object_t* object = NULL;
132  amxd_param_t* param = NULL;
133  static const char* types_params[] = {
134  "Param1",
135  "Param2",
136  "Param3",
137  "Param4",
138  "Param5",
139  "Param6",
140  "Param7",
141  "Param8",
142  "Param9",
143  "Param10",
144  "Param11",
145  "Param12",
146  "Param13",
147  NULL
148  };
149 
150  object = amxd_object_findf(root, "TestObjectRoot.TestObjectParamTypes");
151  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_protected), 13);
152  for(int i = 0; types_params[i] != NULL; i++) {
153  assert_ptr_not_equal(amxd_object_get_param_def(object, types_params[i]), NULL);
154  }
155 
156  object = amxd_object_findf(root, "TestObjectRoot.TestSingeltonParamAttr");
157  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_private), 1);
158  param = amxd_object_get_param_def(object, "Param1");
159  assert_ptr_not_equal(param, NULL);
160  assert_true(amxd_param_is_attr_set(param, amxd_pattr_private));
161  assert_true(amxd_param_is_attr_set(param, amxd_pattr_read_only));
162  assert_true(amxd_param_is_attr_set(param, amxd_pattr_variable));
163  assert_true(amxd_param_is_attr_set(param, amxd_pattr_instance));
164  assert_true(amxd_param_is_attr_set(param, amxd_pattr_template));
165 
166  object = amxd_object_findf(root, "TestObjectRoot.TestTemplateParamAttr");
167  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_private), 3);
168  param = amxd_object_get_param_def(object, "Param1");
169  assert_ptr_not_equal(param, NULL);
170  assert_true(amxd_param_is_attr_set(param, amxd_pattr_private));
171  assert_true(amxd_param_is_attr_set(param, amxd_pattr_read_only));
172  assert_true(amxd_param_is_attr_set(param, amxd_pattr_variable));
173  assert_true(amxd_param_is_attr_set(param, amxd_pattr_instance));
174  assert_true(amxd_param_is_attr_set(param, amxd_pattr_template));
175  param = amxd_object_get_param_def(object, "Param2");
176  assert_ptr_not_equal(param, NULL);
177  assert_false(amxd_param_is_attr_set(param, amxd_pattr_private));
178  assert_false(amxd_param_is_attr_set(param, amxd_pattr_read_only));
179  assert_false(amxd_param_is_attr_set(param, amxd_pattr_variable));
180  assert_false(amxd_param_is_attr_set(param, amxd_pattr_instance));
181  assert_true(amxd_param_is_attr_set(param, amxd_pattr_template));
182  param = amxd_object_get_param_def(object, "Param3");
183  assert_ptr_not_equal(param, NULL);
184  assert_false(amxd_param_is_attr_set(param, amxd_pattr_private));
185  assert_false(amxd_param_is_attr_set(param, amxd_pattr_read_only));
186  assert_false(amxd_param_is_attr_set(param, amxd_pattr_variable));
187  assert_true(amxd_param_is_attr_set(param, amxd_pattr_instance));
188  assert_false(amxd_param_is_attr_set(param, amxd_pattr_template));
189 
190  object = amxd_object_findf(root, "TestObjectRoot");
191  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_private), 2);
192  param = amxd_object_get_param_def(object, "TestObjectTemplateWithChildCounter");
193  assert_ptr_not_equal(param, NULL);
194  object = amxd_object_findf(root, "TestObjectRoot.TestObjectTemplateWithChild.TemplateChildObject");
195  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_private), 1);
196  param = amxd_object_get_param_def(object, "Param1");
197  assert_ptr_not_equal(param, NULL);
198  object = amxd_object_findf(root, "TestObjectRoot.TestObjectTemplateWithChild.1.TemplateChildObject");
199  assert_int_equal(amxd_object_get_param_count(object, amxd_dm_access_private), 1);
200  param = amxd_object_get_param_def(object, "Param1");
201  assert_ptr_not_equal(param, NULL);
202 
203  object = amxd_object_findf(root, "TestObjectRoot.TestObjectTemplateWithKeys.1.");
204  param = amxd_object_get_param_def(object, "KeyPart1");
205  assert_true(amxd_param_is_attr_set(param, amxd_pattr_key));
206  assert_false(amxd_param_is_attr_set(param, amxd_pattr_mutable));
207  param = amxd_object_get_param_def(object, "KeyPart2");
208  assert_true(amxd_param_is_attr_set(param, amxd_pattr_key));
209  assert_true(amxd_param_is_attr_set(param, amxd_pattr_mutable));
210 }

◆ test_can_parse_empty_file()

void test_can_parse_empty_file ( UNUSED void **  state)

Definition at line 320 of file test_valid_odl.c.

320  {
321  amxd_dm_t dm;
322  amxo_parser_t parser;
323 
324  amxd_dm_init(&dm);
325  amxo_parser_init(&parser);
326 
327  assert_int_equal(amxo_parser_parse_file(&parser, "empty.odl", amxd_dm_get_root(&dm)), 0);
328  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
329 
330  amxo_parser_clean(&parser);
331  amxd_dm_clean(&dm);
332 }
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_parse_file
int amxo_parser_parse_file(amxo_parser_t *parser, const char *file_path, amxd_object_t *object)
Parses an odl file.
Definition: amxo_parser_main.c:328
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

◆ test_can_parse_fd()

void test_can_parse_fd ( UNUSED void **  state)

Definition at line 335 of file test_valid_odl.c.

335  {
336  amxd_dm_t dm;
337  amxo_parser_t parser;
338  amxc_var_t* lib_dirs = NULL;
339  int fd = open("test_valid.odl", O_RDONLY);
340 
341  amxd_dm_init(&dm);
342  amxo_parser_init(&parser);
343 
344  lib_dirs = amxo_parser_get_config(&parser, "import-dirs");
345  amxc_var_add(cstring_t, lib_dirs, "../test_plugin/");
346  amxc_var_dump(&parser.config, STDOUT_FILENO);
347 
348  assert_int_equal(amxo_parser_parse_fd(&parser, fd, amxd_dm_get_root(&dm)), 0);
349  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
350  close(fd);
351 
352  check_options_are_available(&parser);
353  check_objects_exist(&dm);
354  check_parameters_exist(&dm);
355  check_functions_exist(&dm);
356 
357  amxo_parser_clean(&parser);
358  amxd_dm_clean(&dm);
359  amxo_resolver_import_close_all();
360 }
amxo_parser_parse_fd
int amxo_parser_parse_fd(amxo_parser_t *parser, int fd, amxd_object_t *object)
Parses an odl file.
Definition: amxo_parser_main.c:304
amxo_resolver_import_close_all
void amxo_resolver_import_close_all(void)
Unloads all loaded shared objects.
Definition: amxo_import_resolver.c:451
_amxo_parser::config
amxc_var_t config
Definition: amxo_types.h:250
check_functions_exist
static void check_functions_exist(amxd_dm_t *dm)
Definition: test_valid_odl.c:212
check_options_are_available
static void check_options_are_available(amxo_parser_t *parser)
Definition: test_valid_odl.c:82
check_objects_exist
static void check_objects_exist(amxd_dm_t *dm)
Definition: test_valid_odl.c:96
check_parameters_exist
static void check_parameters_exist(amxd_dm_t *dm)
Definition: test_valid_odl.c:129

◆ test_can_parse_odl_file()

void test_can_parse_odl_file ( UNUSED void **  state)

Definition at line 264 of file test_valid_odl.c.

264  {
265  amxd_dm_t dm;
266  amxc_var_t* lib_dirs = NULL;
267  amxo_parser_t parser;
268 
269  amxd_dm_init(&dm);
270  amxo_parser_init(&parser);
271 
272  lib_dirs = amxo_parser_get_config(&parser, "import-dirs");
273  amxc_var_add(cstring_t, lib_dirs, "../test_plugin/");
274  amxc_var_dump(&parser.config, STDOUT_FILENO);
275 
276  assert_int_equal(amxo_parser_parse_file(&parser, "test_valid.odl", amxd_dm_get_root(&dm)), 0);
277  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
278 
279  check_options_are_available(&parser);
280  check_objects_exist(&dm);
281  check_parameters_exist(&dm);
282  check_functions_exist(&dm);
283  check_mib_extions_work(&dm);
284 
285  amxo_parser_clean(&parser);
286  amxd_dm_clean(&dm);
287  amxo_resolver_import_close_all();
288 }
check_mib_extions_work
static void check_mib_extions_work(amxd_dm_t *dm)
Definition: test_valid_odl.c:255

◆ test_can_parse_odl_file_no_resolve()

void test_can_parse_odl_file_no_resolve ( UNUSED void **  state)

Definition at line 290 of file test_valid_odl.c.

290  {
291  amxd_dm_t dm;
292  amxc_var_t* lib_dirs = NULL;
293  amxo_parser_t parser;
294  amxc_var_t* odl_resolve = NULL;
295 
296  amxd_dm_init(&dm);
297  amxo_parser_init(&parser);
298 
299  lib_dirs = amxo_parser_get_config(&parser, "import-dirs");
300  odl_resolve = amxo_parser_claim_config(&parser, "odl-resolve");
301  amxc_var_set(bool, odl_resolve, false);
302 
303  amxc_var_add(cstring_t, lib_dirs, "../test_plugin/");
304  amxc_var_dump(&parser.config, STDOUT_FILENO);
305 
306  assert_int_equal(amxo_parser_parse_file(&parser, "test_valid.odl", amxd_dm_get_root(&dm)), 0);
307  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
308 
309  check_options_are_available(&parser);
310  check_objects_exist(&dm);
311  check_parameters_exist(&dm);
312  check_functions_exist(&dm);
313  check_mib_extions_work(&dm);
314 
315  amxo_parser_clean(&parser);
316  amxd_dm_clean(&dm);
317  amxo_resolver_import_close_all();
318 }
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

◆ test_can_parse_string()

void test_can_parse_string ( UNUSED void **  state)

Definition at line 362 of file test_valid_odl.c.

362  {
363  amxd_dm_t dm;
364  amxo_parser_t parser;
365 
366  amxd_dm_init(&dm);
367  amxo_parser_init(&parser);
368 
369  assert_int_equal(amxo_parser_parse_string(&parser, "%config {} %define{} %populate { } %config { }", amxd_dm_get_root(&dm)), 0);
370  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
371  assert_int_equal(amxo_parser_parse_string(&parser, " ", amxd_dm_get_root(&dm)), 0);
372  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
373 
374  amxo_parser_clean(&parser);
375  amxd_dm_clean(&dm);
376 }
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

◆ test_duplicate_func_name()

void test_duplicate_func_name ( UNUSED void **  state)

Definition at line 378 of file test_valid_odl.c.

378  {
379  amxd_dm_t dm;
380  amxo_parser_t parser;
381  const char* odl = "%define { object Test { void F1(); void F2(); void F1(); } }";
382 
383  amxd_dm_init(&dm);
384  amxo_parser_init(&parser);
385 
386  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
387  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
388 
389  amxo_parser_clean(&parser);
390  amxd_dm_clean(&dm);
391 }
odl
include test_include odl
Definition: test_valid.odl:66

◆ test_object_has_event()

void test_object_has_event ( UNUSED void **  state)

Definition at line 393 of file test_valid_odl.c.

393  {
394  amxd_dm_t dm;
395  amxo_parser_t parser;
396  amxd_object_t* obj = NULL;
397  amxc_var_t events;
398  amxc_var_t* lib_dirs = NULL;
399 
400  amxd_dm_init(&dm);
401  amxo_parser_init(&parser);
402  amxc_var_init(&events);
403 
404  lib_dirs = amxo_parser_get_config(&parser, "import-dirs");
405  amxc_var_add(cstring_t, lib_dirs, "../test_plugin/");
406  amxc_var_dump(&parser.config, STDOUT_FILENO);
407 
408  assert_int_equal(amxo_parser_parse_file(&parser, "test_valid.odl", amxd_dm_get_root(&dm)), 0);
409  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
410 
411  obj = amxd_dm_findf(&dm, "TestObjectRoot.TestObjectEvent.");
412  assert_non_null(obj);
413  assert_int_equal(amxd_object_describe_events(obj, &events, amxd_dm_access_protected), 0);
414  assert_non_null(GETP_ARG(&events, "0"));
415 
416  amxc_var_clean(&events);
417  amxo_parser_clean(&parser);
418  amxd_dm_clean(&dm);
419 }
events
static amxc_var_t events
Definition: test_events.c:92