libamxo  4.3.4
Object Definition Language (ODL) parsing
test_save.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_signal.h>
73 #include <amxd/amxd_dm.h>
74 #include <amxd/amxd_object.h>
75 #include <amxd/amxd_parameter.h>
76 #include <amxo/amxo.h>
77 #include <amxo/amxo_save.h>
78 
79 #include "test_save.h"
80 
81 #include <amxc/amxc_macros.h>
82 void test_save_config_array(UNUSED void** state) {
83  amxd_dm_t dm;
84  amxo_parser_t parser;
85  amxc_var_t config_options;
86  amxc_var_t* the_array = NULL;
87 
88  amxc_var_init(&config_options);
89  amxc_var_set_type(&config_options, AMXC_VAR_ID_HTABLE);
90  the_array = amxc_var_add_key(amxc_llist_t, &config_options, "MyArray", NULL);
91  amxc_var_add(uint32_t, the_array, 100);
92  amxc_var_add(int32_t, the_array, -100);
93  amxc_var_add(bool, the_array, true);
94  amxc_var_add(bool, the_array, false);
95  amxc_var_add(cstring_t, the_array, "Text");
96  amxc_var_add(csv_string_t, the_array, "Text,text");
97  amxc_var_add(ssv_string_t, the_array, "Text text");
98  amxc_var_add(uint64_t, the_array, 100);
99  amxc_var_add(int64_t, the_array, -100);
100 
101  amxd_dm_init(&dm);
102  amxo_parser_init(&parser);
103 
104  assert_int_equal(amxo_parser_save_config(&parser, "test_config.odl", &config_options, false), 0);
105 
106  assert_ptr_equal(amxo_parser_get_config(&parser, "MyArray"), NULL);
107  assert_int_equal(amxo_parser_parse_file(&parser, "test_config.odl", amxd_dm_get_root(&dm)), 0);
108  amxc_var_dump(&parser.config, STDOUT_FILENO);
109  assert_ptr_not_equal(amxo_parser_get_config(&parser, "MyArray"), NULL);
110 
111  unlink("test_config.odl");
112 
113  amxo_parser_clean(&parser);
114  amxd_dm_clean(&dm);
115  amxc_var_clean(&config_options);
116 }
117 
118 void test_config_arrays_can_contain_tables(UNUSED void** state) {
119  amxd_dm_t dm;
120  amxo_parser_t parser;
121  amxc_var_t config_options;
122  amxc_var_t* the_array = NULL;
123 
124  amxc_var_init(&config_options);
125  amxc_var_set_type(&config_options, AMXC_VAR_ID_HTABLE);
126  the_array = amxc_var_add_key(amxc_llist_t, &config_options, "MyArray", NULL);
127  amxc_var_add(amxc_htable_t, the_array, NULL);
128 
129  amxd_dm_init(&dm);
130  amxo_parser_init(&parser);
131 
132  assert_int_equal(amxo_parser_save_config(&parser, "test_config.odl", &config_options, false), 0);
133  assert_int_equal(amxo_parser_parse_file(&parser, "test_config.odl", amxd_dm_get_root(&dm)), 0);
134  amxc_var_dump(&parser.config, STDOUT_FILENO);
135  assert_ptr_not_equal(amxo_parser_get_config(&parser, "MyArray"), NULL);
136 
137  unlink("test_config.odl");
138 
139  amxo_parser_clean(&parser);
140  amxd_dm_clean(&dm);
141  amxc_var_clean(&config_options);
142 }
143 
144 void test_save_config_key_value_pairs(UNUSED void** state) {
145  amxd_dm_t dm;
146  amxo_parser_t parser;
147  amxc_var_t config_options;
148  amxc_var_t* the_table = NULL;
149 
150  amxc_var_init(&config_options);
151  amxc_var_set_type(&config_options, AMXC_VAR_ID_HTABLE);
152  the_table = amxc_var_add_key(amxc_htable_t, &config_options, "populate_behavior", NULL);
153  amxc_var_add_key(cstring_t, the_table, "unknown_parameter", "add");
154  amxc_var_add_key(cstring_t, the_table, "duplicate_instance", "update");
155 
156  amxd_dm_init(&dm);
157  amxo_parser_init(&parser);
158 
159  assert_int_equal(amxo_parser_save_config(&parser, "test_config.odl", &config_options, false), 0);
160 
161  assert_ptr_equal(amxo_parser_get_config(&parser, "populate_behavior"), NULL);
162  assert_int_equal(amxo_parser_parse_file(&parser, "test_config.odl", amxd_dm_get_root(&dm)), 0);
163  amxc_var_dump(&parser.config, STDOUT_FILENO);
164  assert_ptr_not_equal(amxo_parser_get_config(&parser, "populate_behavior"), NULL);
165 
166  unlink("test_config.odl");
167 
168  amxo_parser_clean(&parser);
169  amxd_dm_clean(&dm);
170  amxc_var_clean(&config_options);
171 }
172 
173 void test_config_tables_can_be_composite(UNUSED void** state) {
174  amxd_dm_t dm;
175  amxo_parser_t parser;
176  amxc_var_t config_options;
177  amxc_var_t* the_table = NULL;
178 
179  amxc_var_init(&config_options);
180  amxc_var_set_type(&config_options, AMXC_VAR_ID_HTABLE);
181  the_table = amxc_var_add_key(amxc_htable_t, &config_options, "populate_behavior", NULL);
182  amxc_var_add_key(amxc_htable_t, the_table, "some_key", NULL);
183  amxc_var_add_key(amxc_llist_t, the_table, "other_key", NULL);
184 
185  amxd_dm_init(&dm);
186  amxo_parser_init(&parser);
187 
188  assert_int_equal(amxo_parser_save_config(&parser, "test_config.odl", &config_options, false), 0);
189  assert_int_equal(amxo_parser_parse_file(&parser, "test_config.odl", amxd_dm_get_root(&dm)), 0);
190  amxc_var_dump(&parser.config, STDOUT_FILENO);
191  assert_ptr_not_equal(amxo_parser_get_config(&parser, "populate_behavior"), NULL);
192 
193  unlink("test_config.odl");
194 
195  amxo_parser_clean(&parser);
196  amxd_dm_clean(&dm);
197  amxc_var_clean(&config_options);
198 }
199 
200 void test_config_tables_keys_can_contain_symbols(UNUSED void** state) {
201  amxd_dm_t dm;
202  amxo_parser_t parser;
203  amxc_var_t config_options;
204  amxc_var_t* the_table = NULL;
205 
206  amxc_var_init(&config_options);
207  amxc_var_set_type(&config_options, AMXC_VAR_ID_HTABLE);
208  the_table = amxc_var_add_key(amxc_htable_t, &config_options, "populate_behavior", NULL);
209  amxc_var_add_key(cstring_t, the_table, "%some_key", "value");
210  amxc_var_add_key(cstring_t, the_table, "key.with.dots", "SomeValue");
211  the_table = amxc_var_add_key(amxc_htable_t, &config_options, "root.key.with.dots", NULL);
212  amxc_var_add_key(cstring_t, the_table, "$key", "value");
213 
214  amxd_dm_init(&dm);
215  amxo_parser_init(&parser);
216 
217  assert_int_equal(amxo_parser_save_config(&parser, "test_config.odl", &config_options, false), 0);
218  assert_int_equal(amxo_parser_parse_file(&parser, "test_config.odl", amxd_dm_get_root(&dm)), 0);
219  amxc_var_dump(&parser.config, STDOUT_FILENO);
220  assert_ptr_not_equal(amxo_parser_get_config(&parser, "populate_behavior"), NULL);
221  assert_ptr_not_equal(amxo_parser_get_config(&parser, "populate_behavior.'key.with.dots'"), NULL);
222  assert_ptr_not_equal(amxo_parser_get_config(&parser, "'root.key.with.dots'.$key"), NULL);
223 
224  amxo_parser_clean(&parser);
225  amxd_dm_clean(&dm);
226  amxc_var_clean(&config_options);
227 }
228 
229 void test_save_config_values(UNUSED void** state) {
230  amxd_dm_t dm;
231  amxo_parser_t parser;
232  amxc_var_t config_options;
233  amxc_ts_t now;
234 
235  amxc_ts_now(&now);
236 
237  amxc_var_init(&config_options);
238  amxc_var_set_type(&config_options, AMXC_VAR_ID_HTABLE);
239  amxc_var_add_key(bool, &config_options, "enable_auto_detect", true);
240  amxc_var_add_key(uint32_t, &config_options, "iteratations", 10);
241  amxc_var_add_key(amxc_ts_t, &config_options, "time", &now);
242  amxc_var_add_key(amxc_llist_t, &config_options, "requires", NULL);
243 
244  amxd_dm_init(&dm);
245  amxo_parser_init(&parser);
246 
247  assert_int_equal(amxo_parser_save_config(&parser, "test_config.odl", &config_options, false), 0);
248 
249  assert_ptr_equal(amxo_parser_get_config(&parser, "enable_auto_detect"), NULL);
250  assert_ptr_equal(amxo_parser_get_config(&parser, "iteratations"), NULL);
251  assert_ptr_equal(amxo_parser_get_config(&parser, "time"), NULL);
252  assert_int_equal(amxo_parser_parse_file(&parser, "test_config.odl", amxd_dm_get_root(&dm)), 0);
253  amxc_var_dump(&parser.config, STDOUT_FILENO);
254  assert_ptr_not_equal(amxo_parser_get_config(&parser, "enable_auto_detect"), NULL);
255  assert_ptr_not_equal(amxo_parser_get_config(&parser, "iteratations"), NULL);
256  assert_ptr_not_equal(amxo_parser_get_config(&parser, "time"), NULL);
257 
258  unlink("test_config.odl");
259 
260  amxc_var_clean(&config_options);
261  amxo_parser_clean(&parser);
262  amxd_dm_clean(&dm);
263 }
264 
265 void test_save_config_succeeds_when_using_keys_with_symbols(UNUSED void** state) {
266  amxd_dm_t dm;
267  amxo_parser_t parser;
268  amxc_var_t config_options;
269  amxc_ts_t now;
270 
271  amxc_ts_now(&now);
272 
273  amxc_var_init(&config_options);
274  amxc_var_set_type(&config_options, AMXC_VAR_ID_HTABLE);
275  amxc_var_add_key(bool, &config_options, "%enable_auto_detect", true);
276  amxc_var_add_key(uint32_t, &config_options, "1234AAQ", 10);
277  amxc_var_add_key(amxc_ts_t, &config_options, "Test=Value", &now);
278 
279  amxd_dm_init(&dm);
280  amxo_parser_init(&parser);
281 
282  assert_int_equal(amxo_parser_save_config(&parser, "test_config.odl", &config_options, false), 0);
283  assert_int_equal(amxo_parser_parse_file(&parser, "test_config.odl", amxd_dm_get_root(&dm)), 0);
284  amxc_var_dump(&parser.config, STDOUT_FILENO);
285  assert_ptr_not_equal(amxo_parser_get_config(&parser, "%enable_auto_detect"), NULL);
286  assert_ptr_not_equal(amxo_parser_get_config(&parser, "Test=Value"), NULL);
287 
288  unlink("test_config.odl");
289 
290  amxc_var_clean(&config_options);
291  amxo_parser_clean(&parser);
292  amxd_dm_clean(&dm);
293 }
294 
295 void test_save_config_fails_for_unsupported_data_types(UNUSED void** state) {
296  amxd_dm_t dm;
297  amxo_parser_t parser;
298  amxc_var_t config_options;
299 
300  amxc_var_init(&config_options);
301  amxc_var_set_type(&config_options, AMXC_VAR_ID_HTABLE);
302  amxc_var_add_key(double, &config_options, "1234AAQ", 10.3);
303  amxc_var_add_key(fd_t, &config_options, "Test=Value", 22);
304 
305  amxd_dm_init(&dm);
306  amxo_parser_init(&parser);
307 
308  assert_int_not_equal(amxo_parser_save_config(&parser, "test_config.odl", &config_options, false), 0);
309 
310  amxc_var_clean(&config_options);
311  amxo_parser_clean(&parser);
312  amxd_dm_clean(&dm);
313 }
314 
315 void test_save_can_append_config_values(UNUSED void** state) {
316  amxd_dm_t dm;
317  amxo_parser_t parser;
318  amxc_var_t config_options;
319  amxc_ts_t now;
320 
321  amxc_ts_now(&now);
322 
323  amxc_var_init(&config_options);
324  amxc_var_set_type(&config_options, AMXC_VAR_ID_HTABLE);
325  amxc_var_add_key(bool, &config_options, "enable_auto_detect", true);
326  amxc_var_add_key(uint32_t, &config_options, "iteratations", 10);
327  amxc_var_add_key(amxc_ts_t, &config_options, "time", &now);
328 
329  amxd_dm_init(&dm);
330  amxo_parser_init(&parser);
331 
332  assert_int_equal(amxo_parser_save_config(&parser, "test_config.odl", &config_options, false), 0);
333 
334  amxc_var_clean(&config_options);
335  amxc_var_set_type(&config_options, AMXC_VAR_ID_HTABLE);
336  amxc_var_add_key(bool, &config_options, "fixed_dir", true);
337  amxc_var_add_key(uint32_t, &config_options, "max_objects", 10);
338 
339  assert_int_equal(amxo_parser_save_config(&parser, "test_config.odl", &config_options, true), 0);
340 
341  assert_ptr_equal(amxo_parser_get_config(&parser, "enable_auto_detect"), NULL);
342  assert_ptr_equal(amxo_parser_get_config(&parser, "iteratations"), NULL);
343  assert_ptr_equal(amxo_parser_get_config(&parser, "time"), NULL);
344  assert_ptr_equal(amxo_parser_get_config(&parser, "fixed_dir"), NULL);
345  assert_ptr_equal(amxo_parser_get_config(&parser, "max_objects"), NULL);
346  assert_int_equal(amxo_parser_parse_file(&parser, "test_config.odl", amxd_dm_get_root(&dm)), 0);
347  amxc_var_dump(&parser.config, STDOUT_FILENO);
348  assert_ptr_not_equal(amxo_parser_get_config(&parser, "enable_auto_detect"), NULL);
349  assert_ptr_not_equal(amxo_parser_get_config(&parser, "iteratations"), NULL);
350  assert_ptr_not_equal(amxo_parser_get_config(&parser, "time"), NULL);
351  assert_ptr_not_equal(amxo_parser_get_config(&parser, "fixed_dir"), NULL);
352  assert_ptr_not_equal(amxo_parser_get_config(&parser, "max_objects"), NULL);
353 
354  unlink("test_config.odl");
355 
356  amxc_var_clean(&config_options);
357  amxo_parser_clean(&parser);
358  amxd_dm_clean(&dm);
359 }
360 
361 void test_can_save_object(UNUSED void** state) {
362  amxd_dm_t dm;
363  amxo_parser_t parser;
364  amxd_object_t* object = NULL;
365  amxd_object_t* instance = NULL;
366  amxc_var_t values;
367 
368  amxd_dm_init(&dm);
369  amxo_parser_init(&parser);
370  amxc_var_init(&values);
371  amxc_var_set_type(&values, AMXC_VAR_ID_HTABLE);
372  amxc_var_add_key(cstring_t, &values, "Text", "Key3");
373 
374  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
375  object = amxd_dm_findf(&dm, "MyRootObject.ChildObject.TemplateObject");
376  assert_ptr_not_equal(object, NULL);
377  assert_int_equal(amxd_object_add_instance(&instance, object, NULL, 3, &values), 0);
378 
379  assert_int_equal(amxo_parser_save_object(&parser, "test_save.odl", object, false), 0);
380  amxd_dm_clean(&dm);
381  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
382  object = amxd_dm_findf(&dm, "MyRootObject.ChildObject.TemplateObject.3");
383  assert_ptr_not_equal(object, NULL);
384 
385  object = amxd_dm_findf(&dm, "MyRootObject");
386  assert_int_equal(amxo_parser_save(&parser, "test_save.odl", object, 2, NULL, false), 0);
387  amxd_dm_clean(&dm);
388  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
389  object = amxd_dm_findf(&dm, "MyRootObject.ChildObject");
390  assert_ptr_not_equal(object, NULL);
391  object = amxd_dm_findf(&dm, "MyRootObject.ChildObject.TemplateObject.3");
392  assert_ptr_equal(object, NULL);
393 
394  unlink("test_save.odl");
395  amxc_var_clean(&values);
396  amxo_parser_clean(&parser);
397  amxd_dm_clean(&dm);
398 }
399 
400 void test_can_save_from_root(UNUSED void** state) {
401  amxd_dm_t dm;
402  amxo_parser_t parser;
403 
404  amxd_dm_init(&dm);
405  amxo_parser_init(&parser);
406 
407  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
408  assert_int_equal(amxo_parser_save_object(&parser, "test_save.odl", amxd_dm_get_root(&dm), false), 0);
409  amxd_dm_clean(&dm);
410 
411  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
412 
413  unlink("test_save.odl");
414  amxo_parser_clean(&parser);
415  amxd_dm_clean(&dm);
416 }
417 
418 void test_can_save_instance(UNUSED void** state) {
419  amxd_dm_t dm;
420  amxo_parser_t parser;
421  amxd_object_t* object = NULL;
422 
423  amxd_dm_init(&dm);
424  amxo_parser_init(&parser);
425 
426  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
427  object = amxd_dm_findf(&dm, "MyRootObject.ChildObject.TemplateObject.1");
428  assert_int_equal(amxo_parser_save_object(&parser, "test_save.odl", object, false), 0);
429  amxd_dm_clean(&dm);
430 
431  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
432  object = amxd_dm_findf(&dm, "MyRootObject.ChildObject.TemplateObject.1");
433  assert_ptr_not_equal(object, NULL);
434  object = amxd_dm_findf(&dm, "MyRootObject.ChildObject.TemplateObject.2");
435  assert_ptr_equal(object, NULL);
436 
437  unlink("test_save.odl");
438  amxo_parser_clean(&parser);
439  amxd_dm_clean(&dm);
440 }
441 
442 void test_can_save_load_objects_with_keyword_names(UNUSED void** state) {
443  amxd_dm_t dm;
444  amxo_parser_t parser;
445  amxd_object_t* object = NULL;
446 
447  amxd_dm_init(&dm);
448  amxo_parser_init(&parser);
449 
450  assert_int_equal(amxo_parser_parse_file(&parser, "test_keyword_names.odl", amxd_dm_get_root(&dm)), 0);
451  object = amxd_dm_findf(&dm, "MainObject");
452  assert_int_equal(amxo_parser_save_object(&parser, "test_save.odl", object, false), 0);
453  object = amxd_dm_findf(&dm, "MainObject.InstanceObject.1");
454  amxd_object_delete(&object);
455 
456  assert_int_equal(amxo_parser_parse_file(&parser, "test_save.odl", amxd_dm_get_root(&dm)), 0);
457  object = amxd_dm_findf(&dm, "MainObject.InstanceObject.1");
458  assert_non_null(object);
459 
460  unlink("test_save.odl");
461  amxo_parser_clean(&parser);
462  amxd_dm_clean(&dm);
463 }
464 
465 void test_save_fails_if_file_can_not_be_opened(UNUSED void** state) {
466  amxd_dm_t dm;
467  amxo_parser_t parser;
468  amxd_object_t* object = NULL;
469 
470  amxd_dm_init(&dm);
471  amxo_parser_init(&parser);
472 
473  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
474  assert_int_not_equal(amxo_parser_save_object(&parser, "/fake_dir/test_save.odl", object, false), 0);
475 
476  amxo_parser_clean(&parser);
477  amxd_dm_clean(&dm);
478 }
479 
480 void test_save_fails_if_append_to_none_existing_file(UNUSED void** state) {
481  amxd_dm_t dm;
482  amxo_parser_t parser;
483  amxd_object_t* object = NULL;
484 
485  amxd_dm_init(&dm);
486  amxo_parser_init(&parser);
487 
488  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
489  assert_int_not_equal(amxo_parser_save_object(&parser, "none_existing.odl", object, true), 0);
490 
491  amxo_parser_clean(&parser);
492  amxd_dm_clean(&dm);
493 }
494 
495 void test_save_takes_rw_data_path_into_account(UNUSED void** state) {
496  amxd_dm_t dm;
497  amxo_parser_t parser;
498  amxc_var_t* rw_data_path = NULL;
499  int fd = -1;
500 
501  amxd_dm_init(&dm);
502  amxo_parser_init(&parser);
503 
504  rw_data_path = amxo_parser_claim_config(&parser, "rw_data_path");
505  amxc_var_set(cstring_t, rw_data_path, "/tmp");
506  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
507  assert_int_equal(amxo_parser_save_object(&parser, "${rw_data_path}/test_save.odl", amxd_dm_get_root(&dm), false), 0);
508 
509  fd = open("/tmp/test_save.odl", O_RDONLY);
510  assert_int_not_equal(fd, -1);
511  close(fd);
512  unlink("/tmp/test_save.odl");
513 
514  amxo_parser_clean(&parser);
515  amxd_dm_clean(&dm);
516 }
517 
518 void test_save_can_change_buffer_size(UNUSED void** state) {
519  amxd_dm_t dm;
520  amxo_parser_t parser;
521  amxc_var_t* buffer_size = NULL;
522  int fd = -1;
523 
524  amxd_dm_init(&dm);
525  amxo_parser_init(&parser);
526 
527  buffer_size = amxo_parser_claim_config(&parser, "odl.buffer-size");
528  amxc_var_set(int32_t, buffer_size, 128);
529  assert_int_equal(amxo_parser_parse_file(&parser, "test_main.odl", amxd_dm_get_root(&dm)), 0);
530  assert_int_equal(amxo_parser_save_object(&parser, "/tmp/test_save.odl", amxd_dm_get_root(&dm), false), 0);
531 
532  fd = open("/tmp/test_save.odl", O_RDONLY);
533  assert_int_not_equal(fd, -1);
534  close(fd);
535  unlink("/tmp/test_save.odl");
536 
537  amxo_parser_clean(&parser);
538  amxd_dm_clean(&dm);
539 }
540 
541 void test_can_save_load_parameter_values_with_special_characters(UNUSED void** state) {
542  amxd_dm_t dm;
543  amxo_parser_t parser;
544  amxd_object_t* object = NULL;
545  char* value = NULL;
546 
547  amxd_dm_init(&dm);
548  amxo_parser_init(&parser);
549 
550  assert_int_equal(amxo_parser_parse_file(&parser, "test_special_values.odl", amxd_dm_get_root(&dm)), 0);
551  object = amxd_dm_findf(&dm, "MainObject.InstanceObject.1");
552  assert_non_null(object);
553  value = amxd_object_get_value(cstring_t, object, "TextA", NULL);
554  assert_string_equal(value, "\"Hello\"");
555  free(value);
556  value = amxd_object_get_value(cstring_t, object, "TextB", NULL);
557  assert_string_equal(value, "\"Hello\"");
558  free(value);
559  value = amxd_object_get_value(cstring_t, object, "TextC", NULL);
560  assert_string_equal(value, "A'B");
561  free(value);
562  value = amxd_object_get_value(cstring_t, object, "TextD", NULL);
563  assert_string_equal(value, "A\"B");
564  free(value);
565  object = amxd_dm_findf(&dm, "MainObject.InstanceObject.2");
566  assert_non_null(object);
567  value = amxd_object_get_value(cstring_t, object, "TextA", NULL);
568  assert_string_equal(value, "Text \"with\" single and double 'quotes'");
569  free(value);
570  value = amxd_object_get_value(cstring_t, object, "TextB", NULL);
571  assert_string_equal(value, "${test}");
572  free(value);
573  value = amxd_object_get_value(cstring_t, object, "TextC", NULL);
574  assert_string_equal(value, "");
575  free(value);
576  value = amxd_object_get_value(cstring_t, object, "TextD", NULL);
577  assert_string_equal(value, "$(test)");
578  free(value);
579 
580  object = amxd_dm_findf(&dm, "MainObject");
581  assert_int_equal(amxo_parser_save_object(&parser, "test_save.odl", object, false), 0);
582  object = amxd_dm_findf(&dm, "MainObject.InstanceObject.1");
583  amxd_object_delete(&object);
584  object = amxd_dm_findf(&dm, "MainObject.InstanceObject.2");
585  amxd_object_delete(&object);
586 
587  assert_int_equal(amxo_parser_parse_file(&parser, "test_save.odl", amxd_dm_get_root(&dm)), 0);
588  object = amxd_dm_findf(&dm, "MainObject.InstanceObject.1");
589  assert_non_null(object);
590  value = amxd_object_get_value(cstring_t, object, "TextA", NULL);
591  assert_string_equal(value, "\"Hello\"");
592  free(value);
593  value = amxd_object_get_value(cstring_t, object, "TextB", NULL);
594  assert_string_equal(value, "\"Hello\"");
595  free(value);
596  value = amxd_object_get_value(cstring_t, object, "TextC", NULL);
597  assert_string_equal(value, "A'B");
598  free(value);
599  value = amxd_object_get_value(cstring_t, object, "TextD", NULL);
600  assert_string_equal(value, "A\"B");
601  free(value);
602  object = amxd_dm_findf(&dm, "MainObject.InstanceObject.2");
603  assert_non_null(object);
604  value = amxd_object_get_value(cstring_t, object, "TextA", NULL);
605  assert_string_equal(value, "Text \"with\" single and double 'quotes'");
606  free(value);
607  value = amxd_object_get_value(cstring_t, object, "TextB", NULL);
608  assert_string_equal(value, "${test}");
609  free(value);
610  value = amxd_object_get_value(cstring_t, object, "TextC", NULL);
611  assert_string_equal(value, "");
612  free(value);
613  value = amxd_object_get_value(cstring_t, object, "TextD", NULL);
614  assert_string_equal(value, "$(test)");
615  free(value);
616 
617  unlink("test_save.odl");
618  amxo_parser_clean(&parser);
619  amxd_dm_clean(&dm);
620 }
amxo.h
Ambiorix ODL parser header file.
buffer_size
static size_t buffer_size
Definition: amxo_save.c:84
amxo_save.h
amxo_parser_save_object
int amxo_parser_save_object(amxo_parser_t *pctx, const char *filename, amxd_object_t *object, bool append)
Definition: amxo_save.c:755
amxo_parser_save_config
int amxo_parser_save_config(amxo_parser_t *pctx, const char *filename, amxc_var_t *config, bool append)
Definition: amxo_save.c:748
amxo_parser_save
int amxo_parser_save(amxo_parser_t *pctx, const char *filename, amxd_object_t *object, uint32_t depth, amxc_var_t *config, bool append)
Definition: amxo_save.c:700
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
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_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_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::config
amxc_var_t config
Definition: amxo_types.h:250
UNUSED
#define UNUSED
Definition: test_issue_48.c:84
test_save_config_array
void test_save_config_array(UNUSED void **state)
Definition: test_save.c:82
test_save_takes_rw_data_path_into_account
void test_save_takes_rw_data_path_into_account(UNUSED void **state)
Definition: test_save.c:495
test_save_fails_if_append_to_none_existing_file
void test_save_fails_if_append_to_none_existing_file(UNUSED void **state)
Definition: test_save.c:480
test_save_config_succeeds_when_using_keys_with_symbols
void test_save_config_succeeds_when_using_keys_with_symbols(UNUSED void **state)
Definition: test_save.c:265
test_save_config_key_value_pairs
void test_save_config_key_value_pairs(UNUSED void **state)
Definition: test_save.c:144
test_can_save_load_parameter_values_with_special_characters
void test_can_save_load_parameter_values_with_special_characters(UNUSED void **state)
Definition: test_save.c:541
test_save_can_change_buffer_size
void test_save_can_change_buffer_size(UNUSED void **state)
Definition: test_save.c:518
test_can_save_instance
void test_can_save_instance(UNUSED void **state)
Definition: test_save.c:418
test_save_config_fails_for_unsupported_data_types
void test_save_config_fails_for_unsupported_data_types(UNUSED void **state)
Definition: test_save.c:295
test_config_arrays_can_contain_tables
void test_config_arrays_can_contain_tables(UNUSED void **state)
Definition: test_save.c:118
test_can_save_from_root
void test_can_save_from_root(UNUSED void **state)
Definition: test_save.c:400
test_config_tables_can_be_composite
void test_config_tables_can_be_composite(UNUSED void **state)
Definition: test_save.c:173
test_can_save_object
void test_can_save_object(UNUSED void **state)
Definition: test_save.c:361
test_save_fails_if_file_can_not_be_opened
void test_save_fails_if_file_can_not_be_opened(UNUSED void **state)
Definition: test_save.c:465
test_can_save_load_objects_with_keyword_names
void test_can_save_load_objects_with_keyword_names(UNUSED void **state)
Definition: test_save.c:442
test_save_config_values
void test_save_config_values(UNUSED void **state)
Definition: test_save.c:229
test_save_can_append_config_values
void test_save_can_append_config_values(UNUSED void **state)
Definition: test_save.c:315
test_config_tables_keys_can_contain_symbols
void test_config_tables_keys_can_contain_symbols(UNUSED void **state)
Definition: test_save.c:200
test_save.h