libamxrt  0.4.2
Ambiorix Run Time Library
Functions
test_amxrt_save_load.h File Reference
#include <amxrt/amxrt.h>
#include <amxc/amxc.h>
#include <amxp/amxp.h>
#include <amxd/amxd_object.h>
#include <amxo/amxo.h>

Go to the source code of this file.

Functions

int test_save_load_setup (UNUSED void **state)
 
int test_save_load_teardown (UNUSED void **state)
 
void test_can_start_with_no_storage_type (UNUSED void **state)
 
void test_can_start_with_no_odl_storage_type (UNUSED void **state)
 
void test_can_start_with_odl_storage_type (UNUSED void **state)
 
void test_can_start_with_no_storage_path (UNUSED void **state)
 
void test_can_start_with_directory_configured (UNUSED void **state)
 
void test_can_load_files_with_eventing_on_or_off (void **state)
 
void test_start_fails_with_invalid_directory_configured (UNUSED void **state)
 
void test_loads_default_when_valid_dir_is_used (UNUSED void **state)
 
void test_load_fails_with_invalid_dir_and_invalid_defaults (UNUSED void **state)
 
void test_can_save_all_objects (UNUSED void **state)
 
void test_save_fails_when_invalid_dir (UNUSED void **state)
 
void test_can_save_separate_objects_csv (UNUSED void **state)
 
void test_save_separate_objects_fail_when_invalid_dir (UNUSED void **state)
 
void test_can_save_separate_objects_string (UNUSED void **state)
 
void test_does_not_save_when_invalid_objects (UNUSED void **state)
 
void test_save_skips_unknown_objects (UNUSED void **state)
 
void test_can_save_on_changes (UNUSED void **state)
 
void test_saves_when_persistent_parameter_changes (UNUSED void **state)
 
void test_does_not_save_when_not_persistent_parameter_changes (UNUSED void **state)
 
void test_saves_when_instance_deleted (UNUSED void **state)
 
void test_can_save_on_changes_with_object_list (UNUSED void **state)
 
void test_does_not_save_on_changed_when_invalid_objects (UNUSED void **state)
 

Function Documentation

◆ test_can_load_files_with_eventing_on_or_off()

void test_can_load_files_with_eventing_on_or_off ( void **  state)

◆ test_can_save_all_objects()

void test_can_save_all_objects ( UNUSED void **  state)

Definition at line 268 of file test_amxrt_save_load.c.

268  {
269  amxc_var_t* config = amxrt_get_config();
270  amxo_parser_t* parser = amxrt_get_parser();
271  amxd_dm_t* dm = amxrt_get_dm();
272  struct stat statbuf;
273 
274  amxc_var_t* dir = GETP_ARG(config, "odl.dm-defaults");
275  amxc_var_t* save = GETP_ARG(config, "odl.dm-save");
276 
277  amxc_var_delete(&dir);
278 
279  dir = GETP_ARG(config, "odl.directory");
280  amxc_var_set(cstring_t, dir, "./odl");
281  amxc_var_add_key(cstring_t, config, "name", "save_test");
282 
283  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
284  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
285  assert_non_null(amxd_dm_findf(dm, "Test2"));
286  amxc_var_set(bool, save, true);
287  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
288 
289  assert_int_not_equal(stat("./odl/save_test.odl", &statbuf), -1);
290  unlink("./odl/save_test.odl");
291  amxd_dm_clean(dm);
292 }
amxrt_get_config
amxc_var_t * amxrt_get_config(void)
Gets the htable variant containing the configuration options.
Definition: amxrt.c:301
amxrt_dm_save_load_main
int amxrt_dm_save_load_main(int reason, amxd_dm_t *dm, amxo_parser_t *parser)
The data model auto load and save module.
Definition: amxrt_save_load.c:457
amxrt_get_dm
amxd_dm_t * amxrt_get_dm(void)
Gets the runtime data model storage.
Definition: amxrt.c:309
amxrt_get_parser
amxo_parser_t * amxrt_get_parser(void)
Gets runtime odl parser.
Definition: amxrt.c:305
config
config
Definition: test.odl:54

◆ test_can_save_on_changes()

void test_can_save_on_changes ( UNUSED void **  state)

Definition at line 431 of file test_amxrt_save_load.c.

431  {
432  amxc_var_t* config = amxrt_get_config();
433  amxo_parser_t* parser = amxrt_get_parser();
434  amxd_dm_t* dm = amxrt_get_dm();
435 
436  struct stat statbuf;
437  amxd_trans_t transaction;
438  amxc_var_t* odl = GET_ARG(config, "odl");
439  amxc_var_t* objects = GETP_ARG(config, "odl.dm-objects");
440  amxc_var_delete(&objects);
441  amxc_var_add_key(bool, odl, "dm-save-on-changed", true);
442 
443  amxd_dm_init(dm);
444 
445  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
446  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
447  assert_non_null(amxd_dm_findf(dm, "Test2"));
448  amxp_sigmngr_trigger_signal(&dm->sigmngr, "app:start", NULL);
449 
450  handle_events();
451 
452  amxd_trans_init(&transaction);
453  amxd_trans_select_pathf(&transaction, "Test.Table");
454  amxd_trans_add_inst(&transaction, 0, NULL);
455  amxd_trans_set_value(cstring_t, &transaction, "Text", "Hallo");
456  amxd_trans_apply(&transaction, dm);
457  amxd_trans_clean(&transaction);
458 
459  handle_events();
460  read_sigalrm();
461  handle_events();
462  assert_int_not_equal(stat("./odl/save_test.odl", &statbuf), -1);
463 
464  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
465 
466  unlink("./odl/save_test.odl");
467  amxd_dm_clean(dm);
468 }
odl
&include test odl
Definition: post_include.odl:54
read_sigalrm
static void read_sigalrm(void)
Definition: test_amxrt_save_load.c:78
handle_events
static void handle_events(void)
Definition: test_amxrt_save_load.c:69

◆ test_can_save_on_changes_with_object_list()

void test_can_save_on_changes_with_object_list ( UNUSED void **  state)

Definition at line 593 of file test_amxrt_save_load.c.

593  {
594  amxc_var_t* config = amxrt_get_config();
595  amxo_parser_t* parser = amxrt_get_parser();
596  amxd_dm_t* dm = amxrt_get_dm();
597 
598  struct stat statbuf;
599  amxd_trans_t transaction;
600  amxc_var_t* odl = GET_ARG(config, "odl");
601  amxc_var_add_key(csv_string_t, odl, "dm-objects", "Test2");
602 
603  amxd_dm_init(dm);
604 
605  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
606  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
607  assert_non_null(amxd_dm_findf(dm, "Test2"));
608  amxp_sigmngr_trigger_signal(&dm->sigmngr, "app:start", NULL);
609 
610  handle_events();
611 
612  amxd_trans_init(&transaction);
613  amxd_trans_select_pathf(&transaction, "Test2");
614  amxd_trans_set_value(cstring_t, &transaction, "Text", "Hallo");
615  amxd_trans_select_pathf(&transaction, "Test.Table.");
616  amxd_trans_add_inst(&transaction, 0, NULL);
617  amxd_trans_set_value(cstring_t, &transaction, "Text", "Hallo");
618  assert_int_equal(amxd_trans_apply(&transaction, dm), 0);
619  amxd_trans_clean(&transaction);
620 
621  handle_events();
622 
623  amxd_trans_init(&transaction);
624  amxd_trans_select_pathf(&transaction, "Test2");
625  amxd_trans_set_value(cstring_t, &transaction, "Text", "World");
626  assert_int_equal(amxd_trans_apply(&transaction, dm), 0);
627  amxd_trans_clean(&transaction);
628 
629  handle_events();
630  read_sigalrm();
631  handle_events();
632  assert_int_not_equal(stat("./odl/00_Test2.odl", &statbuf), -1);
633  assert_int_equal(stat("./odl/02_Test.odl", &statbuf), -1);
634 
635  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
636 
637  unlink("./odl/00_Test2.odl");
638  amxd_dm_clean(dm);
639 }

◆ test_can_save_separate_objects_csv()

void test_can_save_separate_objects_csv ( UNUSED void **  state)

Definition at line 315 of file test_amxrt_save_load.c.

315  {
316  amxc_var_t* config = amxrt_get_config();
317  amxo_parser_t* parser = amxrt_get_parser();
318  amxd_dm_t* dm = amxrt_get_dm();
319 
320  struct stat statbuf;
321  amxc_var_t* odl = GET_ARG(config, "odl");
322  amxc_var_add_key(csv_string_t, odl, "dm-objects", "Test,Test2.");
323 
324  amxd_dm_init(dm);
325 
326  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
327  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
328  assert_non_null(amxd_dm_findf(dm, "Test2"));
329  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
330 
331 
332  assert_int_not_equal(stat("./odl/00_Test.odl", &statbuf), -1);
333  unlink("./odl/00_Test.odl");
334  assert_int_not_equal(stat("./odl/01_Test2.odl", &statbuf), -1);
335  unlink("./odl/01_Test2.odl");
336  amxd_dm_clean(dm);
337 }

◆ test_can_save_separate_objects_string()

void test_can_save_separate_objects_string ( UNUSED void **  state)

Definition at line 362 of file test_amxrt_save_load.c.

362  {
363  amxc_var_t* config = amxrt_get_config();
364  amxo_parser_t* parser = amxrt_get_parser();
365  amxd_dm_t* dm = amxrt_get_dm();
366 
367  struct stat statbuf;
368  amxc_var_t* objects = GETP_ARG(config, "odl.dm-objects");
369  amxc_var_set(cstring_t, objects, "Test,Test2");
370 
371  amxd_dm_init(dm);
372 
373  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
374  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
375  assert_non_null(amxd_dm_findf(dm, "Test2"));
376  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
377 
378  assert_int_not_equal(stat("./odl/00_Test.odl", &statbuf), -1);
379  unlink("./odl/00_Test.odl");
380  assert_int_not_equal(stat("./odl/01_Test2.odl", &statbuf), -1);
381  unlink("./odl/01_Test2.odl");
382  amxd_dm_clean(dm);
383 }

◆ test_can_start_with_directory_configured()

void test_can_start_with_directory_configured ( UNUSED void **  state)

Definition at line 173 of file test_amxrt_save_load.c.

173  {
174  amxc_var_t* config = amxrt_get_config();
175  amxo_parser_t* parser = amxrt_get_parser();
176  amxd_dm_t* dm = amxrt_get_dm();
177 
178  amxc_var_t* odl = GET_ARG(config, "odl");
179  amxc_var_add_key(cstring_t, odl, "directory", "./odl");
180 
181  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
182  amxp_sigmngr_trigger_signal(&dm->sigmngr, "app:start", NULL);
183  handle_events();
184  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
185  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
186  amxd_dm_clean(dm);
187 }

◆ test_can_start_with_no_odl_storage_type()

void test_can_start_with_no_odl_storage_type ( UNUSED void **  state)

Definition at line 138 of file test_amxrt_save_load.c.

138  {
139  amxc_var_t* config = amxrt_get_config();
140  amxo_parser_t* parser = amxrt_get_parser();
141  amxd_dm_t* dm = amxrt_get_dm();
142  amxc_var_t* storage = GET_ARG(config, "storage-type");
143  amxc_var_set(cstring_t, storage, "uci");
144 
145  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
146  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
147 }
storage
static odl_storage_t storage
Definition: amxrt_save_load.c:71

◆ test_can_start_with_no_storage_path()

void test_can_start_with_no_storage_path ( UNUSED void **  state)

Definition at line 160 of file test_amxrt_save_load.c.

160  {
161  amxc_var_t* config = amxrt_get_config();
162  amxo_parser_t* parser = amxrt_get_parser();
163  amxd_dm_t* dm = amxrt_get_dm();
164  amxc_var_t* storage = GET_ARG(config, "storage-path");
165  amxc_var_take_it(storage);
166 
167  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
168  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
169 
170  amxc_var_set_key(config, "storage-path", storage, AMXC_VAR_FLAG_DEFAULT);
171 }

◆ test_can_start_with_no_storage_type()

void test_can_start_with_no_storage_type ( UNUSED void **  state)

Definition at line 125 of file test_amxrt_save_load.c.

125  {
126  amxc_var_t* config = amxrt_get_config();
127  amxo_parser_t* parser = amxrt_get_parser();
128  amxd_dm_t* dm = amxrt_get_dm();
129  amxc_var_t* storage = GET_ARG(config, "storage-type");
130  amxc_var_take_it(storage);
131 
132  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
133  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
134 
135  amxc_var_set_key(config, "storage-type", storage, AMXC_VAR_FLAG_DEFAULT);
136 }

◆ test_can_start_with_odl_storage_type()

void test_can_start_with_odl_storage_type ( UNUSED void **  state)

Definition at line 149 of file test_amxrt_save_load.c.

149  {
150  amxc_var_t* config = amxrt_get_config();
151  amxo_parser_t* parser = amxrt_get_parser();
152  amxd_dm_t* dm = amxrt_get_dm();
153  amxc_var_t* storage = GET_ARG(config, "storage-type");
154  amxc_var_set(cstring_t, storage, "odl");
155 
156  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
157  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
158 }

◆ test_does_not_save_on_changed_when_invalid_objects()

void test_does_not_save_on_changed_when_invalid_objects ( UNUSED void **  state)

Definition at line 641 of file test_amxrt_save_load.c.

641  {
642  amxc_var_t* config = amxrt_get_config();
643  amxo_parser_t* parser = amxrt_get_parser();
644  amxd_dm_t* dm = amxrt_get_dm();
645 
646  struct stat statbuf;
647  amxd_trans_t transaction;
648  amxc_var_t* objects = GETP_ARG(config, "odl.dm-objects");
649  amxc_var_set(uint32_t, objects, 100);
650 
651  amxd_dm_init(dm);
652 
653  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
654  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
655  assert_non_null(amxd_dm_findf(dm, "Test2"));
656  amxp_sigmngr_trigger_signal(&dm->sigmngr, "app:start", NULL);
657 
658  amxd_trans_init(&transaction);
659  amxd_trans_select_pathf(&transaction, "Test2");
660  amxd_trans_set_value(cstring_t, &transaction, "Text", "Hallo");
661  amxd_trans_select_pathf(&transaction, "Test.Table.");
662  amxd_trans_add_inst(&transaction, 0, NULL);
663  amxd_trans_set_value(cstring_t, &transaction, "Text", "Hallo");
664  assert_int_equal(amxd_trans_apply(&transaction, dm), 0);
665  amxd_trans_clean(&transaction);
666 
667  handle_events();
668  sleep(1);
669  amxp_timers_calculate();
670  amxp_timers_check();
671  handle_events();
672 
673  assert_int_equal(stat("./odl/save_test.odl", &statbuf), -1);
674  assert_int_equal(stat("./odl/Test2.odl", &statbuf), -1);
675  assert_int_equal(stat("./odl/Test2.odl", &statbuf), -1);
676 
677  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
678 
679  amxd_dm_clean(dm);
680 }

◆ test_does_not_save_when_invalid_objects()

void test_does_not_save_when_invalid_objects ( UNUSED void **  state)

Definition at line 385 of file test_amxrt_save_load.c.

385  {
386  amxc_var_t* config = amxrt_get_config();
387  amxo_parser_t* parser = amxrt_get_parser();
388  amxd_dm_t* dm = amxrt_get_dm();
389 
390  struct stat statbuf;
391  amxc_var_t* objects = GETP_ARG(config, "odl.dm-objects");
392  amxc_var_set(uint32_t, objects, 100);
393 
394  amxd_dm_init(dm);
395 
396  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
397  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
398  assert_non_null(amxd_dm_findf(dm, "Test2"));
399  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
400 
401  assert_int_equal(stat("./odl/00_Test.odl", &statbuf), -1);
402  assert_int_equal(stat("./odl/01_Test2.odl", &statbuf), -1);
403  amxd_dm_clean(dm);
404 }

◆ test_does_not_save_when_not_persistent_parameter_changes()

void test_does_not_save_when_not_persistent_parameter_changes ( UNUSED void **  state)

Definition at line 515 of file test_amxrt_save_load.c.

515  {
516  amxo_parser_t* parser = amxrt_get_parser();
517  amxd_dm_t* dm = amxrt_get_dm();
518 
519  struct stat statbuf;
520  amxd_trans_t transaction;
521 
522  amxd_dm_init(dm);
523 
524  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
525  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
526  assert_non_null(amxd_dm_findf(dm, "Test2"));
527  amxp_sigmngr_trigger_signal(&dm->sigmngr, "app:start", NULL);
528 
529  handle_events();
530 
531  amxd_trans_init(&transaction);
532  amxd_trans_select_pathf(&transaction, "Test.Table");
533  amxd_trans_add_inst(&transaction, 0, NULL);
534  amxd_trans_set_value(cstring_t, &transaction, "Text", "Hallo");
535  assert_int_equal(amxd_trans_apply(&transaction, dm), 0);
536  amxd_trans_clean(&transaction);
537 
538  handle_events();
539  read_sigalrm();
540  handle_events();
541  assert_int_not_equal(stat("./odl/save_test.odl", &statbuf), -1);
542  unlink("./odl/save_test.odl");
543 
544  amxd_trans_init(&transaction);
545  amxd_trans_select_pathf(&transaction, "Test.Table.1");
546  amxd_trans_set_value(uint32_t, &transaction, "Number", 999);
547  assert_int_equal(amxd_trans_apply(&transaction, dm), 0);
548  amxd_trans_clean(&transaction);
549 
550  handle_events();
551  sleep(1);
552  amxp_timers_calculate();
553  amxp_timers_check();
554  handle_events();
555  assert_int_equal(stat("./odl/save_test.odl", &statbuf), -1);
556 
557  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
558  unlink("./odl/save_test.odl");
559  amxd_dm_clean(dm);
560 }

◆ test_load_fails_with_invalid_dir_and_invalid_defaults()

void test_load_fails_with_invalid_dir_and_invalid_defaults ( UNUSED void **  state)

Definition at line 253 of file test_amxrt_save_load.c.

253  {
254  amxc_var_t* config = amxrt_get_config();
255  amxo_parser_t* parser = amxrt_get_parser();
256  amxd_dm_t* dm = amxrt_get_dm();
257 
258  amxc_var_t* dir = GETP_ARG(config, "odl.dm-defaults");
259  amxc_var_set(cstring_t, dir, "./rubish");
260 
261  amxd_dm_init(dm);
262 
263  assert_int_not_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
264  assert_null(amxd_dm_findf(dm, "Test.Table"));
265  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
266 }

◆ test_loads_default_when_valid_dir_is_used()

void test_loads_default_when_valid_dir_is_used ( UNUSED void **  state)

Definition at line 239 of file test_amxrt_save_load.c.

239  {
240  amxc_var_t* config = amxrt_get_config();
241  amxo_parser_t* parser = amxrt_get_parser();
242  amxd_dm_t* dm = amxrt_get_dm();
243 
244  amxc_var_t* odl = GET_ARG(config, "odl");
245  amxc_var_add_key(cstring_t, odl, "dm-defaults", "./defaults");
246 
247  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
248  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
249  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
250  amxd_dm_clean(dm);
251 }

◆ test_save_fails_when_invalid_dir()

void test_save_fails_when_invalid_dir ( UNUSED void **  state)

Definition at line 294 of file test_amxrt_save_load.c.

294  {
295  amxc_var_t* config = amxrt_get_config();
296  amxo_parser_t* parser = amxrt_get_parser();
297  amxd_dm_t* dm = amxrt_get_dm();
298  struct stat statbuf;
299  amxc_var_t* dir = GETP_ARG(config, "odl.directory");
300  amxc_var_set(cstring_t, dir, "./odl");
301 
302  amxd_dm_init(dm);
303 
304  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
305  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
306  assert_non_null(amxd_dm_findf(dm, "Test2"));
307  amxc_var_set(cstring_t, dir, "./rubish");
308  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
309 
310  assert_int_equal(stat("./odl/save_test.odl", &statbuf), -1);
311  amxc_var_set(cstring_t, dir, "./odl");
312  amxd_dm_clean(dm);
313 }

◆ test_save_load_setup()

int test_save_load_setup ( UNUSED void **  state)

Definition at line 101 of file test_amxrt_save_load.c.

101  {
102  amxc_var_t* odl = NULL;
103  amxc_var_t* config = NULL;
104  amxd_dm_t* dm = NULL;
105 
106  amxrt_new();
107  config = amxrt_get_config();
108  dm = amxrt_get_dm();
109  odl = amxc_var_add_key(amxc_htable_t, config, "odl", NULL);
110 
111  amxc_var_add_key(bool, odl, "dm-load", true);
112  amxc_var_add_key(bool, odl, "dm-save", true);
113  amxc_var_add_key(uint32_t, odl, "dm-save-init-delay", 1000);
114 
115  amxp_sigmngr_enable(&dm->sigmngr, true);
116 
117  return 0;
118 }
amxrt_new
void amxrt_new(void)
Create the ambiorix runtime.
Definition: amxrt.c:313

◆ test_save_load_teardown()

int test_save_load_teardown ( UNUSED void **  state)

Definition at line 120 of file test_amxrt_save_load.c.

120  {
121  amxrt_delete();
122  return 0;
123 }
amxrt_delete
void amxrt_delete(void)
Clean-up ambiorix runtime.
Definition: amxrt.c:378

◆ test_save_separate_objects_fail_when_invalid_dir()

void test_save_separate_objects_fail_when_invalid_dir ( UNUSED void **  state)

Definition at line 339 of file test_amxrt_save_load.c.

339  {
340  amxc_var_t* config = amxrt_get_config();
341  amxo_parser_t* parser = amxrt_get_parser();
342  amxd_dm_t* dm = amxrt_get_dm();
343 
344  struct stat statbuf;
345  amxc_var_t* dir = GETP_ARG(config, "odl.directory");
346  amxc_var_set(cstring_t, dir, "./odl");
347 
348  amxd_dm_init(dm);
349 
350  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
351  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
352  assert_non_null(amxd_dm_findf(dm, "Test2"));
353  amxc_var_set(cstring_t, dir, "./rubish");
354  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
355 
356  assert_int_equal(stat("./odl/00_Test.odl", &statbuf), -1);
357  assert_int_equal(stat("./odl/01_Test2.odl", &statbuf), -1);
358  amxc_var_set(cstring_t, dir, "./odl");
359  amxd_dm_clean(dm);
360 }

◆ test_save_skips_unknown_objects()

void test_save_skips_unknown_objects ( UNUSED void **  state)

Definition at line 406 of file test_amxrt_save_load.c.

406  {
407  amxc_var_t* config = amxrt_get_config();
408  amxo_parser_t* parser = amxrt_get_parser();
409  amxd_dm_t* dm = amxrt_get_dm();
410 
411  struct stat statbuf;
412  amxc_var_t* objects = GETP_ARG(config, "odl.dm-objects");
413  amxc_var_set(csv_string_t, objects, "Test3, Test, Test4, Test2");
414 
415  amxd_dm_init(dm);
416 
417  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
418  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
419  assert_non_null(amxd_dm_findf(dm, "Test2"));
420  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
421 
422  assert_int_not_equal(stat("./odl/00_Test.odl", &statbuf), -1);
423  unlink("./odl/00_Test.odl");
424  assert_int_not_equal(stat("./odl/01_Test2.odl", &statbuf), -1);
425  unlink("./odl/01_Test2.odl");
426  assert_int_equal(stat("./odl/00_Test3.odl", &statbuf), -1);
427  assert_int_equal(stat("./odl/02_Test4.odl", &statbuf), -1);
428  amxd_dm_clean(dm);
429 }

◆ test_saves_when_instance_deleted()

void test_saves_when_instance_deleted ( UNUSED void **  state)

Definition at line 562 of file test_amxrt_save_load.c.

562  {
563  amxo_parser_t* parser = amxrt_get_parser();
564  amxd_dm_t* dm = amxrt_get_dm();
565  struct stat statbuf;
566  amxd_trans_t transaction;
567 
568  amxd_dm_init(dm);
569 
570  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
571  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
572  assert_non_null(amxd_dm_findf(dm, "Test2"));
573  amxp_sigmngr_trigger_signal(&dm->sigmngr, "app:start", NULL);
574 
575  handle_events();
576 
577  amxd_trans_init(&transaction);
578  amxd_trans_select_pathf(&transaction, "Test.Table");
579  amxd_trans_del_inst(&transaction, 1, NULL);
580  assert_int_equal(amxd_trans_apply(&transaction, dm), 0);
581  amxd_trans_clean(&transaction);
582 
583  handle_events();
584  read_sigalrm();
585  handle_events();
586  assert_int_not_equal(stat("./odl/save_test.odl", &statbuf), -1);
587 
588  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
589  unlink("./odl/save_test.odl");
590  amxd_dm_clean(dm);
591 }

◆ test_saves_when_persistent_parameter_changes()

void test_saves_when_persistent_parameter_changes ( UNUSED void **  state)

Definition at line 470 of file test_amxrt_save_load.c.

470  {
471  amxo_parser_t* parser = amxrt_get_parser();
472  amxd_dm_t* dm = amxrt_get_dm();
473 
474  struct stat statbuf;
475  amxd_trans_t transaction;
476 
477  amxd_dm_init(dm);
478 
479  assert_int_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
480  assert_non_null(amxd_dm_findf(dm, "Test.Table"));
481  assert_non_null(amxd_dm_findf(dm, "Test2"));
482  amxp_sigmngr_trigger_signal(&dm->sigmngr, "app:start", NULL);
483 
484  handle_events();
485 
486  amxd_trans_init(&transaction);
487  amxd_trans_select_pathf(&transaction, "Test.Table");
488  amxd_trans_add_inst(&transaction, 0, NULL);
489  amxd_trans_set_value(cstring_t, &transaction, "Text", "Hallo");
490  assert_int_equal(amxd_trans_apply(&transaction, dm), 0);
491  amxd_trans_clean(&transaction);
492 
493  handle_events();
494  read_sigalrm();
495  handle_events();
496  assert_int_not_equal(stat("./odl/save_test.odl", &statbuf), -1);
497  unlink("./odl/save_test.odl");
498 
499  amxd_trans_init(&transaction);
500  amxd_trans_select_pathf(&transaction, "Test.Table.1");
501  amxd_trans_set_value(cstring_t, &transaction, "Text", "World");
502  assert_int_equal(amxd_trans_apply(&transaction, dm), 0);
503  amxd_trans_clean(&transaction);
504 
505  handle_events();
506  read_sigalrm();
507  handle_events();
508  assert_int_not_equal(stat("./odl/save_test.odl", &statbuf), -1);
509 
510  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
511  unlink("./odl/save_test.odl");
512  amxd_dm_clean(dm);
513 }

◆ test_start_fails_with_invalid_directory_configured()

void test_start_fails_with_invalid_directory_configured ( UNUSED void **  state)

Definition at line 223 of file test_amxrt_save_load.c.

223  {
224  amxc_var_t* config = amxrt_get_config();
225  amxo_parser_t* parser = amxrt_get_parser();
226  amxd_dm_t* dm = amxrt_get_dm();
227 
228  amxc_var_t* dir = GETP_ARG(config, "odl.directory");
229  amxc_var_set(cstring_t, dir, "./rubish");
230 
231  amxd_dm_init(dm);
232 
233  assert_int_not_equal(amxrt_dm_save_load_main(AMXO_START, dm, parser), 0);
234  assert_null(amxd_dm_findf(dm, "Test.Table"));
235  assert_int_equal(amxrt_dm_save_load_main(AMXO_STOP, dm, parser), 0);
236  amxd_dm_clean(dm);
237 }