libamxs  0.6.0
Data Model Synchronization C API
Functions | Variables
test_amxs_sync_copy.c File Reference
#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
#include <setjmp.h>
#include <cmocka.h>
#include <amxc/amxc_variant.h>
#include <amxc/amxc_htable.h>
#include <amxc/amxc_lqueue.h>
#include <amxp/amxp_signal.h>
#include <amxp/amxp_slot.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_transaction.h>
#include <amxo/amxo.h>
#include <amxs/amxs.h>
#include <amxc/amxc_macros.h>
#include "test_amxs_sync_copy.h"
#include "dummy_be.h"

Go to the source code of this file.

Functions

static void handle_events (void)
 
int test_amxs_sync_setup (UNUSED void **state)
 
int test_amxs_sync_teardown (UNUSED void **state)
 
void test_amxs_sync_copy_param (UNUSED void **state)
 
void test_amxs_sync_copy_same_param (UNUSED void **state)
 
void test_amxs_sync_copy_object (UNUSED void **state)
 
static amxs_status_t param_action_cb (const amxs_sync_entry_t *sync_entry, amxs_sync_direction_t direction, amxc_var_t *data, void *priv)
 
static void get_latest_template_data (amxc_var_t *data, amxc_var_t **ptr, uint32_t template_nr, char name)
 
static void check_parameter (amxc_var_t *data_a, amxc_var_t **ptr_a, char name_a, amxc_var_t *data_b, amxc_var_t **ptr_b, char name_b, uint32_t template_nr, bool ptrs_equal)
 
void test_amxs_sync_copy_template_object (UNUSED void **state)
 
void test_amxs_sync_root_copy_template_object (UNUSED void **state)
 
void test_amxs_sync_copy_instance_object (UNUSED void **state)
 
static bool compare_object_params (amxc_var_t *data_a, amxc_var_t *data_b)
 
void test_amxs_sync_copy_object_batch (UNUSED void **state)
 
void test_amxs_sync_copy_object_batch_check_direction (UNUSED void **state)
 
void test_amxs_sync_copy_param_loop_prevention (UNUSED void **state)
 
void test_amxs_sync_copy_param_loop_prevention_multi_instance (UNUSED void **state)
 
void test_amxs_sync_copy_param_read_only (UNUSED void **state)
 
void test_amxs_sync_copy_instances (UNUSED void **state)
 
void test_amxs_sync_copy_template_sub_object (UNUSED void **state)
 
void test_amxs_sync_copy_template_sub_object_with_batch (UNUSED void **state)
 
void test_amxs_sync_copy_template_sub_object_reverse (UNUSED void **state)
 
void test_amxs_sync_copy_template_sub_object_batch_reverse (UNUSED void **state)
 

Variables

static amxb_bus_ctx_t * bus_ctx = NULL
 

Function Documentation

◆ check_parameter()

static void check_parameter ( amxc_var_t *  data_a,
amxc_var_t **  ptr_a,
char  name_a,
amxc_var_t *  data_b,
amxc_var_t **  ptr_b,
char  name_b,
uint32_t  template_nr,
bool  ptrs_equal 
)
static

Definition at line 318 of file test_amxs_sync_copy.c.

318  {
319  int ret = 0;
320 
321  get_latest_template_data(data_a, ptr_a, template_nr, name_a);
322  get_latest_template_data(data_b, ptr_b, template_nr, name_b);
323  assert_int_equal(amxc_var_compare(*ptr_a, *ptr_b, &ret), 0);
324  if(ptrs_equal) {
325  assert_int_equal(ret, 0);
326  } else {
327  assert_int_not_equal(ret, 0);
328  }
329 }
get_latest_template_data
static void get_latest_template_data(amxc_var_t *data, amxc_var_t **ptr, uint32_t template_nr, char name)
Definition: test_amxs_sync_copy.c:302

◆ compare_object_params()

static bool compare_object_params ( amxc_var_t *  data_a,
amxc_var_t *  data_b 
)
static

Definition at line 492 of file test_amxs_sync_copy.c.

492  {
493  bool ret = false;
494  int result = -1;
495  amxc_var_t* ptr_a = GETP_ARG(data_a, "0.'A.object_A.'.param_A");
496  amxc_var_t* ptr_b = GETP_ARG(data_b, "0.'B.object_B.'.param_B");
497 
498  when_failed(amxc_var_compare(ptr_a, ptr_b, &result), exit);
499  when_failed(result, exit);
500 
501  ptr_a = GETP_ARG(data_a, "0.'A.object_A.'.number_A");
502  ptr_b = GETP_ARG(data_b, "0.'B.object_B.'.number_B");
503 
504  when_failed(amxc_var_compare(ptr_a, ptr_b, &result), exit);
505  when_failed(result, exit);
506 
507  ret = true;
508 
509 exit:
510  return ret;
511 }

◆ get_latest_template_data()

static void get_latest_template_data ( amxc_var_t *  data,
amxc_var_t **  ptr,
uint32_t  template_nr,
char  name 
)
static

Definition at line 302 of file test_amxs_sync_copy.c.

302  {
303  amxc_string_t new_flags_str;
304 
305  amxc_string_init(&new_flags_str, 0);
306 
307  amxc_var_clean(data);
308 
309  amxc_string_setf(&new_flags_str, "%c.%c_template.%d.", name, name, template_nr);
310  assert_int_equal(amxb_get(bus_ctx, amxc_string_get(&new_flags_str, 0), 0, data, 5), 0);
311  amxc_string_prependf(&new_flags_str, "0.'");
312  amxc_string_appendf(&new_flags_str, "'.param_%c", name);
313  *ptr = GETP_ARG(data, amxc_string_get(&new_flags_str, 0));
314 
315  amxc_string_clean(&new_flags_str);
316 }
bus_ctx
static amxb_bus_ctx_t * bus_ctx
Definition: test_amxs_sync_copy.c:82

◆ handle_events()

static void handle_events ( void  )
static

Definition at line 84 of file test_amxs_sync_copy.c.

84  {
85  while(amxp_signal_read() == 0) {
86  }
87 }

◆ param_action_cb()

static amxs_status_t param_action_cb ( const amxs_sync_entry_t *  sync_entry,
amxs_sync_direction_t  direction,
amxc_var_t *  data,
void *  priv 
)
static

Definition at line 273 of file test_amxs_sync_copy.c.

273  {
274  amxc_var_t current_object_data;
275  amxc_var_t new_settings;
276  amxc_string_t new_flags_str;
277 
278  const char* previous_flags = NULL;
279 
280  amxc_var_init(&current_object_data);
281  amxc_var_init(&new_settings);
282  amxc_string_init(&new_flags_str, 0);
283  amxc_var_set_type(&new_settings, AMXC_VAR_ID_HTABLE);
284 
285  assert_int_equal(amxb_get(bus_ctx, GET_CHAR(data, "path"), 0, &current_object_data, 5), 0);
286  previous_flags = GETP_CHAR(&current_object_data, "0.0.flag");
287 
288  amxc_string_setf(&new_flags_str, "%s C", (previous_flags == NULL ? "" : previous_flags));
289 
290  amxc_var_add_key(cstring_t, &new_settings, "flag", amxc_string_get(&new_flags_str, 0));
291 
292  assert_int_equal(amxb_set(bus_ctx, GET_CHAR(data, "path"), &new_settings, &new_settings, 5), 0);
293  handle_events();
294 
295  amxc_string_clean(&new_flags_str);
296  amxc_var_clean(&new_settings);
297  amxc_var_clean(&current_object_data);
298 
299  return amxs_sync_param_copy_action_cb(sync_entry, direction, data, priv);
300 }
amxs_sync_param_copy_action_cb
amxs_status_t amxs_sync_param_copy_action_cb(const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, amxc_var_t *data, void *priv)
Sets the new parameter value.
handle_events
static void handle_events(void)
Definition: test_amxs_sync_copy.c:84

◆ test_amxs_sync_copy_instance_object()

void test_amxs_sync_copy_instance_object ( UNUSED void **  state)

Definition at line 438 of file test_amxs_sync_copy.c.

438  {
439  amxs_sync_ctx_t* ctx = NULL;
440  amxs_sync_object_t* obj = NULL;
441  amxc_var_t data_a;
442  amxc_var_t data_b;
443  amxc_var_t* ptr_a = NULL;
444  amxc_var_t* ptr_b = NULL;
445  int ret = 0;
446 
447  amxc_var_init(&data_a);
448  amxc_var_init(&data_b);
449 
450  assert_int_equal(amxb_get(bus_ctx, "A.A_template.1.param_A", 0, &data_a, 5), 0);
451  assert_int_equal(amxb_get(bus_ctx, "B.B_template.1.param_B", 0, &data_b, 5), 0);
452  ptr_a = GETP_ARG(&data_a, "0.'A.A_template.1.'.param_A");
453  ptr_b = GETP_ARG(&data_b, "0.'B.B_template.1.'.param_B");
454 
455  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
456  assert_int_not_equal(ret, 0);
457 
458  handle_events();
459  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.", "B.", AMXS_SYNC_DEFAULT), 0);
460  assert_int_equal(amxs_sync_object_new_copy(&obj, "A_template.1.", "B_template.1.", AMXS_SYNC_DEFAULT), 0);
461  assert_int_equal(amxs_sync_object_add_new_copy_param(obj, "param_A", "param_B", AMXS_SYNC_DEFAULT), 0);
462  assert_int_equal(amxs_sync_ctx_add_object(ctx, obj), 0);
463  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
464  handle_events();
465  assert_int_equal(amxc_llist_size(&ctx->subscriptions), 2);
466 
467  amxc_var_clean(&data_b);
468  assert_int_equal(amxb_get(bus_ctx, "B.B_template.1.param_B", 0, &data_b, 5), 0);
469  ptr_b = GETP_ARG(&data_b, "0.'B.B_template.1.'.param_B");
470  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
471  assert_int_equal(ret, 0);
472 
473  amxc_var_clean(&data_a);
474  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
475  amxc_var_add_key(uint32_t, &data_a, "param_A", 1234);
476  assert_int_equal(amxb_set(bus_ctx, "A.A_template.1.", &data_a, &data_a, 5), 0);
477  handle_events();
478  amxc_var_clean(&data_b);
479  assert_int_equal(amxb_get(bus_ctx, "B.B_template.1.param_B", 0, &data_b, 5), 0);
480  ptr_a = GETP_ARG(&data_a, "0.'A.A_template.1.'.param_A");
481  ptr_b = GETP_ARG(&data_b, "0.'B.B_template.1.'.param_B");
482  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
483  assert_int_equal(ret, 0);
484 
485  amxs_sync_ctx_stop_sync(ctx);
486  amxs_sync_ctx_delete(&ctx);
487 
488  amxc_var_clean(&data_a);
489  amxc_var_clean(&data_b);
490 }
amxs_sync_object_add_new_copy_param
amxs_status_t amxs_sync_object_add_new_copy_param(amxs_sync_object_t *object, const char *param_a, const char *param_b, int attributes)
Creates and adds a synchronization parameter to a synchronization object.
Definition: amxs_sync_object.c:147
amxs_sync_object_new_copy
amxs_status_t amxs_sync_object_new_copy(amxs_sync_object_t **object, const char *object_a, const char *object_b, int attributes)
Synchronization object constructor function.
Definition: amxs_sync_object.c:88
AMXS_SYNC_DEFAULT
#define AMXS_SYNC_DEFAULT
Default synchronization attributes.
Definition: amxs_types.h:190
amxs_sync_ctx_new
amxs_status_t amxs_sync_ctx_new(amxs_sync_ctx_t **ctx, const char *object_a, const char *object_b, int attributes)
Synchronization context constructor function.
Definition: amxs_sync_ctx.c:713
amxs_sync_ctx_start_sync
amxs_status_t amxs_sync_ctx_start_sync(amxs_sync_ctx_t *ctx)
Starts the object synchronization.
Definition: amxs_sync_ctx.c:766
amxs_sync_ctx_delete
void amxs_sync_ctx_delete(amxs_sync_ctx_t **ctx)
Synchronization context destructor function.
Definition: amxs_sync_ctx.c:727
amxs_sync_ctx_add_object
amxs_status_t amxs_sync_ctx_add_object(amxs_sync_ctx_t *ctx, amxs_sync_object_t *object)
Adds a synchronization object to a synchronization context.
Definition: amxs_sync_ctx.c:916
amxs_sync_ctx_stop_sync
void amxs_sync_ctx_stop_sync(amxs_sync_ctx_t *ctx)
Stops the object synchronization.
Definition: amxs_sync_ctx.c:818
_amxs_sync_entry
Definition: amxs_types.h:161
_amxs_sync_entry::subscriptions
amxc_llist_t subscriptions
Definition: amxs_types.h:173

◆ test_amxs_sync_copy_instances()

void test_amxs_sync_copy_instances ( UNUSED void **  state)

Definition at line 831 of file test_amxs_sync_copy.c.

831  {
832  amxc_var_t data_a;
833  amxc_var_t data_b;
834  amxc_var_t* ptr_a = NULL;
835  amxc_var_t* ptr_b = NULL;
836  int ret = 0;
837  amxd_trans_t trans;
838 
839  amxd_trans_init(&trans);
840  amxd_trans_set_attr(&trans, amxd_tattr_change_ro, true);
841 
842  amxc_var_init(&data_a);
843  amxc_var_init(&data_b);
844 
845  handle_events();
846 
847  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.", 2, &data_a, 5), 0);
848  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.", 0, &data_b, 5), 0);
849 
850  assert_int_equal(test_load_dummy_remote("sync.odl"), 0);
851  assert_int_equal(amxo_parser_start_synchronize(test_get_parser()), 0);
852 
853  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.1.", 2, &data_b, 5), 0);
854  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.1.'.param_A");
855  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.1.'.param_B");
856  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
857  assert_int_equal(ret, 0);
858  assert_string_equal(GET_CHAR(ptr_b, NULL), "I am A template sub");
859 
860  amxd_trans_select_pathf(&trans, "A.A_template_sub.");
861  amxd_trans_add_inst(&trans, 2, NULL);
862  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
863  amxd_trans_clean(&trans);
864 
865  handle_events();
866  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.2.", 0, &data_a, 5), 0);
867  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.2.", 0, &data_b, 5), 0);
868  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.2.'.param_A");
869  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.2.'.param_B");
870  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
871  assert_int_equal(ret, 0);
872  assert_string_equal(GET_CHAR(ptr_b, NULL), "I am A template sub");
873 
874  amxd_trans_init(&trans);
875  amxd_trans_select_pathf(&trans, "B.B_template_sub.");
876  amxd_trans_add_inst(&trans, 3, NULL);
877  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
878 
879  handle_events();
880  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.3.", 0, &data_a, 5), 0);
881  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.3.", 0, &data_b, 5), 0);
882  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.3.'.param_A");
883  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.3.'.param_B");
884  assert_string_equal(GET_CHAR(ptr_a, NULL), "I am B template sub");
885  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
886  assert_int_equal(ret, 0);
887 
888  amxc_var_clean(&data_a);
889  amxc_var_clean(&data_b);
890  amxd_trans_clean(&trans);
891 }
test_get_parser
amxo_parser_t * test_get_parser(void)
Definition: dummy_be.c:268
test_get_dm
amxd_dm_t * test_get_dm(void)
Definition: dummy_be.c:264
test_load_dummy_remote
int test_load_dummy_remote(const char *odl)
Definition: dummy_be.c:254

◆ test_amxs_sync_copy_object()

void test_amxs_sync_copy_object ( UNUSED void **  state)

Definition at line 217 of file test_amxs_sync_copy.c.

217  {
218  amxs_sync_ctx_t* ctx = NULL;
219  amxs_sync_object_t* obj = NULL;
220  amxc_var_t data_a;
221  amxc_var_t data_b;
222  amxc_var_t* ptr_a = NULL;
223  amxc_var_t* ptr_b = NULL;
224  int ret = 0;
225 
226  amxc_var_init(&data_a);
227  amxc_var_init(&data_b);
228 
229  assert_int_equal(amxb_get(bus_ctx, "A.object_A.param_A", 0, &data_a, 5), 0);
230  assert_int_equal(amxb_get(bus_ctx, "B.object_B.param_B", 0, &data_b, 5), 0);
231  ptr_a = GETP_ARG(&data_a, "0.'A.object_A.'.param_A");
232  ptr_b = GETP_ARG(&data_b, "0.'B.object_B.'.param_B");
233 
234  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
235  assert_int_not_equal(ret, 0);
236 
237  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.", "B.", AMXS_SYNC_DEFAULT), 0);
238  assert_int_equal(amxs_sync_object_new_copy(&obj, "object_A.", "object_B.", AMXS_SYNC_DEFAULT), 0);
239  assert_int_equal(amxs_sync_object_add_new_copy_param(obj, "param_A", "param_B", AMXS_SYNC_DEFAULT), 0);
240  assert_int_equal(amxs_sync_ctx_add_object(ctx, obj), 0);
241  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
242  handle_events();
243  assert_int_equal(amxc_llist_size(&ctx->subscriptions), 4);
244 
245  amxc_var_clean(&data_b);
246  assert_int_equal(amxb_get(bus_ctx, "B.object_B.param_B", 0, &data_b, 5), 0);
247  ptr_b = GETP_ARG(&data_b, "0.'B.object_B.'.param_B");
248  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
249  assert_int_equal(ret, 0);
250 
251  amxc_var_clean(&data_a);
252  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
253  amxc_var_add_key(cstring_t, &data_a, "param_A", "Updated string");
254  assert_int_equal(amxb_set(bus_ctx, "A.object_A.", &data_a, &data_a, 5), 0);
255  handle_events();
256  amxc_var_clean(&data_b);
257  assert_int_equal(amxb_get(bus_ctx, "B.object_B.param_B", 0, &data_b, 5), 0);
258  ptr_a = GETP_ARG(&data_a, "0.'A.object_A.'.param_A");
259  ptr_b = GETP_ARG(&data_b, "0.'B.object_B.'.param_B");
260  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
261  assert_int_equal(ret, 0);
262 
263  amxs_sync_ctx_stop_sync(ctx);
264  amxs_sync_ctx_delete(&ctx);
265 
266  amxc_var_clean(&data_a);
267  amxc_var_clean(&data_b);
268 }

◆ test_amxs_sync_copy_object_batch()

void test_amxs_sync_copy_object_batch ( UNUSED void **  state)

Definition at line 513 of file test_amxs_sync_copy.c.

513  {
514  amxs_sync_ctx_t* ctx = NULL;
515  amxs_sync_object_t* obj = NULL;
516  amxc_var_t data_a;
517  amxc_var_t data_b;
518 
519  amxc_var_init(&data_a);
520  amxc_var_init(&data_b);
521 
522  assert_int_equal(amxb_get(bus_ctx, "A.object_A.", 0, &data_a, 5), 0);
523  assert_int_equal(amxb_get(bus_ctx, "B.object_B.", 0, &data_b, 5), 0);
524  assert_false(compare_object_params(&data_a, &data_b));
525 
526  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.", "B.", AMXS_SYNC_DEFAULT), 0);
527  assert_int_equal(amxs_sync_object_new_copy(&obj, "object_A.", "object_B.", AMXS_SYNC_DEFAULT), 0);
528  assert_int_equal(amxs_sync_object_add_new_copy_param(obj, "param_A", "param_B", AMXS_SYNC_DEFAULT), 0);
529  assert_int_equal(amxs_sync_object_add_new_copy_param(obj, "number_A", "number_B", AMXS_SYNC_DEFAULT), 0);
530  assert_int_equal(amxs_sync_ctx_add_object(ctx, obj), 0);
531  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
532  handle_events();
533  assert_int_equal(amxc_llist_size(&ctx->subscriptions), 4);
534 
535  amxc_var_clean(&data_b);
536  assert_int_equal(amxb_get(bus_ctx, "B.object_B.", 0, &data_b, 5), 0);
537  assert_true(compare_object_params(&data_a, &data_b));
538 
539  amxc_var_clean(&data_a);
540  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
541  amxc_var_add_key(cstring_t, &data_a, "param_A", "Updated string");
542  assert_int_equal(amxb_set(bus_ctx, "A.object_A.", &data_a, &data_a, 5), 0);
543  handle_events();
544  amxc_var_clean(&data_b);
545  assert_int_equal(amxb_get(bus_ctx, "A.object_A.", 0, &data_a, 5), 0);
546  assert_int_equal(amxb_get(bus_ctx, "B.object_B.", 0, &data_b, 5), 0);
547  assert_true(compare_object_params(&data_a, &data_b));
548 
549  amxs_sync_ctx_stop_sync(ctx);
550  amxs_sync_ctx_delete(&ctx);
551 
552  amxc_var_clean(&data_a);
553  amxc_var_clean(&data_b);
554 }
compare_object_params
static bool compare_object_params(amxc_var_t *data_a, amxc_var_t *data_b)
Definition: test_amxs_sync_copy.c:492

◆ test_amxs_sync_copy_object_batch_check_direction()

void test_amxs_sync_copy_object_batch_check_direction ( UNUSED void **  state)

Definition at line 556 of file test_amxs_sync_copy.c.

556  {
557  amxs_sync_ctx_t* ctx = NULL;
558  amxs_sync_object_t* obj = NULL;
559  amxc_var_t data_a;
560  amxc_var_t data_b;
561 
562  amxc_var_init(&data_a);
563  amxc_var_init(&data_b);
564 
565  assert_int_equal(amxb_get(bus_ctx, "A.object_A.", 0, &data_a, 5), 0);
566  assert_int_equal(amxb_get(bus_ctx, "B.object_B.", 0, &data_b, 5), 0);
567  assert_false(compare_object_params(&data_a, &data_b));
568 
569  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.", "B.", AMXS_SYNC_DEFAULT), 0);
570  assert_int_equal(amxs_sync_object_new_copy(&obj, "object_A.", "object_B.", AMXS_SYNC_DEFAULT), 0);
571  assert_int_equal(amxs_sync_object_add_new_copy_param(obj, "param_A", "param_B", AMXS_SYNC_ONLY_A_TO_B), 0);
572  assert_int_equal(amxs_sync_object_add_new_copy_param(obj, "number_A", "number_B", AMXS_SYNC_ONLY_B_TO_A | AMXS_SYNC_INIT_B), 0);
573  assert_int_equal(amxs_sync_ctx_add_object(ctx, obj), 0);
574  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
575  handle_events();
576  assert_int_equal(amxc_llist_size(&ctx->subscriptions), 4);
577 
578  amxc_var_clean(&data_a);
579  amxc_var_clean(&data_b);
580  assert_int_equal(amxb_get(bus_ctx, "A.object_A.", 0, &data_a, 5), 0);
581  assert_int_equal(amxb_get(bus_ctx, "B.object_B.", 0, &data_b, 5), 0);
582  assert_true(compare_object_params(&data_a, &data_b));
583 
584  amxc_var_clean(&data_a);
585  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
586  amxc_var_add_key(cstring_t, &data_a, "param_A", "Updated string");
587  assert_int_equal(amxb_set(bus_ctx, "A.object_A.", &data_a, &data_a, 5), 0);
588  handle_events();
589  amxc_var_clean(&data_a);
590  amxc_var_clean(&data_b);
591  assert_int_equal(amxb_get(bus_ctx, "A.object_A.", 0, &data_a, 5), 0);
592  assert_int_equal(amxb_get(bus_ctx, "B.object_B.", 0, &data_b, 5), 0);
593  assert_true(compare_object_params(&data_a, &data_b));
594 
595  amxc_var_clean(&data_a);
596  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
597  amxc_var_add_key(uint32_t, &data_a, "number_A", 1234);
598  assert_int_equal(amxb_set(bus_ctx, "A.object_A.", &data_a, &data_a, 5), 0);
599  handle_events();
600  amxc_var_clean(&data_a);
601  amxc_var_clean(&data_b);
602  assert_int_equal(amxb_get(bus_ctx, "A.object_A.", 0, &data_a, 5), 0);
603  assert_int_equal(amxb_get(bus_ctx, "B.object_B.", 0, &data_b, 5), 0);
604  assert_false(compare_object_params(&data_a, &data_b));
605 
606  amxc_var_clean(&data_b);
607  amxc_var_set_type(&data_b, AMXC_VAR_ID_HTABLE);
608  amxc_var_add_key(uint32_t, &data_b, "number_B", 4321);
609  assert_int_equal(amxb_set(bus_ctx, "B.object_B.", &data_b, &data_b, 5), 0);
610  handle_events();
611  amxc_var_clean(&data_a);
612  amxc_var_clean(&data_b);
613  assert_int_equal(amxb_get(bus_ctx, "A.object_A.", 0, &data_a, 5), 0);
614  assert_int_equal(amxb_get(bus_ctx, "B.object_B.", 0, &data_b, 5), 0);
615  assert_true(compare_object_params(&data_a, &data_b));
616 
617  amxs_sync_ctx_stop_sync(ctx);
618  amxs_sync_ctx_delete(&ctx);
619 
620  amxc_var_clean(&data_a);
621  amxc_var_clean(&data_b);
622 }
AMXS_SYNC_INIT_B
#define AMXS_SYNC_INIT_B
Take the initial values from object B.
Definition: amxs_types.h:205
AMXS_SYNC_ONLY_B_TO_A
#define AMXS_SYNC_ONLY_B_TO_A
Only synchronize from object B to object A.
Definition: amxs_types.h:195
AMXS_SYNC_ONLY_A_TO_B
#define AMXS_SYNC_ONLY_A_TO_B
Only synchronize from object A to object B.
Definition: amxs_types.h:200

◆ test_amxs_sync_copy_param()

void test_amxs_sync_copy_param ( UNUSED void **  state)

Definition at line 106 of file test_amxs_sync_copy.c.

106  {
107  amxs_sync_ctx_t* ctx = NULL;
108  amxc_var_t data_a;
109  amxc_var_t data_b;
110  amxc_var_t* ptr_a = NULL;
111  amxc_var_t* ptr_b = NULL;
112  int ret = 0;
113 
114  amxc_var_init(&data_a);
115  amxc_var_init(&data_b);
116 
117  assert_int_equal(amxb_get(bus_ctx, "A.param_A", 0, &data_a, 5), 0);
118  assert_int_equal(amxb_get(bus_ctx, "B.param_B", 0, &data_b, 5), 0);
119  ptr_a = GETP_ARG(&data_a, "0.'A.'.param_A");
120  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B");
121 
122  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
123  assert_int_not_equal(ret, 0);
124 
125  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.", "B.", AMXS_SYNC_DEFAULT), 0);
126  assert_int_equal(amxs_sync_ctx_add_new_copy_param(ctx, "param_A", "param_B", AMXS_SYNC_DEFAULT), 0);
127  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
128  handle_events();
129  assert_int_equal(amxc_llist_size(&ctx->subscriptions), 2);
130 
131  amxc_var_clean(&data_b);
132  assert_int_equal(amxb_get(bus_ctx, "B.param_B", 0, &data_b, 5), 0);
133  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B");
134  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
135  assert_int_equal(ret, 0);
136 
137 
138  amxc_var_clean(&data_a);
139  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
140  amxc_var_add_key(uint32_t, &data_a, "param_A", 1234);
141  assert_int_equal(amxb_set(bus_ctx, "A.", &data_a, &data_a, 5), 0);
142  handle_events();
143  amxc_var_clean(&data_b);
144  assert_int_equal(amxb_get(bus_ctx, "B.param_B", 0, &data_b, 5), 0);
145  ptr_a = GETP_ARG(&data_a, "0.'A.'.param_A");
146  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B");
147  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
148  assert_int_equal(ret, 0);
149 
150  amxs_sync_ctx_stop_sync(ctx);
151  amxs_sync_ctx_delete(&ctx);
152 
153  amxc_var_clean(&data_a);
154  amxc_var_clean(&data_b);
155 }
amxs_sync_ctx_add_new_copy_param
amxs_status_t amxs_sync_ctx_add_new_copy_param(amxs_sync_ctx_t *ctx, const char *param_a, const char *param_b, int attributes)
Creates and adds a synchronization parameter to a synchronization context.
Definition: amxs_sync_ctx.c:903

◆ test_amxs_sync_copy_param_loop_prevention()

void test_amxs_sync_copy_param_loop_prevention ( UNUSED void **  state)

Definition at line 624 of file test_amxs_sync_copy.c.

624  {
625  amxs_sync_ctx_t* ctx = NULL;
626  amxc_var_t data_a;
627  amxc_var_t data_b;
628  amxc_var_t* ptr_a = NULL;
629  amxc_var_t* ptr_b = NULL;
630  int ret = 0;
631 
632  amxc_var_init(&data_a);
633  amxc_var_init(&data_b);
634 
635  assert_int_equal(amxb_get(bus_ctx, "A.param_A", 0, &data_a, 5), 0);
636  assert_int_equal(amxb_get(bus_ctx, "B.param_B", 0, &data_b, 5), 0);
637  ptr_a = GETP_ARG(&data_a, "0.'A.'.param_A");
638  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B");
639 
640  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
641  assert_int_not_equal(ret, 0);
642 
643  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.", "B.", AMXS_SYNC_DEFAULT), 0);
644  assert_int_equal(amxs_sync_ctx_add_new_copy_param(ctx, "param_A", "param_B", AMXS_SYNC_DEFAULT), 0);
645  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
646  handle_events();
647  assert_int_equal(amxc_llist_size(&ctx->subscriptions), 2);
648 
649  amxc_var_clean(&data_b);
650  assert_int_equal(amxb_get(bus_ctx, "B.param_B", 0, &data_b, 5), 0);
651  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B");
652  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
653  assert_int_equal(ret, 0);
654 
655  // Toggle one side twice, then handle events
656  // Value should be the latest one
657  amxc_var_clean(&data_a);
658  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
659  amxc_var_add_key(uint32_t, &data_a, "param_A", 1234);
660  assert_int_equal(amxb_set(bus_ctx, "A.", &data_a, &data_a, 5), 0);
661  amxc_var_clean(&data_a);
662  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
663  amxc_var_add_key(uint32_t, &data_a, "param_A", 5678);
664  assert_int_equal(amxb_set(bus_ctx, "A.", &data_a, &data_a, 5), 0);
665  handle_events();
666  amxc_var_clean(&data_b);
667  assert_int_equal(amxb_get(bus_ctx, "B.param_B", 0, &data_b, 5), 0);
668  ptr_a = GETP_ARG(&data_a, "0.'A.'.param_A");
669  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B");
670  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
671  assert_int_equal(ret, 0);
672 
673  // Toggle both sides at the same time, then handle events
674  // Values should be swapped
675  amxc_var_clean(&data_a);
676  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
677  amxc_var_add_key(uint32_t, &data_a, "param_A", 1234);
678  assert_int_equal(amxb_set(bus_ctx, "A.", &data_a, &data_a, 5), 0);
679  amxc_var_clean(&data_b);
680  amxc_var_set_type(&data_b, AMXC_VAR_ID_HTABLE);
681  amxc_var_add_key(uint32_t, &data_b, "param_B", 4321);
682  assert_int_equal(amxb_set(bus_ctx, "B.", &data_b, &data_b, 5), 0);
683  handle_events();
684  amxc_var_clean(&data_b);
685  assert_int_equal(amxb_get(bus_ctx, "B.param_B", 0, &data_b, 5), 0);
686  assert_int_equal(amxb_get(bus_ctx, "A.param_A", 0, &data_a, 5), 0);
687  assert_int_equal(GETP_INT32(&data_a, "0.'A.'.param_A"), 4321);
688  assert_int_equal(GETP_INT32(&data_b, "0.'B.'.param_B"), 1234);
689 
690  amxs_sync_ctx_stop_sync(ctx);
691  amxs_sync_ctx_delete(&ctx);
692 
693  amxc_var_clean(&data_a);
694  amxc_var_clean(&data_b);
695 }

◆ test_amxs_sync_copy_param_loop_prevention_multi_instance()

void test_amxs_sync_copy_param_loop_prevention_multi_instance ( UNUSED void **  state)

Definition at line 697 of file test_amxs_sync_copy.c.

697  {
698  amxs_sync_ctx_t* ctx = NULL;
699  amxs_sync_object_t* obj = NULL;
700  amxc_var_t data_a;
701  amxc_var_t data_b;
702  amxc_var_t* ptr_a = NULL;
703  amxc_var_t* ptr_b = NULL;
704 
705  amxc_var_init(&data_a);
706  amxc_var_init(&data_b);
707  handle_events();
708 
709  check_parameter(&data_a, &ptr_a, 'A', &data_b, &ptr_b, 'B', 1, false);
710 
711  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.", "B.", AMXS_SYNC_DEFAULT), 0);
712  assert_int_equal(amxs_sync_object_new_copy(&obj, "A_template.", "B_template.", AMXS_SYNC_DEFAULT), 0);
713  assert_int_equal(amxs_sync_object_add_new_copy_param(obj, "param_A", "param_B", AMXS_SYNC_DEFAULT), 0);
714  assert_int_equal(amxs_sync_ctx_add_object(ctx, obj), 0);
715  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
716  handle_events();
717  assert_int_equal(amxc_llist_size(&ctx->subscriptions), 4);
718 
719  // Verify that both sides are equal
720  check_parameter(&data_a, &ptr_a, 'A', &data_b, &ptr_b, 'B', 1, true);
721  check_parameter(&data_a, &ptr_a, 'A', &data_b, &ptr_b, 'B', 2, true);
722 
723  // Change A.1., B.2., A.2., then handle events
724  // A.1 should be equal to B.1
725  // A.2 and B.2 should be swapped
726  amxc_var_clean(&data_a);
727  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
728  amxc_var_add_key(uint32_t, &data_a, "param_A", 1234);
729  assert_int_equal(amxb_set(bus_ctx, "A.A_template.1.", &data_a, &data_a, 5), 0);
730 
731  amxc_var_clean(&data_b);
732  amxc_var_set_type(&data_b, AMXC_VAR_ID_HTABLE);
733  amxc_var_add_key(uint32_t, &data_b, "param_B", 1234);
734  assert_int_equal(amxb_set(bus_ctx, "B.B_template.2.", &data_b, &data_b, 5), 0);
735 
736  amxc_var_clean(&data_a);
737  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
738  amxc_var_add_key(uint32_t, &data_a, "param_A", 4321);
739  assert_int_equal(amxb_set(bus_ctx, "A.A_template.2.", &data_a, &data_a, 5), 0);
740 
741  handle_events();
742 
743  amxc_var_clean(&data_a);
744  amxc_var_clean(&data_b);
745  assert_int_equal(amxb_get(bus_ctx, "A.A_template.", 1, &data_a, 5), 0);
746  assert_int_equal(amxb_get(bus_ctx, "B.B_template.", 1, &data_b, 5), 0);
747 
748  assert_int_equal(GETP_UINT32(&data_a, "0.'A.A_template.1.'.param_A"), 1234);
749  assert_int_equal(GETP_UINT32(&data_b, "0.'B.B_template.1.'.param_B"), 1234);
750 
751  assert_int_equal(GETP_UINT32(&data_a, "0.'A.A_template.2.'.param_A"), 1234);
752  assert_int_equal(GETP_UINT32(&data_b, "0.'B.B_template.2.'.param_B"), 4321);
753 
754  amxs_sync_ctx_stop_sync(ctx);
755  amxs_sync_ctx_delete(&ctx);
756 
757  amxc_var_clean(&data_a);
758  amxc_var_clean(&data_b);
759 }
check_parameter
static void check_parameter(amxc_var_t *data_a, amxc_var_t **ptr_a, char name_a, amxc_var_t *data_b, amxc_var_t **ptr_b, char name_b, uint32_t template_nr, bool ptrs_equal)
Definition: test_amxs_sync_copy.c:318

◆ test_amxs_sync_copy_param_read_only()

void test_amxs_sync_copy_param_read_only ( UNUSED void **  state)

Definition at line 761 of file test_amxs_sync_copy.c.

761  {
762  amxs_sync_ctx_t* ctx = NULL;
763  amxc_var_t data_a;
764  amxc_var_t data_b;
765  amxc_var_t* ptr_a = NULL;
766  amxc_var_t* ptr_b = NULL;
767  int ret = 0;
768  amxd_trans_t trans;
769 
770  amxd_trans_init(&trans);
771  amxd_trans_set_attr(&trans, amxd_tattr_change_ro, true);
772 
773  amxc_var_init(&data_a);
774  amxc_var_init(&data_b);
775 
776  assert_int_equal(amxb_get(bus_ctx, "A.param_A_ro", 0, &data_a, 5), 0);
777  assert_int_equal(amxb_get(bus_ctx, "B.param_B_ro", 0, &data_b, 5), 0);
778  ptr_a = GETP_ARG(&data_a, "0.'A.'.param_A_ro");
779  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B_ro");
780 
781  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
782  assert_int_not_equal(ret, 0);
783 
784  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.", "B.", AMXS_SYNC_DEFAULT), 0);
785  assert_int_equal(amxs_sync_ctx_add_new_copy_param(ctx, "param_A_ro", "param_B_ro", AMXS_SYNC_DEFAULT), 0);
786  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
787  handle_events();
788  assert_int_equal(amxc_llist_size(&ctx->subscriptions), 2);
789 
790  amxc_var_clean(&data_b);
791  assert_int_equal(amxb_get(bus_ctx, "B.param_B_ro", 0, &data_b, 5), 0);
792  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B_ro");
793  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
794  assert_int_not_equal(ret, 0);
795 
796  amxs_sync_ctx_stop_sync(ctx);
797  assert_int_equal(amxs_sync_ctx_set_local_dm(ctx, NULL, test_get_dm()), 0);
798  assert_ptr_equal(amxs_sync_ctx_get_dm(ctx, amxs_sync_a_to_b), NULL);
799  assert_ptr_equal(amxs_sync_ctx_get_dm(ctx, amxs_sync_b_to_a), test_get_dm());
800  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
801  handle_events();
802 
803  amxc_var_clean(&data_b);
804  assert_int_equal(amxb_get(bus_ctx, "B.param_B_ro", 0, &data_b, 5), 0);
805  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B_ro");
806  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
807  assert_int_equal(ret, 0);
808 
809  amxd_trans_select_pathf(&trans, "A.");
810  amxd_trans_set_value(cstring_t, &trans, "param_A_ro", "I am written");
811  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
812 
813  handle_events();
814  amxc_var_clean(&data_a);
815  assert_int_equal(amxb_get(bus_ctx, "A.param_A_ro", 0, &data_a, 5), 0);
816  amxc_var_clean(&data_b);
817  assert_int_equal(amxb_get(bus_ctx, "B.param_B_ro", 0, &data_b, 5), 0);
818  ptr_a = GETP_ARG(&data_a, "0.'A.'.param_A_ro");
819  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B_ro");
820  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
821  assert_int_equal(ret, 0);
822 
823  amxs_sync_ctx_stop_sync(ctx);
824  amxs_sync_ctx_delete(&ctx);
825 
826  amxc_var_clean(&data_a);
827  amxc_var_clean(&data_b);
828  amxd_trans_clean(&trans);
829 }
amxs_sync_ctx_set_local_dm
amxs_status_t amxs_sync_ctx_set_local_dm(amxs_sync_ctx_t *ctx, amxd_dm_t *dm_a, amxd_dm_t *dm_b)
Set the local datamodel pointer for the sync root objects.
Definition: amxs_sync_ctx.c:964
amxs_sync_a_to_b
@ amxs_sync_a_to_b
Definition: amxs_types.h:80
amxs_sync_b_to_a
@ amxs_sync_b_to_a
Definition: amxs_types.h:81
amxs_sync_ctx_get_dm
amxd_dm_t * amxs_sync_ctx_get_dm(const amxs_sync_ctx_t *ctx, amxs_sync_direction_t direction)
Definition: amxs_util.c:367

◆ test_amxs_sync_copy_same_param()

void test_amxs_sync_copy_same_param ( UNUSED void **  state)

Definition at line 157 of file test_amxs_sync_copy.c.

157  {
158  amxs_sync_ctx_t* ctx = NULL;
159  amxs_sync_object_t* obj = NULL;
160  amxc_var_t data_a;
161  amxc_var_t data_b;
162  amxc_var_t* ptr_a = NULL;
163  amxc_var_t* ptr_b = NULL;
164  int ret = 0;
165 
166  amxc_var_init(&data_a);
167  amxc_var_init(&data_b);
168 
169  assert_int_equal(amxb_get(bus_ctx, "A.", 3, &data_a, 5), 0);
170  assert_int_equal(amxb_get(bus_ctx, "B.", 3, &data_b, 5), 0);
171  ptr_a = GETP_ARG(&data_a, "0.'A.'.param_A");
172  ptr_b = GETP_ARG(&data_b, "0.'B.'.param_B");
173 
174  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
175  assert_int_not_equal(ret, 0);
176 
177  ptr_a = GETP_ARG(&data_a, "0.'A.object_A.'.param_A");
178  ptr_b = GETP_ARG(&data_b, "0.'B.object_B.'.param_B");
179 
180  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
181  assert_int_not_equal(ret, 0);
182 
183  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.", "B.", AMXS_SYNC_DEFAULT), 0);
184  assert_int_equal(amxs_sync_ctx_add_new_copy_param(ctx, "param_A", "param_B", AMXS_SYNC_DEFAULT), 0);
185  assert_int_equal(amxs_sync_object_new_copy(&obj, "object_A.", "object_B.", AMXS_SYNC_DEFAULT), 0);
186  assert_int_equal(amxs_sync_object_add_new_copy_param(obj, "param_A", "param_B", AMXS_SYNC_DEFAULT), 0);
187  assert_int_equal(amxs_sync_ctx_add_object(ctx, obj), 0);
188  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
189  handle_events();
190  assert_int_equal(amxc_llist_size(&ctx->subscriptions), 6);
191 
192  amxc_var_clean(&data_b);
193  assert_int_equal(amxb_get(bus_ctx, "B.object_B.param_B", 0, &data_b, 5), 0);
194  ptr_b = GETP_ARG(&data_b, "0.'B.object_B.'.param_B");
195  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
196  assert_int_equal(ret, 0);
197 
198  amxc_var_clean(&data_a);
199  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
200  amxc_var_add_key(cstring_t, &data_a, "param_A", "Updated string");
201  assert_int_equal(amxb_set(bus_ctx, "A.object_A.", &data_a, &data_a, 5), 0);
202  handle_events();
203  amxc_var_clean(&data_b);
204  assert_int_equal(amxb_get(bus_ctx, "B.object_B.param_B", 0, &data_b, 5), 0);
205  ptr_a = GETP_ARG(&data_a, "0.'A.object_A.'.param_A");
206  ptr_b = GETP_ARG(&data_b, "0.'B.object_B.'.param_B");
207  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
208  assert_int_equal(ret, 0);
209 
210  amxs_sync_ctx_stop_sync(ctx);
211  amxs_sync_ctx_delete(&ctx);
212 
213  amxc_var_clean(&data_a);
214  amxc_var_clean(&data_b);
215 }

◆ test_amxs_sync_copy_template_object()

void test_amxs_sync_copy_template_object ( UNUSED void **  state)

Definition at line 331 of file test_amxs_sync_copy.c.

331  {
332  amxs_sync_ctx_t* ctx = NULL;
333  amxs_sync_object_t* obj = NULL;
334  amxc_var_t data_a;
335  amxc_var_t data_b;
336  amxc_var_t* ptr_a = NULL;
337  amxc_var_t* ptr_b = NULL;
338 
339  amxc_var_init(&data_a);
340  amxc_var_init(&data_b);
341 
342  /* Nothing synced yet, param_A and param_B each have their own value */
343  check_parameter(&data_a, &ptr_a, 'A', &data_b, &ptr_b, 'B', 1, false);
344  assert_int_equal(strcmp(GETP_CHAR(&data_a, "0.'A.A_template.1.'.flag"), "AA"), 0); // No sync yet so no flags set in param_action_cb
345  assert_int_equal(strcmp(GETP_CHAR(&data_b, "0.'B.B_template.1.'.flag"), "BB"), 0); // No sync yet so no flags set in param_action_cb
346 
347  /* Start syncing param_A and param_B */
348  handle_events();
349  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.", "B.", AMXS_SYNC_DEFAULT), 0);
350  assert_int_equal(amxs_sync_object_new_copy(&obj, "A_template.", "B_template.", AMXS_SYNC_DEFAULT), 0);
351  assert_int_equal(amxs_sync_object_add_new_param(obj, "param_A", "param_B", AMXS_SYNC_DEFAULT, amxs_sync_param_copy_trans_cb, param_action_cb, ctx), 0);
352  assert_int_equal(amxs_sync_ctx_add_object(ctx, obj), 0);
353  assert_int_equal(amxs_sync_ctx_start_sync(ctx), 0);
354  handle_events();
355  assert_int_equal(amxc_llist_size(&ctx->subscriptions), 4);
356 
357  /* Check param_A and param_B are in sync for template 1 */
358  check_parameter(&data_a, &ptr_a, 'A', &data_b, &ptr_b, 'B', 1, true);
359  assert_int_equal(strcmp(GETP_CHAR(&data_a, "0.'A.A_template.1.'.flag"), "AA C"), 0); // Parameters are synced both ways so we entered param_action_cb once
360  assert_int_equal(strcmp(GETP_CHAR(&data_b, "0.'B.B_template.1.'.flag"), "BB C"), 0); // Parameters are synced both ways so we entered param_action_cb once
361 
362  /* Check param_A and param_B are in sync for template 2 */
363  check_parameter(&data_a, &ptr_a, 'A', &data_b, &ptr_b, 'B', 2, true);
364  assert_int_equal(strcmp(GETP_CHAR(&data_a, "0.'A.A_template.2.'.flag"), "AA C"), 0);
365  assert_int_equal(strcmp(GETP_CHAR(&data_b, "0.'B.B_template.2.'.flag"), "BB C"), 0);
366 
367  /* Change param_A for template 1, it should sync to param_B */
368  amxc_var_clean(&data_a);
369  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
370  amxc_var_add_key(uint32_t, &data_a, "param_A", 1234);
371  assert_int_equal(amxb_set(bus_ctx, "A.A_template.1.", &data_a, &data_a, 5), 0);
372  handle_events();
373  check_parameter(&data_a, &ptr_a, 'A', &data_b, &ptr_b, 'B', 1, true);
374  assert_int_equal(strcmp(GETP_CHAR(&data_a, "0.'A.A_template.1.'.flag"), "AA C C"), 0); // 1st: creation ; 2nd: change of parameter
375  assert_int_equal(strcmp(GETP_CHAR(&data_b, "0.'B.B_template.1.'.flag"), "BB C C"), 0); // 1st: creation ; 2nd: sync of parameter
376 
377  /* Add template 3 for A, it should sync to B */
378  amxc_var_clean(&data_a);
379  assert_int_equal(amxb_add(bus_ctx, "A.A_template.", 3, NULL, NULL, &data_a, 5), 0);
380  handle_events();
381  check_parameter(&data_a, &ptr_a, 'A', &data_b, &ptr_b, 'B', 3, true);
382  assert_int_equal(strcmp(GETP_CHAR(&data_a, "0.'A.A_template.3.'.flag"), "AA C"), 0);
383  assert_int_equal(strcmp(GETP_CHAR(&data_b, "0.'B.B_template.3.'.flag"), "BB C"), 0);
384 
385  /* Change param_A for template 3, it should sync to param_B */
386  amxc_var_clean(&data_a);
387  amxc_var_set_type(&data_a, AMXC_VAR_ID_HTABLE);
388  amxc_var_add_key(uint32_t, &data_a, "param_A", 12345);
389  assert_int_equal(amxb_set(bus_ctx, "A.A_template.3.", &data_a, &data_a, 5), 0);
390  handle_events();
391  check_parameter(&data_a, &ptr_a, 'A', &data_b, &ptr_b, 'B', 3, true);
392  assert_int_equal(strcmp(GETP_CHAR(&data_a, "0.'A.A_template.3.'.flag"), "AA C C"), 0); // 1st: creation ; 2nd: change of parameter
393  assert_int_equal(strcmp(GETP_CHAR(&data_b, "0.'B.B_template.3.'.flag"), "BB C C"), 0); // 1st creation ; 2nd: sync of parameter
394 
395  /* Remove template 3 */
396  amxc_var_clean(&data_a);
397  assert_int_equal(amxb_del(bus_ctx, "A.A_template.", 3, NULL, &data_a, 5), 0);
398  handle_events();
399  amxc_var_clean(&data_b);
400  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template.3.", 0, &data_b, 5), 0);
401  assert_null(GETP_ARG(&data_b, "0.0"));
402 
403  amxs_sync_ctx_stop_sync(ctx);
404  amxs_sync_ctx_delete(&ctx);
405 
406  amxc_var_clean(&data_a);
407  amxc_var_clean(&data_b);
408 }
amxs_sync_object_add_new_param
amxs_status_t amxs_sync_object_add_new_param(amxs_sync_object_t *object, const char *param_a, const char *param_b, int attributes, amxs_translation_cb_t translation_cb, amxs_action_cb_t action_cb, void *priv)
Creates and adds a synchronization parameter to a synchronization object.
Definition: amxs_sync_object.c:125
amxs_sync_param_copy_trans_cb
amxs_status_t amxs_sync_param_copy_trans_cb(const amxs_sync_entry_t *entry, amxs_sync_direction_t direction, const amxc_var_t *input, amxc_var_t *output, void *priv)
Translates data from a dm:object-changed event to data suited for an amxb_set call for a single param...
param_action_cb
static amxs_status_t param_action_cb(const amxs_sync_entry_t *sync_entry, amxs_sync_direction_t direction, amxc_var_t *data, void *priv)
Definition: test_amxs_sync_copy.c:273

◆ test_amxs_sync_copy_template_sub_object()

void test_amxs_sync_copy_template_sub_object ( UNUSED void **  state)

Definition at line 893 of file test_amxs_sync_copy.c.

893  {
894  amxc_var_t data_a;
895  amxc_var_t data_b;
896  amxc_var_t* ptr_a = NULL;
897  amxc_var_t* ptr_b = NULL;
898  int ret = 0;
899  amxd_trans_t trans;
900 
901  amxd_trans_init(&trans);
902  amxd_trans_set_attr(&trans, amxd_tattr_change_ro, true);
903 
904  amxc_var_init(&data_a);
905  amxc_var_init(&data_b);
906 
907  handle_events();
908 
909  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
910  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
911 
912  assert_int_equal(test_load_dummy_remote("sync.odl"), 0);
913  assert_int_equal(amxo_parser_start_synchronize(test_get_parser()), 0);
914 
915  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
916  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
917  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.1.A_sub.'.text_A");
918  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.1.B_sub.'.text_B");
919  assert_string_equal(GET_CHAR(ptr_b, NULL), "I am A sub");
920  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
921  assert_int_equal(ret, 0);
922 
923  handle_events();
924 
925  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
926  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
927  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.1.A_sub.'.text_A");
928  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.1.B_sub.'.text_B");
929  assert_string_equal(GET_CHAR(ptr_b, NULL), "I am A sub");
930  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
931  assert_int_equal(ret, 0);
932 
933  amxd_trans_select_pathf(&trans, "A.A_template_sub.");
934  amxd_trans_add_inst(&trans, 2, NULL);
935  amxd_trans_set_value(cstring_t, &trans, "A_sub.text_A", "Changed text");
936  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
937  amxd_trans_clean(&trans);
938 
939  handle_events();
940  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.2.A_sub.", 0, &data_a, 5), 0);
941  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.2.B_sub.", 0, &data_b, 5), 0);
942  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.2.A_sub.'.text_A");
943  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.2.B_sub.'.text_B");
944  assert_string_equal(GET_CHAR(ptr_b, NULL), "Changed text");
945  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
946  assert_int_equal(ret, 0);
947 
948  amxd_trans_select_pathf(&trans, "A.A_template_sub.");
949  amxd_trans_add_inst(&trans, 3, NULL);
950  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
951  amxd_trans_clean(&trans);
952 
953  handle_events();
954  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.3.A_sub.", 0, &data_a, 5), 0);
955  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.3.B_sub.", 0, &data_b, 5), 0);
956  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.3.A_sub.'.text_A");
957  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.3.B_sub.'.text_B");
958  assert_string_equal(GET_CHAR(ptr_b, NULL), "I am A sub");
959  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
960  assert_int_equal(ret, 0);
961 
962  amxd_trans_select_pathf(&trans, "B.B_template_sub.");
963  amxd_trans_add_inst(&trans, 4, NULL);
964  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
965  amxd_trans_clean(&trans);
966 
967  handle_events();
968  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.4.A_sub.", 0, &data_a, 5), 0);
969  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.4.B_sub.", 0, &data_b, 5), 0);
970  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.4.A_sub.'.text_A");
971  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.4.B_sub.'.text_B");
972  assert_string_equal(GET_CHAR(ptr_b, NULL), "I am B sub");
973  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
974  assert_int_equal(ret, 0);
975 
976  amxc_var_clean(&data_a);
977  amxc_var_clean(&data_b);
978  amxd_trans_clean(&trans);
979 }

◆ test_amxs_sync_copy_template_sub_object_batch_reverse()

void test_amxs_sync_copy_template_sub_object_batch_reverse ( UNUSED void **  state)

Definition at line 1134 of file test_amxs_sync_copy.c.

1134  {
1135  amxc_var_t data_a;
1136  amxc_var_t data_b;
1137  amxc_var_t* ptr_a = NULL;
1138  amxc_var_t* ptr_b = NULL;
1139  int ret = 0;
1140  amxd_trans_t trans;
1141 
1142  amxd_trans_init(&trans);
1143  amxd_trans_set_attr(&trans, amxd_tattr_change_ro, true);
1144 
1145  amxc_var_init(&data_a);
1146  amxc_var_init(&data_b);
1147 
1148  handle_events();
1149 
1150  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
1151  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
1152 
1153  assert_int_equal(test_load_dummy_remote("sync_batch_reverse.odl"), 0);
1154  assert_int_equal(amxo_parser_start_synchronize(test_get_parser()), 0);
1155 
1156  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
1157  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
1158 
1159  handle_events();
1160 
1161  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
1162  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
1163 
1164  amxd_trans_select_pathf(&trans, "B.B_template_sub.");
1165  amxd_trans_add_inst(&trans, 1, NULL);
1166  amxd_trans_set_value(cstring_t, &trans, "B_sub.text_B", "Changed text");
1167  amxd_trans_set_value(cstring_t, &trans, "param_B", "Changed text");
1168  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
1169  amxd_trans_clean(&trans);
1170 
1171  handle_events();
1172  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.", 2, &data_a, 5), 0);
1173  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.1.", 2, &data_b, 5), 0);
1174  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.1.A_sub.'.text_A");
1175  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.1.B_sub.'.text_B");
1176  assert_string_equal(GET_CHAR(ptr_a, NULL), "Changed text");
1177  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
1178  assert_int_equal(ret, 0);
1179  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.1.'.param_A");
1180  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.1.'.param_B");
1181  assert_string_equal(GET_CHAR(ptr_a, NULL), "Changed text");
1182  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
1183  assert_int_equal(ret, 0);
1184 
1185  amxd_trans_select_pathf(&trans, "A.A_template_sub.");
1186  amxd_trans_del_inst(&trans, 1, NULL);
1187  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
1188  amxd_trans_clean(&trans);
1189 
1190  handle_events();
1191  assert_int_not_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
1192  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
1193 
1194  amxc_var_clean(&data_a);
1195  amxc_var_clean(&data_b);
1196  amxd_trans_clean(&trans);
1197 }

◆ test_amxs_sync_copy_template_sub_object_reverse()

void test_amxs_sync_copy_template_sub_object_reverse ( UNUSED void **  state)

Definition at line 1069 of file test_amxs_sync_copy.c.

1069  {
1070  amxc_var_t data_a;
1071  amxc_var_t data_b;
1072  amxc_var_t* ptr_a = NULL;
1073  amxc_var_t* ptr_b = NULL;
1074  int ret = 0;
1075  amxd_trans_t trans;
1076 
1077  amxd_trans_init(&trans);
1078  amxd_trans_set_attr(&trans, amxd_tattr_change_ro, true);
1079 
1080  amxc_var_init(&data_a);
1081  amxc_var_init(&data_b);
1082 
1083  handle_events();
1084 
1085  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
1086  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
1087 
1088  assert_int_equal(test_load_dummy_remote("sync_reverse.odl"), 0);
1089  assert_int_equal(amxo_parser_start_synchronize(test_get_parser()), 0);
1090 
1091  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
1092  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
1093 
1094  handle_events();
1095 
1096  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
1097  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
1098 
1099  amxd_trans_select_pathf(&trans, "B.B_template_sub.");
1100  amxd_trans_add_inst(&trans, 1, NULL);
1101  amxd_trans_set_value(cstring_t, &trans, "B_sub.text_B", "Changed text");
1102  amxd_trans_set_value(cstring_t, &trans, "param_B", "Changed text");
1103  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
1104  amxd_trans_clean(&trans);
1105 
1106  handle_events();
1107  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.", 2, &data_a, 5), 0);
1108  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.1.", 2, &data_b, 5), 0);
1109  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.1.A_sub.'.text_A");
1110  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.1.B_sub.'.text_B");
1111  assert_string_equal(GET_CHAR(ptr_a, NULL), "Changed text");
1112  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
1113  assert_int_equal(ret, 0);
1114  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.1.'.param_A");
1115  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.1.'.param_B");
1116  assert_string_equal(GET_CHAR(ptr_a, NULL), "Changed text");
1117  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
1118  assert_int_equal(ret, 0);
1119 
1120  amxd_trans_select_pathf(&trans, "A.A_template_sub.");
1121  amxd_trans_del_inst(&trans, 1, NULL);
1122  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
1123  amxd_trans_clean(&trans);
1124 
1125  handle_events();
1126  assert_int_not_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
1127  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
1128 
1129  amxc_var_clean(&data_a);
1130  amxc_var_clean(&data_b);
1131  amxd_trans_clean(&trans);
1132 }

◆ test_amxs_sync_copy_template_sub_object_with_batch()

void test_amxs_sync_copy_template_sub_object_with_batch ( UNUSED void **  state)

Definition at line 981 of file test_amxs_sync_copy.c.

981  {
982  amxc_var_t data_a;
983  amxc_var_t data_b;
984  amxc_var_t* ptr_a = NULL;
985  amxc_var_t* ptr_b = NULL;
986  int ret = 0;
987  amxd_trans_t trans;
988 
989  amxd_trans_init(&trans);
990  amxd_trans_set_attr(&trans, amxd_tattr_change_ro, true);
991 
992  amxc_var_init(&data_a);
993  amxc_var_init(&data_b);
994 
995  handle_events();
996 
997  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
998  assert_int_not_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
999 
1000  assert_int_equal(test_load_dummy_remote("sync_batch.odl"), 0);
1001  assert_int_equal(amxo_parser_start_synchronize(test_get_parser()), 0);
1002 
1003  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
1004  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
1005  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.1.A_sub.'.text_A");
1006  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.1.B_sub.'.text_B");
1007  assert_string_equal(GET_CHAR(ptr_b, NULL), "I am A sub");
1008  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
1009  assert_int_equal(ret, 0);
1010 
1011  handle_events();
1012 
1013  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.1.A_sub.", 0, &data_a, 5), 0);
1014  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.1.B_sub.", 0, &data_b, 5), 0);
1015  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.1.A_sub.'.text_A");
1016  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.1.B_sub.'.text_B");
1017  assert_string_equal(GET_CHAR(ptr_b, NULL), "I am A sub");
1018  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
1019  assert_int_equal(ret, 0);
1020 
1021  amxd_trans_select_pathf(&trans, "A.A_template_sub.");
1022  amxd_trans_add_inst(&trans, 2, NULL);
1023  amxd_trans_set_value(cstring_t, &trans, "A_sub.text_A", "Changed text");
1024  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
1025  amxd_trans_clean(&trans);
1026 
1027  handle_events();
1028  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.2.A_sub.", 0, &data_a, 5), 0);
1029  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.2.B_sub.", 0, &data_b, 5), 0);
1030  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.2.A_sub.'.text_A");
1031  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.2.B_sub.'.text_B");
1032  assert_string_equal(GET_CHAR(ptr_b, NULL), "Changed text");
1033  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
1034  assert_int_equal(ret, 0);
1035 
1036  amxd_trans_select_pathf(&trans, "A.A_template_sub.");
1037  amxd_trans_add_inst(&trans, 3, NULL);
1038  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
1039  amxd_trans_clean(&trans);
1040 
1041  handle_events();
1042  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.3.A_sub.", 0, &data_a, 5), 0);
1043  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.3.B_sub.", 0, &data_b, 5), 0);
1044  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.3.A_sub.'.text_A");
1045  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.3.B_sub.'.text_B");
1046  assert_string_equal(GET_CHAR(ptr_b, NULL), "I am A sub");
1047  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
1048  assert_int_equal(ret, 0);
1049 
1050  amxd_trans_select_pathf(&trans, "B.B_template_sub.");
1051  amxd_trans_add_inst(&trans, 4, NULL);
1052  assert_int_equal(amxd_trans_apply(&trans, test_get_dm()), 0);
1053  amxd_trans_clean(&trans);
1054 
1055  handle_events();
1056  assert_int_equal(amxb_get(bus_ctx, "A.A_template_sub.4.A_sub.", 0, &data_a, 5), 0);
1057  assert_int_equal(amxb_get(bus_ctx, "B.B_template_sub.4.B_sub.", 0, &data_b, 5), 0);
1058  ptr_a = GETP_ARG(&data_a, "0.'A.A_template_sub.4.A_sub.'.text_A");
1059  ptr_b = GETP_ARG(&data_b, "0.'B.B_template_sub.4.B_sub.'.text_B");
1060  assert_string_equal(GET_CHAR(ptr_b, NULL), "I am B sub");
1061  assert_int_equal(amxc_var_compare(ptr_a, ptr_b, &ret), 0);
1062  assert_int_equal(ret, 0);
1063 
1064  amxc_var_clean(&data_a);
1065  amxc_var_clean(&data_b);
1066  amxd_trans_clean(&trans);
1067 }

◆ test_amxs_sync_root_copy_template_object()

void test_amxs_sync_root_copy_template_object ( UNUSED void **  state)

Definition at line 410 of file test_amxs_sync_copy.c.

410  {
411  amxs_sync_ctx_t* ctx = NULL;
412  amxc_var_t data_a;
413  amxc_var_t data_b;
414  amxc_var_t* ptr_a = NULL;
415  amxc_var_t* ptr_b = NULL;
416 
417  amxc_var_init(&data_a);
418  amxc_var_init(&data_b);
419 
420  /* Nothing synced yet, param_A and param_B each have their own value */
421  check_parameter(&data_a, &ptr_a, 'A', &data_b, &ptr_b, 'B', 1, false);
422  assert_int_equal(strcmp(GETP_CHAR(&data_a, "0.'A.A_template.1.'.flag"), "AA"), 0); // No sync yet so no flags set in param_action_cb
423  assert_int_equal(strcmp(GETP_CHAR(&data_b, "0.'B.B_template.1.'.flag"), "BB"), 0); // No sync yet so no flags set in param_action_cb
424 
425  /* Start syncing param_A and param_B */
426  handle_events();
427  assert_int_equal(amxs_sync_ctx_new(&ctx, "A.A_template.", "B.B_template.", AMXS_SYNC_DEFAULT), 0);
428  assert_int_equal(amxs_sync_ctx_add_new_param(ctx, "param_A", "param_B", AMXS_SYNC_DEFAULT, amxs_sync_param_copy_trans_cb, param_action_cb, ctx), 0);
429  assert_int_not_equal(amxs_sync_ctx_start_sync(ctx), 0);
430 
431  amxs_sync_ctx_stop_sync(ctx);
432  amxs_sync_ctx_delete(&ctx);
433 
434  amxc_var_clean(&data_a);
435  amxc_var_clean(&data_b);
436 }
amxs_sync_ctx_add_new_param
amxs_status_t amxs_sync_ctx_add_new_param(amxs_sync_ctx_t *ctx, const char *param_a, const char *param_b, int attributes, amxs_translation_cb_t translation_cb, amxs_action_cb_t action_cb, void *priv)
Creates and adds a synchronization parameter to a synchronization context.
Definition: amxs_sync_ctx.c:881

◆ test_amxs_sync_setup()

int test_amxs_sync_setup ( UNUSED void **  state)

Definition at line 89 of file test_amxs_sync_copy.c.

89  {
90  assert_int_equal(test_register_dummy_be(), 0);
91  assert_int_equal(amxb_connect(&bus_ctx, "dummy:/tmp/dummy.sock"), 0);
92  assert_int_equal(test_load_dummy_remote("a.odl"), 0);
93  assert_int_equal(test_load_dummy_remote("b.odl"), 0);
94 
95  return 0;
96 }
test_register_dummy_be
int test_register_dummy_be(void)
Definition: dummy_be.c:244

◆ test_amxs_sync_teardown()

int test_amxs_sync_teardown ( UNUSED void **  state)

Definition at line 98 of file test_amxs_sync_copy.c.

98  {
99  amxb_disconnect(bus_ctx);
100  amxb_free(&bus_ctx);
101  assert_int_equal(test_unregister_dummy_be(), 0);
102 
103  return 0;
104 }
test_unregister_dummy_be
int test_unregister_dummy_be(void)
Definition: dummy_be.c:249

Variable Documentation

◆ bus_ctx

amxb_bus_ctx_t* bus_ctx = NULL
static

Definition at line 82 of file test_amxs_sync_copy.c.