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

Go to the source code of this file.

Functions

void test_save_config_array (UNUSED void **state)
 
void test_config_arrays_can_contain_tables (UNUSED void **state)
 
void test_save_config_key_value_pairs (UNUSED void **state)
 
void test_config_tables_can_be_composite (UNUSED void **state)
 
void test_config_tables_keys_can_contain_symbols (UNUSED void **state)
 
void test_save_config_values (UNUSED void **state)
 
void test_save_config_succeeds_when_using_keys_with_symbols (UNUSED void **state)
 
void test_save_config_fails_for_unsupported_data_types (UNUSED void **state)
 
void test_save_can_append_config_values (UNUSED void **state)
 
void test_can_save_object (UNUSED void **state)
 
void test_can_save_from_root (UNUSED void **state)
 
void test_can_save_instance (UNUSED void **state)
 
void test_can_save_load_objects_with_keyword_names (UNUSED void **state)
 
void test_save_fails_if_file_can_not_be_opened (UNUSED void **state)
 
void test_save_fails_if_append_to_none_existing_file (UNUSED void **state)
 
void test_save_takes_rw_data_path_into_account (UNUSED void **state)
 
void test_save_can_change_buffer_size (UNUSED void **state)
 
void test_can_save_load_parameter_values_with_special_characters (UNUSED void **state)
 

Function Documentation

◆ test_can_save_from_root()

void test_can_save_from_root ( UNUSED void **  state)

Definition at line 400 of file test_save.c.

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

◆ test_can_save_instance()

void test_can_save_instance ( UNUSED void **  state)

Definition at line 418 of file test_save.c.

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

◆ test_can_save_load_objects_with_keyword_names()

void test_can_save_load_objects_with_keyword_names ( UNUSED void **  state)

Definition at line 442 of file test_save.c.

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

◆ test_can_save_load_parameter_values_with_special_characters()

void test_can_save_load_parameter_values_with_special_characters ( UNUSED void **  state)

Definition at line 541 of file test_save.c.

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

◆ test_can_save_object()

void test_can_save_object ( UNUSED void **  state)

Definition at line 361 of file test_save.c.

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

◆ test_config_arrays_can_contain_tables()

void test_config_arrays_can_contain_tables ( UNUSED void **  state)

Definition at line 118 of file test_save.c.

118  {
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 }
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_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::config
amxc_var_t config
Definition: amxo_types.h:250

◆ test_config_tables_can_be_composite()

void test_config_tables_can_be_composite ( UNUSED void **  state)

Definition at line 173 of file test_save.c.

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

◆ test_config_tables_keys_can_contain_symbols()

void test_config_tables_keys_can_contain_symbols ( UNUSED void **  state)

Definition at line 200 of file test_save.c.

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

◆ test_save_can_append_config_values()

void test_save_can_append_config_values ( UNUSED void **  state)

Definition at line 315 of file test_save.c.

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

◆ test_save_can_change_buffer_size()

void test_save_can_change_buffer_size ( UNUSED void **  state)

Definition at line 518 of file test_save.c.

518  {
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 }
buffer_size
static size_t buffer_size
Definition: amxo_save.c:84
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_save_config_array()

void test_save_config_array ( UNUSED void **  state)

Definition at line 82 of file test_save.c.

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

◆ test_save_config_fails_for_unsupported_data_types()

void test_save_config_fails_for_unsupported_data_types ( UNUSED void **  state)

Definition at line 295 of file test_save.c.

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

◆ test_save_config_key_value_pairs()

void test_save_config_key_value_pairs ( UNUSED void **  state)

Definition at line 144 of file test_save.c.

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

◆ test_save_config_succeeds_when_using_keys_with_symbols()

void test_save_config_succeeds_when_using_keys_with_symbols ( UNUSED void **  state)

Definition at line 265 of file test_save.c.

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

◆ test_save_config_values()

void test_save_config_values ( UNUSED void **  state)

Definition at line 229 of file test_save.c.

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

◆ test_save_fails_if_append_to_none_existing_file()

void test_save_fails_if_append_to_none_existing_file ( UNUSED void **  state)

Definition at line 480 of file test_save.c.

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

◆ test_save_fails_if_file_can_not_be_opened()

void test_save_fails_if_file_can_not_be_opened ( UNUSED void **  state)

Definition at line 465 of file test_save.c.

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

◆ test_save_takes_rw_data_path_into_account()

void test_save_takes_rw_data_path_into_account ( UNUSED void **  state)

Definition at line 495 of file test_save.c.

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