libamxo  4.3.4
Object Definition Language (ODL) parsing
Functions
test_include.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_parameter.h>
#include <amxo/amxo.h>
#include "test_include.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

void test_can_include_empty_file (UNUSED void **state)
 
void test_can_include_between_sections (UNUSED void **state)
 
void test_none_existing_include_file (UNUSED void **state)
 
void test_none_existing_optional_include_file (UNUSED void **state)
 
void test_recursive_include_detection (UNUSED void **state)
 
void test_recursive_dir_include_detection (UNUSED void **state)
 
void test_include_absolute_path (UNUSED void **state)
 
void test_post_include (UNUSED void **state)
 
void test_can_include_directory (UNUSED void **state)
 
void test_empty_directory (UNUSED void **state)
 
void test_conditional_include_with_empty_directory_takes_second (UNUSED void **state)
 
void test_composite_config_options_are_extended (UNUSED void **state)
 
void test_global_nested_include (UNUSED void **state)
 

Function Documentation

◆ test_can_include_between_sections()

void test_can_include_between_sections ( UNUSED void **  state)

Definition at line 96 of file test_include.c.

96  {
97  amxd_dm_t dm;
98  amxo_parser_t parser;
99  const char* odl =
100  "include \"empty.odl\";" \
101  "%config { }" \
102  "include \"empty.odl\";" \
103  "%define { }" \
104  "include \"empty.odl\";" \
105  "%populate { }" \
106  "include \"empty.odl\";";
107 
108  amxd_dm_init(&dm);
109  amxo_parser_init(&parser);
110 
111  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
112  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
113 
114  amxo_parser_clean(&parser);
115  amxd_dm_clean(&dm);
116 }
odl
include test_include odl
Definition: test_valid.odl:66
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

◆ test_can_include_directory()

void test_can_include_directory ( UNUSED void **  state)

Definition at line 228 of file test_include.c.

228  {
229  amxd_dm_t dm;
230  amxo_parser_t parser;
231  const char* odl = "include \"main.odl\";";
232 
233  amxd_dm_init(&dm);
234  amxo_parser_init(&parser);
235 
236  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
237  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
238 
239  assert_non_null(amxd_dm_findf(&dm, "MainObject.InstanceObject.default"));
240  assert_non_null(amxd_dm_findf(&dm, "MainObject.InstanceObject.1"));
241  assert_non_null(amxd_dm_findf(&dm, "MainObject.InstanceObject.2"));
242  assert_non_null(amxd_dm_findf(&dm, "MainObject.InstanceObject.3"));
243 
244  amxo_parser_clean(&parser);
245  amxd_dm_clean(&dm);
246 }

◆ test_can_include_empty_file()

void test_can_include_empty_file ( UNUSED void **  state)

Definition at line 81 of file test_include.c.

81  {
82  amxd_dm_t dm;
83  amxo_parser_t parser;
84  const char* odl = "include \"empty.odl\";";
85 
86  amxd_dm_init(&dm);
87  amxo_parser_init(&parser);
88 
89  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
90  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
91 
92  amxo_parser_clean(&parser);
93  amxd_dm_clean(&dm);
94 }

◆ test_composite_config_options_are_extended()

void test_composite_config_options_are_extended ( UNUSED void **  state)

Definition at line 281 of file test_include.c.

281  {
282  amxd_dm_t dm;
283  amxo_parser_t parser;
284  const char* odl = "./composite_config/config_main.odl";
285 
286  amxd_dm_init(&dm);
287  amxo_parser_init(&parser);
288 
289  assert_int_equal(amxo_parser_parse_file(&parser, odl, amxd_dm_get_root(&dm)), 0);
290 
291  assert_non_null(GETP_ARG(&parser.config, "ubus.watch-ubus-events"));
292  assert_non_null(GETP_ARG(&parser.config, "ubus.register-on-start-event"));
293 
294  amxo_parser_clean(&parser);
295  amxd_dm_clean(&dm);
296 }
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::config
amxc_var_t config
Definition: amxo_types.h:250

◆ test_conditional_include_with_empty_directory_takes_second()

void test_conditional_include_with_empty_directory_takes_second ( UNUSED void **  state)

Definition at line 262 of file test_include.c.

262  {
263  amxd_dm_t dm;
264  amxo_parser_t parser;
265  const char* odl = "include \"./empty_dir/\":\"./main.odl\";";
266 
267  amxd_dm_init(&dm);
268  amxo_parser_init(&parser);
269 
270  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
271  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
272  assert_non_null(amxd_dm_findf(&dm, "MainObject.InstanceObject.default"));
273  assert_non_null(amxd_dm_findf(&dm, "MainObject.InstanceObject.1"));
274  assert_non_null(amxd_dm_findf(&dm, "MainObject.InstanceObject.2"));
275  assert_non_null(amxd_dm_findf(&dm, "MainObject.InstanceObject.3"));
276 
277  amxo_parser_clean(&parser);
278  amxd_dm_clean(&dm);
279 }

◆ test_empty_directory()

void test_empty_directory ( UNUSED void **  state)

Definition at line 248 of file test_include.c.

248  {
249  amxd_dm_t dm;
250  amxo_parser_t parser;
251  const char* odl = "include \"./empty_dir/\";";
252 
253  amxd_dm_init(&dm);
254  amxo_parser_init(&parser);
255 
256  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
257 
258  amxo_parser_clean(&parser);
259  amxd_dm_clean(&dm);
260 }

◆ test_global_nested_include()

void test_global_nested_include ( UNUSED void **  state)

Definition at line 298 of file test_include.c.

298  {
299  amxd_dm_t dm;
300  amxo_parser_t parser;
301  const char* odl = "./composite_config/config_main.odl";
302  amxc_var_t* requires = NULL;
303  const amxc_llist_t* rl = NULL;
304  int index = 0;
305  const char* expected[] = { "Test1", "Test2", "Test3" };
306 
307  amxd_dm_init(&dm);
308  amxo_parser_init(&parser);
309 
310  assert_int_equal(amxo_parser_parse_file(&parser, odl, amxd_dm_get_root(&dm)), 0);
311 
312  requires = GETP_ARG(&parser.config, "requires");
313  assert_non_null(requires);
314  assert_int_equal(amxc_var_type_of(requires), AMXC_VAR_ID_LIST);
315 
316  rl = amxc_var_constcast(amxc_llist_t, requires);
317  assert_int_equal(amxc_llist_size(rl), 3);
318 
319  amxc_var_for_each(r, requires) {
320  assert_string_equal(expected[index], GET_CHAR(r, NULL));
321  index++;
322  }
323 
324  amxo_parser_clean(&parser);
325  amxd_dm_clean(&dm);
326 }

◆ test_include_absolute_path()

void test_include_absolute_path ( UNUSED void **  state)

Definition at line 178 of file test_include.c.

178  {
179  amxd_dm_t dm;
180  amxo_parser_t parser;
181  char* abs_path = realpath("empty.odl", NULL);
182  char odl[8192];
183 
184  amxd_dm_init(&dm);
185  amxo_parser_init(&parser);
186 
187  sprintf(odl, "include \"%s\";", abs_path);
188  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
189  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
190 
191  sprintf(odl, "include \"/tmp/fake.odl\";");
192  assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
193  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_file_not_found);
194 
195  free(abs_path);
196  amxo_parser_clean(&parser);
197  amxd_dm_clean(&dm);
198 }

◆ test_none_existing_include_file()

void test_none_existing_include_file ( UNUSED void **  state)

Definition at line 118 of file test_include.c.

118  {
119  amxd_dm_t dm;
120  amxo_parser_t parser;
121  const char* odl = "include \"does_not_exists.odl\";";
122 
123  amxd_dm_init(&dm);
124  amxo_parser_init(&parser);
125 
126  assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
127  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_file_not_found);
128 
129  amxo_parser_clean(&parser);
130  amxd_dm_clean(&dm);
131 }

◆ test_none_existing_optional_include_file()

void test_none_existing_optional_include_file ( UNUSED void **  state)

Definition at line 133 of file test_include.c.

133  {
134  amxd_dm_t dm;
135  amxo_parser_t parser;
136  const char* odl = "#include \"does_not_exists.odl\";";
137 
138  amxd_dm_init(&dm);
139  amxo_parser_init(&parser);
140 
141  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
142  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
143 
144  amxo_parser_clean(&parser);
145  amxd_dm_clean(&dm);
146 }

◆ test_post_include()

void test_post_include ( UNUSED void **  state)

Definition at line 200 of file test_include.c.

200  {
201  amxd_dm_t dm;
202  amxo_parser_t parser;
203  char* abs_path = realpath("empty.odl", NULL);
204  char odl[8192];
205 
206  amxd_dm_init(&dm);
207  amxo_parser_init(&parser);
208 
209  sprintf(odl, "&include \"%s\";", abs_path);
210  assert_int_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
211  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
212 
213  assert_true(dm.sigmngr.enabled);
214 
215  sprintf(odl, "&include \"/tmp/fake.odl\";");
216  assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
217  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_file_not_found);
218 
219  assert_int_equal(amxo_parser_invoke_entry_points(&parser, &dm, 0), 0);
220 
221  assert_true(dm.sigmngr.enabled);
222 
223  free(abs_path);
224  amxo_parser_clean(&parser);
225  amxd_dm_clean(&dm);
226 }
amxo_parser_invoke_entry_points
int amxo_parser_invoke_entry_points(amxo_parser_t *parser, amxd_dm_t *dm, int reason)
Invokes all registered entry points.
Definition: amxo_parser_main.c:493

◆ test_recursive_dir_include_detection()

void test_recursive_dir_include_detection ( UNUSED void **  state)

Definition at line 163 of file test_include.c.

163  {
164  amxd_dm_t dm;
165  amxo_parser_t parser;
166  const char* odl = "include \"./recursive_dir/\";";
167 
168  amxd_dm_init(&dm);
169  amxo_parser_init(&parser);
170 
171  assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
172  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_unknown_error);
173 
174  amxo_parser_clean(&parser);
175  amxd_dm_clean(&dm);
176 }

◆ test_recursive_include_detection()

void test_recursive_include_detection ( UNUSED void **  state)

Definition at line 148 of file test_include.c.

148  {
149  amxd_dm_t dm;
150  amxo_parser_t parser;
151  const char* odl = "include \"test1.odl\";";
152 
153  amxd_dm_init(&dm);
154  amxo_parser_init(&parser);
155 
156  assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
157  assert_int_equal(amxo_parser_get_status(&parser), amxd_status_unknown_error);
158 
159  amxo_parser_clean(&parser);
160  amxd_dm_clean(&dm);
161 }