tests/engine-tests/check_engine_error.c

   1 #include "support.h"
   2 #include "engine_support.h"
   3
   4 #include "opensync/engine/opensync_engine_internals.h"
   5 #include "opensync/engine/opensync_engine_private.h"
   6
   7 #include "opensync/group/opensync_group_internals.h"
   8 #include "opensync/client/opensync_client_internals.h"
   9
  10 #include <opensync/opensync-group.h>
  11 #include <opensync/opensync-data.h>
  12 #include <opensync/opensync-format.h>
  13 #include <opensync/opensync-client.h>
  14 #include <opensync/opensync-engine.h>
  15 #include <opensync/opensync-context.h>
  16
  17 #include "../mock-plugin/mock_sync.h"
  18
  19 static void _member_add_objtype(OSyncMember *member, const char *objtype)
  20 {
  21        OSyncObjTypeSink *sink = NULL;
  22        osync_assert(member);
  23        osync_assert(objtype);
  24
  25        if (!osync_member_find_objtype_sink(member, objtype)) {
  26                sink = osync_objtype_sink_new(objtype, NULL);
  27                osync_member_add_objtype_sink(member, sink);
  28                osync_objtype_sink_unref(sink);
  29        }
  30 }
  31
  32 int num_connect = 0;
  33 int num_disconnect = 0;
  34 int num_get_changes = 0;
  35
  36 static void connect1(void *data, OSyncPluginInfo *info, OSyncContext *ctx)
  37 {
  38         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, data, info, ctx);
  39
  40         g_atomic_int_inc(&(num_connect));
  41
  42         osync_context_report_success(ctx);
  43
  44         osync_trace(TRACE_EXIT, "%s", __func__);
  45 }
  46
  47 static void connect_error(void *data, OSyncPluginInfo *info, OSyncContext *ctx)
  48 {
  49         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, data, info, ctx);
  50
  51         g_atomic_int_inc(&(num_connect));
  52
  53         osync_context_report_error(ctx, OSYNC_ERROR_GENERIC, "connect error");
  54
  55         osync_trace(TRACE_EXIT, "%s", __func__);
  56 }
  57
  58 static void disconnect(void *data, OSyncPluginInfo *info, OSyncContext *ctx)
  59 {
  60         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, data, info, ctx);
  61
  62         g_atomic_int_inc(&(num_disconnect));
  63
  64         osync_context_report_success(ctx);
  65
  66         osync_trace(TRACE_EXIT, "%s", __func__);
  67 }
  68
  69 static void get_changes(void *data, OSyncPluginInfo *info, OSyncContext *ctx)
  70 {
  71         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, data, info, ctx);
  72
  73         g_atomic_int_inc(&(num_get_changes));
  74
  75         osync_context_report_success(ctx);
  76
  77         osync_trace(TRACE_EXIT, "%s", __func__);
  78 }
  79
  80 static void *initialize_error(OSyncPlugin *plugin, OSyncPluginInfo *info, OSyncError **error)
  81 {
  82         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, info, error);
  83
  84         osync_error_set(error, OSYNC_ERROR_GENERIC, "init error");
  85
  86         osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
  87         return NULL;
  88 }
  89
  90 static void *initialize(OSyncPlugin *plugin, OSyncPluginInfo *info, OSyncError **error)
  91 {
  92         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, info, error);
  93
  94         mock_env *env = osync_try_malloc0(sizeof(mock_env), error);
  95         if (!env)
  96                 goto error;
  97
  98         OSyncObjTypeSink *sink = osync_objtype_sink_new("mockobjtype1", error);
  99         if (!sink)
 100                 goto error;
 101
 102         OSyncObjFormatSink *formatsink = osync_objformat_sink_new("mockobjtype1", error);
 103         osync_objtype_sink_add_objformat_sink(sink, formatsink);
 104
 105         OSyncObjTypeSinkFunctions functions;
 106         memset(&functions, 0, sizeof(functions));
 107         functions.connect = connect1;
 108         functions.disconnect = disconnect;
 109         functions.get_changes = get_changes;
 110
 111         osync_objtype_sink_set_functions(sink, functions, NULL);
 112         osync_plugin_info_add_objtype(info, sink);
 113         osync_objtype_sink_unref(sink);
 114
 115         osync_trace(TRACE_EXIT, "%s: %p", __func__, env);
 116         return (void *)env;
 117
 118 error:
 119         osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
 120         return NULL;
 121 }
 122
 123 static void *initialize_connect_error(OSyncPlugin *plugin, OSyncPluginInfo *info, OSyncError **error)
 124 {
 125         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, info, error);
 126
 127         mock_env *env = osync_try_malloc0(sizeof(mock_env), error);
 128         osync_assert(env);
 129
 130         OSyncObjTypeSink *sink = osync_plugin_info_nth_objtype(info, 0);
 131         osync_assert(sink);
 132
 133         OSyncObjFormatSink *formatsink = osync_objformat_sink_new("mockformat1", error);
 134         osync_objtype_sink_add_objformat_sink(sink, formatsink);
 135
 136         OSyncObjTypeSinkFunctions functions;
 137         memset(&functions, 0, sizeof(functions));
 138         functions.connect = connect_error;
 139         functions.disconnect = disconnect;
 140         functions.get_changes = get_changes;
 141
 142         osync_objtype_sink_set_functions(sink, functions, NULL);
 143         osync_plugin_info_add_objtype(info, sink);
 144         osync_objtype_sink_unref(sink);
 145
 146         osync_trace(TRACE_EXIT, "%s: %p", __func__, env);
 147         return (void *)env;
 148 }
 149
 150 static void finalize(void *data)
 151 {
 152         mock_env *env = data;
 153
 154         g_free(env);
 155 }
 156
 157 static OSyncDebugGroup *_create_group(char *testbed)
 158 {
 159         OSyncDebugGroup *debug = g_malloc0(sizeof(OSyncDebugGroup));
 160
 161         OSyncError *error = NULL;
 162         debug->group = osync_group_new(&error);
 163         fail_unless(debug->group != NULL, NULL);
 164         fail_unless(error == NULL, NULL);
 165         char *path = g_strdup_printf("%s/configs/group", testbed);
 166         osync_group_set_configdir(debug->group, path);
 167         g_free(path);
 168
 169         debug->member1 = osync_member_new(&error);
 170         fail_unless(debug->member1 != NULL, NULL);
 171         fail_unless(error == NULL, NULL);
 172         osync_group_add_member(debug->group, debug->member1);
 173         osync_member_set_pluginname(debug->member1, "mock-sync-foo");
 174         path = g_strdup_printf("%s/configs/group/1", testbed);
 175         osync_member_set_configdir(debug->member1, path);
 176         g_free(path);
 177         _member_add_objtype(debug->member1, "mockobjtype1");
 178         OSyncPluginConfig *config1 = simple_plugin_config(NULL, "data1", "mockobjtype1", "mockobjformat1", NULL);
 179         osync_member_set_config(debug->member1, config1);
 180         osync_plugin_config_unref(config1);
 181
 182         debug->member2 = osync_member_new(&error);
 183         fail_unless(debug->member2 != NULL, NULL);
 184         fail_unless(error == NULL, NULL);
 185         osync_group_add_member(debug->group, debug->member2);
 186         osync_member_set_pluginname(debug->member2, "mock-sync-foo");
 187         path = g_strdup_printf("%s/configs/group/2", testbed);
 188         osync_member_set_configdir(debug->member2, path);
 189         g_free(path);
 190
 191         _member_add_objtype(debug->member2, "mockobjtype1");
 192
 193         OSyncPluginConfig *config2 = simple_plugin_config(NULL, "data2", "mockobjtype1", "mockobjformat1", NULL);
 194         osync_member_set_config(debug->member2, config2);
 195         osync_plugin_config_unref(config2);
 196
 197
 198
 199         debug->plugin = osync_plugin_new(&error);
 200         fail_unless(debug->plugin != NULL, NULL);
 201         fail_unless(error == NULL, NULL);
 202
 203         osync_plugin_set_name(debug->plugin, "mock-sync-foo");
 204         osync_plugin_set_longname(debug->plugin, "Mock Sync Plugin");
 205         osync_plugin_set_description(debug->plugin, "This is a pseudo plugin");
 206         osync_plugin_set_start_type(debug->plugin, OSYNC_START_TYPE_EXTERNAL);
 207         osync_plugin_set_config_type(debug->plugin, OSYNC_PLUGIN_NO_CONFIGURATION);
 208
 209         osync_plugin_set_initialize(debug->plugin, initialize);
 210         osync_plugin_set_finalize(debug->plugin, finalize);
 211
 212
 213         debug->plugin2 = osync_plugin_new(&error);
 214         fail_unless(debug->plugin2 != NULL, NULL);
 215         fail_unless(error == NULL, NULL);
 216
 217         osync_plugin_set_name(debug->plugin2, "mock-sync-foo");
 218         osync_plugin_set_longname(debug->plugin2, "Mock Sync Plugin");
 219         osync_plugin_set_description(debug->plugin2, "This is a pseudo plugin");
 220         osync_plugin_set_start_type(debug->plugin2, OSYNC_START_TYPE_EXTERNAL);
 221
 222         osync_plugin_set_initialize(debug->plugin2, initialize_error);
 223         osync_plugin_set_finalize(debug->plugin2, finalize);
 224
 225
 226
 227
 228         debug->client1 = osync_client_new(&error);
 229         fail_unless(debug->client1 != NULL, NULL);
 230         fail_unless(error == NULL, NULL);
 231         char *pipe_path = g_strdup_printf("%s/configs/group/1/pluginpipe", testbed);
 232         osync_client_run_external(debug->client1, pipe_path, debug->plugin, &error);
 233         g_free(pipe_path);
 234
 235         debug->client2 = osync_client_new(&error);
 236         fail_unless(debug->client2 != NULL, NULL);
 237         fail_unless(error == NULL, NULL);
 238         pipe_path = g_strdup_printf("%s/configs/group/2/pluginpipe", testbed);
 239         osync_client_run_external(debug->client2, pipe_path, debug->plugin2, &error);
 240         g_free(pipe_path);
 241
 242         return debug;
 243 }
 244
 245 static OSyncDebugGroup *_create_group2(char *testbed)
 246 {
 247         OSyncDebugGroup *debug = g_malloc0(sizeof(OSyncDebugGroup));
 248
 249         OSyncError *error = NULL;
 250         debug->group = osync_group_new(&error);
 251         fail_unless(debug->group != NULL, NULL);
 252         fail_unless(error == NULL, NULL);
 253         char *path = g_strdup_printf("%s/configs/group", testbed);
 254         osync_group_set_configdir(debug->group, path);
 255         g_free(path);
 256
 257         debug->member1 = osync_member_new(&error);
 258         fail_unless(debug->member1 != NULL, NULL);
 259         fail_unless(error == NULL, NULL);
 260         osync_group_add_member(debug->group, debug->member1);
 261         osync_member_set_pluginname(debug->member1, "mock-sync-foo");
 262         path = g_strdup_printf("%s/configs/group/1", testbed);
 263         osync_member_set_configdir(debug->member1, path);
 264         g_free(path);
 265
 266         _member_add_objtype(debug->member1, "mockobjtype1");
 267         OSyncPluginConfig *config1 = simple_plugin_config(NULL, "data1", "mockobjtype1", "mockobjformat1", NULL);
 268         osync_member_set_config(debug->member1, config1);
 269         osync_plugin_config_unref(config1);
 270
 271
 272         debug->member2 = osync_member_new(&error);
 273         fail_unless(debug->member2 != NULL, NULL);
 274         fail_unless(error == NULL, NULL);
 275         osync_group_add_member(debug->group, debug->member2);
 276         osync_member_set_pluginname(debug->member2, "mock-sync-foo");
 277         path = g_strdup_printf("%s/configs/group/2", testbed);
 278         osync_member_set_configdir(debug->member2, path);
 279         g_free(path);
 280
 281         _member_add_objtype(debug->member2, "mockobjtype1");
 282         OSyncPluginConfig *config2 = simple_plugin_config(NULL, "data2", "mockobjtype1", "mockobjformat1", NULL);
 283         osync_member_set_config(debug->member2, config2);
 284         osync_plugin_config_unref(config2);
 285
 286
 287         debug->plugin = osync_plugin_new(&error);
 288         fail_unless(debug->plugin != NULL, NULL);
 289         fail_unless(error == NULL, NULL);
 290
 291         osync_plugin_set_name(debug->plugin, "mock-sync-foo");
 292         osync_plugin_set_longname(debug->plugin, "Mock Sync Plugin");
 293         osync_plugin_set_description(debug->plugin, "This is a pseudo plugin");
 294         osync_plugin_set_start_type(debug->plugin, OSYNC_START_TYPE_EXTERNAL);
 295         osync_plugin_set_config_type(debug->plugin, OSYNC_PLUGIN_NO_CONFIGURATION);
 296
 297         osync_plugin_set_initialize(debug->plugin, initialize_error);
 298         osync_plugin_set_finalize(debug->plugin, finalize);
 299
 300
 301         debug->plugin2 = osync_plugin_new(&error);
 302         fail_unless(debug->plugin2 != NULL, NULL);
 303         fail_unless(error == NULL, NULL);
 304
 305         osync_plugin_set_name(debug->plugin2, "mock-sync-foo");
 306         osync_plugin_set_longname(debug->plugin2, "Mock Sync Plugin");
 307         osync_plugin_set_description(debug->plugin2, "This is a pseudo plugin");
 308         osync_plugin_set_start_type(debug->plugin2, OSYNC_START_TYPE_EXTERNAL);
 309
 310         osync_plugin_set_initialize(debug->plugin2, initialize_error);
 311         osync_plugin_set_finalize(debug->plugin2, finalize);
 312
 313
 314
 315
 316         debug->client1 = osync_client_new(&error);
 317         fail_unless(debug->client1 != NULL, NULL);
 318         fail_unless(error == NULL, NULL);
 319         char *pipe_path = g_strdup_printf("%s/configs/group/1/pluginpipe", testbed);
 320         osync_client_run_external(debug->client1, pipe_path, debug->plugin, &error);
 321         g_free(pipe_path);
 322
 323         debug->client2 = osync_client_new(&error);
 324         fail_unless(debug->client2 != NULL, NULL);
 325         fail_unless(error == NULL, NULL);
 326         pipe_path = g_strdup_printf("%s/configs/group/2/pluginpipe", testbed);
 327         osync_client_run_external(debug->client2, pipe_path, debug->plugin2, &error);
 328         g_free(pipe_path);
 329
 330         return debug;
 331 }
 332
 333 static OSyncDebugGroup *_create_group3(char *testbed)
 334 {
 335         OSyncDebugGroup *debug = g_malloc0(sizeof(OSyncDebugGroup));
 336
 337         OSyncError *error = NULL;
 338         debug->group = osync_group_new(&error);
 339         fail_unless(debug->group != NULL, NULL);
 340         fail_unless(error == NULL, NULL);
 341         char *path = g_strdup_printf("%s/configs/group", testbed);
 342         osync_group_set_configdir(debug->group, path);
 343         g_free(path);
 344
 345         debug->member1 = osync_member_new(&error);
 346         fail_unless(debug->member1 != NULL, NULL);
 347         fail_unless(error == NULL, NULL);
 348         osync_group_add_member(debug->group, debug->member1);
 349         osync_member_set_pluginname(debug->member1, "mock-sync-foo");
 350         path = g_strdup_printf("%s/configs/group/1", testbed);
 351         osync_member_set_configdir(debug->member1, path);
 352         g_free(path);
 353
 354         _member_add_objtype(debug->member1, "mockobjtype1");
 355
 356         debug->member2 = osync_member_new(&error);
 357         fail_unless(debug->member2 != NULL, NULL);
 358         fail_unless(error == NULL, NULL);
 359         osync_group_add_member(debug->group, debug->member2);
 360         osync_member_set_pluginname(debug->member2, "mock-sync-foo");
 361         path = g_strdup_printf("%s/configs/group/2", testbed);
 362         osync_member_set_configdir(debug->member2, path);
 363         g_free(path);
 364
 365         _member_add_objtype(debug->member2, "mockobjtype1");
 366
 367
 368
 369         debug->plugin = osync_plugin_new(&error);
 370         fail_unless(debug->plugin != NULL, NULL);
 371         fail_unless(error == NULL, NULL);
 372
 373         osync_plugin_set_name(debug->plugin, "mock-sync-foo");
 374         osync_plugin_set_longname(debug->plugin, "Mock Sync Plugin");
 375         osync_plugin_set_description(debug->plugin, "This is a pseudo plugin");
 376         osync_plugin_set_start_type(debug->plugin, OSYNC_START_TYPE_EXTERNAL);
 377         osync_plugin_set_config_type(debug->plugin, OSYNC_PLUGIN_NO_CONFIGURATION);
 378
 379         osync_plugin_set_initialize(debug->plugin, initialize_error);
 380         osync_plugin_set_finalize(debug->plugin, finalize);
 381
 382
 383         debug->plugin2 = osync_plugin_new(&error);
 384         fail_unless(debug->plugin2 != NULL, NULL);
 385         fail_unless(error == NULL, NULL);
 386
 387         osync_plugin_set_name(debug->plugin2, "mock-sync-foo");
 388         osync_plugin_set_longname(debug->plugin2, "Mock Sync Plugin");
 389         osync_plugin_set_description(debug->plugin2, "This is a pseudo plugin");
 390         osync_plugin_set_start_type(debug->plugin2, OSYNC_START_TYPE_EXTERNAL);
 391
 392         osync_plugin_set_initialize(debug->plugin2, initialize_error);
 393         osync_plugin_set_finalize(debug->plugin2, finalize);
 394
 395
 396
 397
 398         debug->client1 = osync_client_new(&error);
 399         fail_unless(debug->client1 != NULL, NULL);
 400         fail_unless(error == NULL, NULL);
 401         char *pipe_path = g_strdup_printf("%s/configs/group/1/pluginpipe", testbed);
 402         osync_client_run_external(debug->client1, pipe_path, debug->plugin, &error);
 403         g_free(pipe_path);
 404
 405         debug->client2 = osync_client_new(&error);
 406         fail_unless(debug->client2 != NULL, NULL);
 407         fail_unless(error == NULL, NULL);
 408         pipe_path = g_strdup_printf("%s/configs/group/2/pluginpipe", testbed);
 409         osync_client_run_external(debug->client2, pipe_path, debug->plugin2, &error);
 410         g_free(pipe_path);
 411
 412         return debug;
 413 }
 414
 415 static OSyncDebugGroup *_create_group4(char *testbed)
 416 {
 417         OSyncDebugGroup *debug = g_malloc0(sizeof(OSyncDebugGroup));
 418
 419         OSyncError *error = NULL;
 420         debug->group = osync_group_new(&error);
 421         fail_unless(debug->group != NULL, NULL);
 422         fail_unless(error == NULL, NULL);
 423         char *path = g_strdup_printf("%s/configs/group", testbed);
 424         osync_group_set_configdir(debug->group, path);
 425         g_free(path);
 426
 427         debug->member1 = osync_member_new(&error);
 428         fail_unless(debug->member1 != NULL, NULL);
 429         fail_unless(error == NULL, NULL);
 430         osync_group_add_member(debug->group, debug->member1);
 431         osync_member_set_pluginname(debug->member1, "mock-sync-foo");
 432         path = g_strdup_printf("%s/configs/group/1", testbed);
 433         osync_member_set_configdir(debug->member1, path);
 434         g_free(path);
 435
 436         _member_add_objtype(debug->member1, "mockobjtype1");
 437         OSyncPluginConfig *config1 = simple_plugin_config(NULL, "data1", "mockobjtype1", "mockobjformat1", NULL);
 438         osync_member_set_config(debug->member1, config1);
 439         osync_plugin_config_unref(config1);
 440
 441
 442         debug->member2 = osync_member_new(&error);
 443         fail_unless(debug->member2 != NULL, NULL);
 444         fail_unless(error == NULL, NULL);
 445         osync_group_add_member(debug->group, debug->member2);
 446         osync_member_set_pluginname(debug->member2, "mock-sync-foo");
 447         path = g_strdup_printf("%s/configs/group/2", testbed);
 448         osync_member_set_configdir(debug->member2, path);
 449         g_free(path);
 450
 451         OSyncPluginConfig *config2 = simple_plugin_config(NULL, "data2", "mockobjtype1", "mockobjformat1", NULL);
 452         osync_member_set_config(debug->member2, config2);
 453         osync_plugin_config_unref(config2);
 454
 455
 456         debug->plugin = osync_plugin_new(&error);
 457         fail_unless(debug->plugin != NULL, NULL);
 458         fail_unless(error == NULL, NULL);
 459
 460         osync_plugin_set_name(debug->plugin, "mock-sync-foo");
 461         osync_plugin_set_longname(debug->plugin, "Mock Sync Plugin");
 462         osync_plugin_set_description(debug->plugin, "This is a pseudo plugin");
 463         osync_plugin_set_start_type(debug->plugin, OSYNC_START_TYPE_EXTERNAL);
 464         osync_plugin_set_config_type(debug->plugin, OSYNC_PLUGIN_NO_CONFIGURATION);
 465
 466         osync_plugin_set_initialize(debug->plugin, initialize);
 467         osync_plugin_set_finalize(debug->plugin, finalize);
 468
 469
 470         debug->client1 = osync_client_new(&error);
 471         fail_unless(debug->client1 != NULL, NULL);
 472         fail_unless(error == NULL, NULL);
 473         char *pipe_path = g_strdup_printf("%s/configs/group/1/pluginpipe", testbed);
 474         osync_client_run_external(debug->client1, pipe_path, debug->plugin, &error);
 475         g_free(pipe_path);
 476
 477         debug->client2 = osync_client_new(&error);
 478         fail_unless(debug->client2 != NULL, NULL);
 479         fail_unless(error == NULL, NULL);
 480         pipe_path = g_strdup_printf("%s/configs/group/2/pluginpipe", testbed);
 481         osync_client_run_external(debug->client2, pipe_path, debug->plugin, &error);
 482         g_free(pipe_path);
 483
 484         return debug;
 485 }
 486
 487 static OSyncDebugGroup *_create_group5(char *testbed)
 488 {
 489         OSyncDebugGroup *debug = g_malloc0(sizeof(OSyncDebugGroup));
 490
 491         OSyncError *error = NULL;
 492         debug->group = osync_group_new(&error);
 493         fail_unless(debug->group != NULL, NULL);
 494         fail_unless(error == NULL, NULL);
 495         char *path = g_strdup_printf("%s/configs/group", testbed);
 496         osync_group_set_configdir(debug->group, path);
 497         g_free(path);
 498
 499         debug->member1 = osync_member_new(&error);
 500         fail_unless(debug->member1 != NULL, NULL);
 501         fail_unless(error == NULL, NULL);
 502         osync_group_add_member(debug->group, debug->member1);
 503         osync_member_set_pluginname(debug->member1, "mock-sync-foo");
 504         path = g_strdup_printf("%s/configs/group/1", testbed);
 505         osync_member_set_configdir(debug->member1, path);
 506         g_free(path);
 507
 508         _member_add_objtype(debug->member1, "mockobjtype1");
 509         OSyncPluginConfig *config1 = simple_plugin_config(NULL, "data1", "mockobjtype1", "mockobjformat1", NULL);
 510         osync_member_set_config(debug->member1, config1);
 511         osync_plugin_config_unref(config1);
 512
 513
 514         debug->member2 = osync_member_new(&error);
 515         fail_unless(debug->member2 != NULL, NULL);
 516         fail_unless(error == NULL, NULL);
 517         osync_group_add_member(debug->group, debug->member2);
 518         osync_member_set_pluginname(debug->member2, "mock-sync-foo");
 519         path = g_strdup_printf("%s/configs/group/2", testbed);
 520         osync_member_set_configdir(debug->member2, path);
 521         g_free(path);
 522         _member_add_objtype(debug->member2, "mockobjtype1");
 523         OSyncPluginConfig *config2 = simple_plugin_config(NULL, "data2", "mockobjtype1", "mockobjformat1", NULL);
 524         osync_member_set_config(debug->member2, config2);
 525         osync_plugin_config_unref(config2);
 526
 527
 528         debug->plugin = osync_plugin_new(&error);
 529         fail_unless(debug->plugin != NULL, NULL);
 530         fail_unless(error == NULL, NULL);
 531
 532         osync_plugin_set_name(debug->plugin, "mock-sync-foo");
 533         osync_plugin_set_longname(debug->plugin, "Mock Sync Plugin");
 534         osync_plugin_set_description(debug->plugin, "This is a pseudo plugin");
 535         osync_plugin_set_start_type(debug->plugin, OSYNC_START_TYPE_EXTERNAL);
 536         osync_plugin_set_config_type(debug->plugin, OSYNC_PLUGIN_NO_CONFIGURATION);
 537
 538         osync_plugin_set_initialize(debug->plugin, initialize_connect_error);
 539         osync_plugin_set_finalize(debug->plugin, finalize);
 540
 541
 542         debug->plugin2 = osync_plugin_new(&error);
 543         fail_unless(debug->plugin2 != NULL, NULL);
 544         fail_unless(error == NULL, NULL);
 545
 546         osync_plugin_set_name(debug->plugin2, "mock-sync-foo");
 547         osync_plugin_set_longname(debug->plugin2, "Mock Sync Plugin");
 548         osync_plugin_set_description(debug->plugin2, "This is a pseudo plugin");
 549         osync_plugin_set_start_type(debug->plugin2, OSYNC_START_TYPE_EXTERNAL);
 550
 551         osync_plugin_set_initialize(debug->plugin2, initialize_connect_error);
 552         osync_plugin_set_finalize(debug->plugin2, finalize);
 553
 554
 555         debug->client1 = osync_client_new(&error);
 556         fail_unless(debug->client1 != NULL, NULL);
 557         fail_unless(error == NULL, NULL);
 558         char *pipe_path = g_strdup_printf("%s/configs/group/1/pluginpipe", testbed);
 559         osync_client_run_external(debug->client1, pipe_path, debug->plugin, &error);
 560         g_free(pipe_path);
 561
 562         debug->client2 = osync_client_new(&error);
 563         fail_unless(debug->client2 != NULL, NULL);
 564         fail_unless(error == NULL, NULL);
 565         pipe_path = g_strdup_printf("%s/configs/group/2/pluginpipe", testbed);
 566         osync_client_run_external(debug->client2, pipe_path, debug->plugin2, &error);
 567         g_free(pipe_path);
 568
 569         return debug;
 570 }
 571
 572 static void _free_group(OSyncDebugGroup *debug)
 573 {
 574         osync_client_unref(debug->client1);
 575         osync_client_unref(debug->client2);
 576
 577         if (debug->plugin)
 578                 osync_plugin_unref(debug->plugin);
 579
 580         if (debug->plugin2)
 581                 osync_plugin_unref(debug->plugin2);
 582
 583         osync_member_unref(debug->member1);
 584         osync_member_unref(debug->member2);
 585         osync_group_unref(debug->group);
 586
 587         g_free(debug);
 588 }
 589
 590 static void _engine_instrument_pluginenv(OSyncEngine *engine, OSyncDebugGroup *debug)
 591 {
 592         fail_unless(engine->pluginenv == NULL, NULL);
 593         engine->pluginenv = osync_plugin_env_new(NULL);
 594
 595         if (debug->plugin)
 596                 osync_plugin_env_register_plugin(engine->pluginenv, debug->plugin);
 597
 598         if (debug->plugin2)
 599                 osync_plugin_env_register_plugin(engine->pluginenv, debug->plugin2);
 600 }
 601
 602 START_TEST (single_init_error)
 603 {
 604         char *testbed = setup_testbed("sync_setup");
 605         char *formatdir = g_strdup_printf("%s/formats", testbed);
 606         char *plugindir = g_strdup_printf("%s/plugins", testbed);
 607
 608         OSyncError *error = NULL;
 609         OSyncDebugGroup *debug = _create_group(testbed);
 610
 611         OSyncEngine *engine = osync_engine_new(debug->group, &error);
 612         fail_unless(engine != NULL, NULL);
 613         fail_unless(error == NULL, NULL);
 614
 615         osync_engine_set_schemadir(engine, testbed);
 616         osync_engine_set_plugindir(engine, plugindir);
 617         osync_engine_set_formatdir(engine, formatdir);
 618
 619         _engine_instrument_pluginenv(engine, debug);
 620
 621         fail_unless(!osync_engine_initialize(engine, &error), NULL);
 622         fail_unless(error != NULL, NULL);
 623         osync_error_unref(&error);
 624
 625         fail_unless(!synchronize_once(engine, &error), NULL);
 626         fail_unless(error != NULL, NULL);
 627         osync_error_unref(&error);
 628
 629         _free_group(debug);
 630
 631         osync_engine_unref(engine);
 632
 633         g_free(formatdir);
 634         g_free(plugindir);
 635
 636         destroy_testbed(testbed);
 637 }
 638 END_TEST
 639
 640 START_TEST (double_init_error)
 641 {
 642         char *testbed = setup_testbed("sync_setup");
 643         char *formatdir = g_strdup_printf("%s/formats", testbed);
 644         char *plugindir = g_strdup_printf("%s/plugins", testbed);
 645
 646         OSyncError *error = NULL;
 647         OSyncDebugGroup *debug = _create_group2(testbed);
 648
 649         OSyncEngine *engine = osync_engine_new(debug->group, &error);
 650         fail_unless(engine != NULL, NULL);
 651         fail_unless(error == NULL, NULL);
 652
 653         osync_engine_set_schemadir(engine, testbed);
 654         osync_engine_set_plugindir(engine, plugindir);
 655         osync_engine_set_formatdir(engine, formatdir);
 656
 657         _engine_instrument_pluginenv(engine, debug);
 658
 659         fail_unless(!osync_engine_initialize(engine, &error), NULL);
 660         fail_unless(error != NULL, NULL);
 661         osync_error_unref(&error);
 662
 663         fail_unless(!synchronize_once(engine, &error), NULL);
 664         fail_unless(error != NULL, NULL);
 665         osync_error_unref(&error);
 666
 667         _free_group(debug);
 668
 669         osync_engine_unref(engine);
 670
 671         g_free(formatdir);
 672         g_free(plugindir);
 673
 674         destroy_testbed(testbed);
 675 }
 676 END_TEST
 677
 678 START_TEST (no_config_error)
 679 {
 680         char *testbed = setup_testbed("sync_setup");
 681         char *formatdir = g_strdup_printf("%s/formats", testbed);
 682         char *plugindir = g_strdup_printf("%s/plugins", testbed);
 683
 684         OSyncError *error = NULL;
 685         OSyncDebugGroup *debug = _create_group3(testbed);
 686
 687         OSyncEngine *engine = osync_engine_new(debug->group, &error);
 688         fail_unless(engine != NULL, NULL);
 689         fail_unless(error == NULL, NULL);
 690
 691         osync_engine_set_schemadir(engine, testbed);
 692         osync_engine_set_plugindir(engine, plugindir);
 693         osync_engine_set_formatdir(engine, formatdir);
 694
 695         _engine_instrument_pluginenv(engine, debug);
 696
 697         fail_unless(!osync_engine_initialize(engine, &error), NULL);
 698         fail_unless(error != NULL, NULL);
 699         osync_error_unref(&error);
 700
 701         fail_unless(!synchronize_once(engine, &error), NULL);
 702         fail_unless(error != NULL, NULL);
 703         osync_error_unref(&error);
 704
 705         _free_group(debug);
 706
 707         osync_engine_unref(engine);
 708
 709         g_free(formatdir);
 710         g_free(plugindir);
 711
 712         destroy_testbed(testbed);
 713 }
 714 END_TEST
 715
 716 START_TEST (no_objtype_error)
 717 {
 718         char *testbed = setup_testbed("sync_setup");
 719         char *formatdir = g_strdup_printf("%s/formats", testbed);
 720         char *plugindir = g_strdup_printf("%s/plugins", testbed);
 721
 722         OSyncError *error = NULL;
 723         OSyncDebugGroup *debug = _create_group4(testbed);
 724
 725         OSyncEngine *engine = osync_engine_new(debug->group, &error);
 726         fail_unless(engine != NULL, NULL);
 727         fail_unless(error == NULL, NULL);
 728
 729         osync_engine_set_schemadir(engine, testbed);
 730         osync_engine_set_plugindir(engine, plugindir);
 731         osync_engine_set_formatdir(engine, formatdir);
 732
 733         _engine_instrument_pluginenv(engine, debug);
 734
 735         fail_unless(!osync_engine_initialize(engine, &error), NULL);
 736         fail_unless(error != NULL, NULL);
 737         osync_error_unref(&error);
 738
 739         fail_unless(!synchronize_once(engine, &error), NULL);
 740         fail_unless(error != NULL, NULL);
 741         osync_error_unref(&error);
 742
 743         _free_group(debug);
 744
 745         osync_engine_unref(engine);
 746
 747         g_free(formatdir);
 748         g_free(plugindir);
 749
 750         destroy_testbed(testbed);
 751 }
 752 END_TEST
 753
 754 START_TEST (dual_connect_error)
 755 {
 756         char *testbed = setup_testbed("sync_setup");
 757         char *formatdir = g_strdup_printf("%s/formats", testbed);
 758         char *plugindir = g_strdup_printf("%s/plugins", testbed);
 759
 760         OSyncError *error = NULL;
 761         OSyncDebugGroup *debug = _create_group5(testbed);
 762
 763         OSyncEngine *engine = osync_engine_new(debug->group, &error);
 764         fail_unless(engine != NULL, NULL);
 765         fail_unless(error == NULL, NULL);
 766
 767         osync_engine_set_schemadir(engine, testbed);
 768         osync_engine_set_plugindir(engine, plugindir);
 769         osync_engine_set_formatdir(engine, formatdir);
 770
 771         _engine_instrument_pluginenv(engine, debug);
 772
 773         osync_engine_set_conflict_callback(engine, conflict_handler_choose_first, GINT_TO_POINTER(1));
 774         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
 775         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
 776         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
 777         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
 778
 779         fail_unless(osync_engine_initialize(engine, &error), NULL);
 780         fail_unless(error == NULL, NULL);
 781
 782         fail_unless(!synchronize_once(engine, &error), NULL);
 783         fail_unless(error != NULL, NULL);
 784         osync_error_unref(&error);
 785
 786         fail_unless(osync_engine_finalize(engine, &error), NULL);
 787         fail_unless(error == NULL, NULL);
 788
 789         fail_unless(num_connect == 2, NULL);
 790         fail_unless(num_disconnect == 0, NULL);
 791         fail_unless(num_get_changes == 0, NULL);
 792
 793         /* Client checks */
 794         fail_unless(num_client_connected == 0, NULL);
 795         fail_unless(num_client_read == 0, NULL);
 796         fail_unless(num_client_written == 0, NULL);
 797         fail_unless(num_client_disconnected == 0, NULL);
 798         fail_unless(num_client_errors == 2, NULL);
 799         fail_unless(num_client_sync_done == 0, NULL);
 800         fail_unless(num_client_discovered == 0, NULL);
 801
 802         /* Main sink checks */
 803
 804         fail_unless(num_client_main_disconnected == 2, NULL);
 805         fail_unless(num_client_main_connected == 2, NULL);
 806
 807         fail_unless(num_client_main_read == 0, NULL);
 808         fail_unless(num_client_main_written == 0, NULL);
 809         fail_unless(num_client_main_sync_done == 0, NULL);
 810
 811         /* Engine checks */
 812         fail_unless(num_engine_connected == 0, NULL);
 813         fail_unless(num_engine_errors == 1, NULL);
 814         fail_unless(num_engine_read == 0, NULL);
 815         fail_unless(num_engine_written == 0, NULL);
 816         fail_unless(num_engine_sync_done == 0, NULL);
 817         fail_unless(num_engine_disconnected == 0, NULL);
 818         fail_unless(num_engine_successful == 0, NULL);
 819         fail_unless(num_engine_end_conflicts == 0, NULL);
 820         fail_unless(num_engine_prev_unclean == 0, NULL);
 821
 822         /* Change checks */
 823         fail_unless(num_change_read == 0, NULL);
 824         fail_unless(num_change_written == 0, NULL);
 825         fail_unless(num_change_error == 0, NULL);
 826
 827         /* Mapping checks */
 828         fail_unless(num_mapping_solved == 0, NULL);
 829         fail_unless(num_mapping_errors == 0, NULL);
 830         fail_unless(num_mapping_conflicts == 0, NULL);
 831
 832         _free_group(debug);
 833
 834         osync_engine_unref(engine);
 835
 836         g_free(formatdir);
 837         g_free(plugindir);
 838
 839         destroy_testbed(testbed);
 840 }
 841 END_TEST
 842
 843 START_TEST (one_of_two_connect_error)
 844 {
 845         char *testbed = setup_testbed("sync");
 846         char *formatdir = g_strdup_printf("%s/formats", testbed);
 847         char *plugindir = g_strdup_printf("%s/plugins", testbed);
 848
 849         if (system("cp testdata data1/testdata"))
 850                 abort();
 851
 852         g_setenv("CONNECT_ERROR", "1", TRUE);
 853
 854         OSyncError *error = NULL;
 855         OSyncGroup *group = osync_group_new(&error);
 856         osync_group_set_schemadir(group, testbed);
 857         osync_group_load(group, "configs/group", &error);
 858         fail_unless(error == NULL, NULL);
 859
 860         OSyncEngine *engine = osync_engine_new(group, &error);
 861         fail_unless(engine != NULL, NULL);
 862         fail_unless(error == NULL, NULL);
 863
 864         osync_engine_set_schemadir(engine, testbed);
 865         osync_engine_set_plugindir(engine, plugindir);
 866         osync_engine_set_formatdir(engine, formatdir);
 867
 868         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
 869         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
 870
 871         fail_unless(osync_engine_initialize(engine, &error), NULL);
 872         fail_unless(error == NULL, NULL);
 873
 874         fail_unless(!synchronize_once(engine, &error), NULL);
 875         fail_unless(error != NULL, NULL);
 876         fail_unless(osync_error_is_set(&error), NULL);
 877
 878         fail_unless(num_client_errors == 1, NULL);
 879         fail_unless(num_client_connected == 1, NULL);
 880         fail_unless(num_client_disconnected == 1, NULL);
 881         fail_unless(num_client_written == 0, NULL);
 882         fail_unless(num_engine_errors == 1, NULL);
 883
 884         osync_error_unref(&error);
 885
 886         osync_engine_unref(engine);
 887
 888         osync_group_unref(group);
 889
 890         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 891
 892         g_free(formatdir);
 893         g_free(plugindir);
 894
 895         destroy_testbed(testbed);
 896 }
 897 END_TEST
 898
 899 START_TEST (two_of_three_connect_error)
 900 {
 901         char *testbed = setup_testbed("multisync_easy_new");
 902         char *formatdir = g_strdup_printf("%s/formats", testbed);
 903         char *plugindir = g_strdup_printf("%s/plugins", testbed);
 904
 905         g_setenv("CONNECT_ERROR", "5", TRUE);
 906
 907         OSyncError *error = NULL;
 908         OSyncGroup *group = osync_group_new(&error);
 909         osync_group_set_schemadir(group, testbed);
 910         osync_group_load(group, "configs/group", &error);
 911         fail_unless(error == NULL, NULL);
 912
 913         OSyncEngine *engine = osync_engine_new(group, &error);
 914         fail_unless(engine != NULL, NULL);
 915         fail_unless(error == NULL, NULL);
 916
 917         osync_engine_set_schemadir(engine, testbed);
 918         osync_engine_set_plugindir(engine, plugindir);
 919         osync_engine_set_formatdir(engine, formatdir);
 920
 921         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
 922         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
 923         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
 924         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 925
 926         fail_unless(osync_engine_initialize(engine, &error), NULL);
 927         fail_unless(error == NULL, NULL);
 928
 929         fail_unless(!synchronize_once(engine, &error), NULL);
 930         fail_unless(error != NULL, NULL);
 931         fail_unless(osync_error_is_set(&error), NULL);
 932
 933
 934         fail_unless(num_client_errors == 2, NULL);
 935         fail_unless(num_client_connected == 1, NULL);
 936         fail_unless(num_client_disconnected == 1, NULL);
 937         fail_unless(num_client_written == 0, NULL);
 938         fail_unless(num_engine_errors == 1, NULL);
 939
 940         osync_error_unref(&error);
 941         osync_engine_finalize(engine, &error);
 942         osync_engine_unref(engine);
 943
 944         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 945
 946         g_free(formatdir);
 947         g_free(plugindir);
 948
 949         destroy_testbed(testbed);
 950 }
 951 END_TEST
 952
 953 START_TEST (two_of_three_connect_error2)
 954 {
 955         char *testbed = setup_testbed("multisync_easy_new");
 956         char *formatdir = g_strdup_printf("%s/formats", testbed);
 957         char *plugindir = g_strdup_printf("%s/plugins", testbed);
 958
 959         g_setenv("CONNECT_ERROR", "6", TRUE);
 960
 961         OSyncError *error = NULL;
 962         OSyncGroup *group = osync_group_new(&error);
 963         osync_group_set_schemadir(group, testbed);
 964         osync_group_load(group, "configs/group", &error);
 965         fail_unless(error == NULL, NULL);
 966
 967         OSyncEngine *engine = osync_engine_new(group, &error);
 968         fail_unless(engine != NULL, NULL);
 969         fail_unless(error == NULL, NULL);
 970
 971         osync_engine_set_schemadir(engine, testbed);
 972         osync_engine_set_plugindir(engine, plugindir);
 973         osync_engine_set_formatdir(engine, formatdir);
 974
 975         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
 976         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
 977         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
 978         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 979
 980         fail_unless(osync_engine_initialize(engine, &error), NULL);
 981         fail_unless(error == NULL, NULL);
 982
 983         fail_unless(!synchronize_once(engine, &error), NULL);
 984         fail_unless(error != NULL, NULL);
 985         fail_unless(osync_error_is_set(&error), NULL);
 986
 987         fail_unless(num_client_errors == 2, NULL);
 988         fail_unless(num_client_connected == 1, NULL);
 989         fail_unless(num_client_disconnected == 1, NULL);
 990         fail_unless(num_client_written == 0, NULL);
 991         fail_unless(num_engine_errors == 1, NULL);
 992
 993         osync_error_unref(&error);
 994         osync_engine_finalize(engine, &error);
 995         osync_engine_unref(engine);
 996
 997         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 998
 999         g_free(formatdir);
1000         g_free(plugindir);
1001
1002         destroy_testbed(testbed);
1003 }
1004 END_TEST
1005
1006 START_TEST (three_of_three_connect_error)
1007 {
1008         char *testbed = setup_testbed("multisync_easy_new");
1009         char *formatdir = g_strdup_printf("%s/formats", testbed);
1010         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1011
1012         g_setenv("CONNECT_ERROR", "7", TRUE);
1013
1014
1015         OSyncError *error = NULL;
1016         OSyncGroup *group = osync_group_new(&error);
1017         osync_group_set_schemadir(group, testbed);
1018         osync_group_load(group, "configs/group", &error);
1019         fail_unless(error == NULL, NULL);
1020
1021         OSyncEngine *engine = osync_engine_new(group, &error);
1022         fail_unless(engine != NULL, NULL);
1023         fail_unless(error == NULL, NULL);
1024
1025         osync_engine_set_schemadir(engine, testbed);
1026         osync_engine_set_plugindir(engine, plugindir);
1027         osync_engine_set_formatdir(engine, formatdir);
1028
1029         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1030         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1031         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1032         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1033
1034         fail_unless(osync_engine_initialize(engine, &error), NULL);
1035         fail_unless(error == NULL, NULL);
1036
1037         fail_unless(!synchronize_once(engine, &error), NULL);
1038         fail_unless(error != NULL, NULL);
1039         fail_unless(osync_error_is_set(&error), NULL);
1040
1041         fail_unless(num_client_errors == 3, NULL);
1042         fail_unless(num_client_connected == 0, NULL);
1043         fail_unless(num_client_disconnected == 0, NULL);
1044         fail_unless(num_client_written == 0, NULL);
1045         fail_unless(num_engine_errors == 1, NULL);
1046
1047         osync_engine_finalize(engine, &error);
1048         osync_engine_unref(engine);
1049
1050         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1051
1052         g_free(formatdir);
1053         g_free(plugindir);
1054
1055         destroy_testbed(testbed);
1056 }
1057 END_TEST
1058
1059 START_TEST (one_of_three_connect_error)
1060 {
1061         char *testbed = setup_testbed("multisync_easy_new");
1062         char *formatdir = g_strdup_printf("%s/formats", testbed);
1063         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1064
1065         g_setenv("CONNECT_ERROR", "2", TRUE);
1066
1067         OSyncError *error = NULL;
1068         OSyncGroup *group = osync_group_new(&error);
1069         osync_group_set_schemadir(group, testbed);
1070         osync_group_load(group, "configs/group", &error);
1071         fail_unless(error == NULL, NULL);
1072
1073         OSyncEngine *engine = osync_engine_new(group, &error);
1074         fail_unless(engine != NULL, NULL);
1075         fail_unless(error == NULL, NULL);
1076
1077         osync_engine_set_schemadir(engine, testbed);
1078         osync_engine_set_plugindir(engine, plugindir);
1079         osync_engine_set_formatdir(engine, formatdir);
1080
1081         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1082         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1083         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1084         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1085
1086         fail_unless(osync_engine_initialize(engine, &error), NULL);
1087         fail_unless(error == NULL, NULL);
1088
1089         fail_unless(!synchronize_once(engine, &error), NULL);
1090         fail_unless(error != NULL, NULL);
1091         fail_unless(osync_error_is_set(&error), NULL);
1092
1093         osync_error_unref(&error);
1094         osync_engine_finalize(engine, &error);
1095         osync_engine_unref(engine);
1096
1097         fail_unless(num_client_errors == 1, NULL);
1098         fail_unless(num_client_connected == 2, NULL);
1099         fail_unless(num_client_written == 0, NULL);
1100         fail_unless(num_engine_errors == 1, NULL);
1101         fail_unless(num_client_disconnected == 2, NULL);
1102
1103         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1104
1105         g_free(formatdir);
1106         g_free(plugindir);
1107
1108         destroy_testbed(testbed);
1109 }
1110 END_TEST
1111
1112 START_TEST (no_connect_error)
1113 {
1114         char *testbed = setup_testbed("multisync_easy_new");
1115         char *formatdir = g_strdup_printf("%s/formats", testbed);
1116         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1117
1118         g_setenv("CONNECT_ERROR", "0", TRUE);
1119
1120         OSyncError *error = NULL;
1121         OSyncGroup *group = osync_group_new(&error);
1122         osync_group_set_schemadir(group, testbed);
1123         osync_group_load(group, "configs/group", &error);
1124         fail_unless(error == NULL, NULL);
1125
1126         OSyncEngine *engine = osync_engine_new(group, &error);
1127         fail_unless(engine != NULL, NULL);
1128         fail_unless(error == NULL, NULL);
1129
1130         osync_engine_set_schemadir(engine, testbed);
1131         osync_engine_set_plugindir(engine, plugindir);
1132         osync_engine_set_formatdir(engine, formatdir);
1133
1134         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1135         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1136         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1137         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1138
1139         fail_unless(osync_engine_initialize(engine, &error), NULL);
1140         fail_unless(error == NULL, NULL);
1141
1142         fail_unless(synchronize_once(engine, &error), NULL);
1143         fail_unless(error == NULL, NULL);
1144         fail_unless(!osync_error_is_set(&error), NULL);
1145
1146         osync_error_unref(&error);
1147         osync_engine_finalize(engine, &error);
1148         osync_engine_unref(engine);
1149
1150         fail_unless(num_client_errors == 0, NULL);
1151         fail_unless(num_client_connected == 3, NULL);
1152         fail_unless(num_client_disconnected == 3, NULL);
1153         fail_unless(num_client_written == 3, NULL);
1154         fail_unless(num_engine_errors == 0, NULL);
1155         fail_unless(num_engine_successful == 1, NULL);
1156
1157         fail_unless(osync_testing_diff("data1", "data2"));
1158         fail_unless(osync_testing_diff("data1", "data3"));
1159
1160         g_free(formatdir);
1161         g_free(plugindir);
1162
1163         destroy_testbed(testbed);
1164 }
1165 END_TEST
1166
1167 START_TEST (single_connect_timeout)
1168 {
1169         char *testbed = setup_testbed("sync");
1170         char *formatdir = g_strdup_printf("%s/formats", testbed);
1171         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1172
1173         if (system("cp testdata data1/testdata"))
1174                 abort();
1175
1176         g_setenv("CONNECT_TIMEOUT", "2", TRUE);
1177
1178         OSyncError *error = NULL;
1179         OSyncGroup *group = osync_group_new(&error);
1180         osync_group_set_schemadir(group, testbed);
1181         osync_group_load(group, "configs/group", &error);
1182         fail_unless(error == NULL, NULL);
1183
1184         OSyncEngine *engine = osync_engine_new(group, &error);
1185         fail_unless(engine != NULL, NULL);
1186         fail_unless(error == NULL, NULL);
1187
1188         osync_engine_set_schemadir(engine, testbed);
1189         osync_engine_set_plugindir(engine, plugindir);
1190         osync_engine_set_formatdir(engine, formatdir);
1191
1192         discover_all_once(engine, &error);
1193
1194         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1195         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1196         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1197         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1198
1199         fail_unless(osync_engine_initialize(engine, &error), NULL);
1200         fail_unless(error == NULL, NULL);
1201
1202         fail_unless(!synchronize_once(engine, &error), NULL);
1203         fail_unless(error != NULL, NULL);
1204         fail_unless(osync_error_is_set(&error), NULL);
1205
1206         osync_error_unref(&error);
1207         osync_engine_finalize(engine, &error);
1208         osync_engine_unref(engine);
1209
1210         fail_unless(num_client_errors == 1, NULL);
1211         fail_unless(num_client_connected == 1, NULL);
1212         fail_unless(num_client_disconnected == 1, NULL);
1213         fail_unless(num_client_written == 0, NULL);
1214         fail_unless(num_engine_errors == 1, NULL);
1215         fail_unless(num_engine_successful == 0, NULL);
1216
1217         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1218
1219         g_free(formatdir);
1220         g_free(plugindir);
1221
1222         destroy_testbed(testbed);
1223 }
1224 END_TEST
1225
1226 START_TEST (dual_connect_timeout)
1227 {
1228         char *testbed = setup_testbed("sync");
1229         char *formatdir = g_strdup_printf("%s/formats", testbed);
1230         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1231
1232         if (system("cp testdata data1/testdata"))
1233                 abort();
1234
1235         g_setenv("CONNECT_TIMEOUT", "3", TRUE);
1236
1237         OSyncError *error = NULL;
1238         OSyncGroup *group = osync_group_new(&error);
1239         osync_group_set_schemadir(group, testbed);
1240         osync_group_load(group, "configs/group", &error);
1241         fail_unless(error == NULL, NULL);
1242
1243         OSyncEngine *engine = osync_engine_new(group, &error);
1244         fail_unless(engine != NULL, NULL);
1245         fail_unless(error == NULL, NULL);
1246
1247         osync_engine_set_schemadir(engine, testbed);
1248         osync_engine_set_plugindir(engine, plugindir);
1249         osync_engine_set_formatdir(engine, formatdir);
1250
1251         discover_all_once(engine, &error);
1252
1253         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1254         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1255         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1256         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1257
1258         fail_unless(osync_engine_initialize(engine, &error), NULL);
1259         fail_unless(error == NULL, NULL);
1260
1261         fail_unless(!synchronize_once(engine, &error), NULL);
1262         fail_unless(error != NULL, NULL);
1263         fail_unless(osync_error_is_set(&error), NULL);
1264
1265         osync_error_unref(&error);
1266         osync_engine_finalize(engine, &error);
1267         osync_engine_unref(engine);
1268
1269         fail_unless(num_client_errors == 2, NULL);
1270         fail_unless(num_client_connected == 0, NULL);
1271         fail_unless(num_client_disconnected == 0, NULL);
1272         fail_unless(num_client_written == 0, NULL);
1273         fail_unless(num_engine_errors == 1, NULL);
1274         fail_unless(num_engine_successful == 0, NULL);
1275
1276         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1277
1278         g_free(formatdir);
1279         g_free(plugindir);
1280
1281         destroy_testbed(testbed);
1282 }
1283 END_TEST
1284
1285 START_TEST (one_of_three_timeout)
1286 {
1287         char *testbed = setup_testbed("multisync_easy_new");
1288         char *formatdir = g_strdup_printf("%s/formats", testbed);
1289         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1290
1291         g_setenv("CONNECT_TIMEOUT", "2", TRUE);
1292
1293         OSyncError *error = NULL;
1294         OSyncGroup *group = osync_group_new(&error);
1295         osync_group_set_schemadir(group, testbed);
1296         osync_group_load(group, "configs/group", &error);
1297         fail_unless(error == NULL, NULL);
1298
1299         OSyncEngine *engine = osync_engine_new(group, &error);
1300         fail_unless(engine != NULL, NULL);
1301         fail_unless(error == NULL, NULL);
1302
1303         osync_engine_set_schemadir(engine, testbed);
1304         osync_engine_set_plugindir(engine, plugindir);
1305         osync_engine_set_formatdir(engine, formatdir);
1306
1307         discover_all_once(engine, &error);
1308
1309         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1310         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1311         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1312         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1313
1314         fail_unless(osync_engine_initialize(engine, &error), NULL);
1315         fail_unless(error == NULL, NULL);
1316
1317         fail_unless(!synchronize_once(engine, &error), NULL);
1318         fail_unless(error != NULL, NULL);
1319         fail_unless(osync_error_is_set(&error), NULL);
1320
1321         osync_error_unref(&error);
1322         osync_engine_finalize(engine, &error);
1323         osync_engine_unref(engine);
1324
1325         fail_unless(num_client_errors == 1, NULL);
1326         fail_unless(num_client_connected == 2, NULL);
1327         fail_unless(num_client_disconnected == 2, NULL);
1328         fail_unless(num_client_written == 0, NULL);
1329         fail_unless(num_engine_errors == 1, NULL);
1330         fail_unless(num_engine_successful == 0, NULL);
1331
1332         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1333
1334         g_free(formatdir);
1335         g_free(plugindir);
1336
1337         destroy_testbed(testbed);
1338 }
1339 END_TEST
1340
1341 START_TEST (timeout_and_error)
1342 {
1343         char *testbed = setup_testbed("multisync_easy_new");
1344         char *formatdir = g_strdup_printf("%s/formats", testbed);
1345         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1346
1347         g_setenv("CONNECT_TIMEOUT", "2", TRUE);
1348         g_setenv("CONNECT_ERROR", "4", TRUE);
1349
1350         OSyncError *error = NULL;
1351         OSyncGroup *group = osync_group_new(&error);
1352         osync_group_set_schemadir(group, testbed);
1353         osync_group_load(group, "configs/group", &error);
1354         fail_unless(error == NULL, NULL);
1355
1356         OSyncEngine *engine = osync_engine_new(group, &error);
1357         fail_unless(engine != NULL, NULL);
1358         fail_unless(error == NULL, NULL);
1359
1360         osync_engine_set_schemadir(engine, testbed);
1361         osync_engine_set_plugindir(engine, plugindir);
1362         osync_engine_set_formatdir(engine, formatdir);
1363
1364         discover_all_once(engine, &error);
1365
1366         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1367         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1368         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1369         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1370
1371         fail_unless(osync_engine_initialize(engine, &error), NULL);
1372         fail_unless(error == NULL, NULL);
1373
1374         fail_unless(!synchronize_once(engine, &error), NULL);
1375         fail_unless(error != NULL, NULL);
1376         fail_unless(osync_error_is_set(&error), NULL);
1377
1378         osync_error_unref(&error);
1379         osync_engine_finalize(engine, &error);
1380         osync_engine_unref(engine);
1381
1382         fail_unless(num_client_errors == 2, NULL);
1383         fail_unless(num_client_connected == 1, NULL);
1384         fail_unless(num_client_disconnected == 1, NULL);
1385         fail_unless(num_client_written == 0, NULL);
1386         fail_unless(num_engine_errors == 1, NULL);
1387         fail_unless(num_engine_successful == 0, NULL);
1388
1389         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1390
1391         g_free(formatdir);
1392         g_free(plugindir);
1393
1394         destroy_testbed(testbed);
1395 }
1396 END_TEST
1397
1398 START_TEST (single_get_changes_error)
1399 {
1400         char *testbed = setup_testbed("sync_easy_conflict");
1401         char *formatdir = g_strdup_printf("%s/formats", testbed);
1402         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1403
1404         g_setenv("GET_CHANGES_ERROR", "2", TRUE);
1405         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
1406
1407         OSyncError *error = NULL;
1408         OSyncGroup *group = osync_group_new(&error);
1409         osync_group_set_schemadir(group, testbed);
1410         osync_group_load(group, "configs/group", &error);
1411         fail_unless(error == NULL, NULL);
1412
1413         OSyncEngine *engine = osync_engine_new(group, &error);
1414         fail_unless(engine != NULL, NULL);
1415         fail_unless(error == NULL, NULL);
1416
1417         osync_engine_set_schemadir(engine, testbed);
1418         osync_engine_set_plugindir(engine, plugindir);
1419         osync_engine_set_formatdir(engine, formatdir);
1420
1421         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1422         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1423         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1424         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1425
1426         fail_unless(osync_engine_initialize(engine, &error), NULL);
1427         fail_unless(error == NULL, NULL);
1428
1429         fail_unless(!synchronize_once(engine, &error), NULL);
1430         fail_unless(error != NULL, NULL);
1431         fail_unless(osync_error_is_set(&error), NULL);
1432
1433         osync_error_unref(&error);
1434         osync_engine_finalize(engine, &error);
1435         osync_engine_unref(engine);
1436
1437         fail_unless(num_client_connected == 2, NULL);
1438         fail_unless(num_client_disconnected == 2, NULL);
1439         fail_unless(num_client_errors == 1, NULL);
1440         fail_unless(num_change_written == 0, NULL);
1441         fail_unless(num_mapping_conflicts == 0, NULL);
1442
1443         fail_unless(num_engine_errors == 1, NULL);
1444
1445         fail_unless(num_engine_successful == 0, NULL);
1446
1447         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1448
1449         g_free(formatdir);
1450         g_free(plugindir);
1451
1452         destroy_testbed(testbed);
1453 }
1454 END_TEST
1455
1456 START_TEST (dual_get_changes_error)
1457 {
1458         char *testbed = setup_testbed("sync_easy_conflict");
1459         char *formatdir = g_strdup_printf("%s/formats", testbed);
1460         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1461
1462         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
1463         g_setenv("GET_CHANGES_ERROR", "3", TRUE);
1464
1465         OSyncError *error = NULL;
1466         OSyncGroup *group = osync_group_new(&error);
1467         osync_group_set_schemadir(group, testbed);
1468         osync_group_load(group, "configs/group", &error);
1469         fail_unless(error == NULL, NULL);
1470
1471         OSyncEngine *engine = osync_engine_new(group, &error);
1472         fail_unless(engine != NULL, NULL);
1473         fail_unless(error == NULL, NULL);
1474
1475         osync_engine_set_schemadir(engine, testbed);
1476         osync_engine_set_plugindir(engine, plugindir);
1477         osync_engine_set_formatdir(engine, formatdir);
1478
1479         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1480         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1481         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1482         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1483
1484         fail_unless(osync_engine_initialize(engine, &error), NULL);
1485         fail_unless(error == NULL, NULL);
1486
1487         fail_unless(!synchronize_once(engine, &error), NULL);
1488         fail_unless(error != NULL, NULL);
1489         fail_unless(osync_error_is_set(&error), NULL);
1490
1491         osync_error_unref(&error);
1492         osync_engine_finalize(engine, &error);
1493         osync_engine_unref(engine);
1494
1495         fail_unless(num_client_errors == 2, NULL);
1496         fail_unless(num_client_connected == 2, NULL);
1497         fail_unless(num_client_disconnected == 2, NULL);
1498         fail_unless(num_client_written == 0, NULL);
1499         fail_unless(num_change_read == 0, NULL);
1500         fail_unless(num_change_written == 0, NULL);
1501         fail_unless(num_mapping_conflicts == 0, NULL);
1502
1503         fail_unless(num_engine_errors == 1, NULL);
1504
1505         fail_unless(num_engine_successful == 0, NULL);
1506
1507         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1508
1509         g_free(formatdir);
1510         g_free(plugindir);
1511
1512         destroy_testbed(testbed);
1513 }
1514 END_TEST
1515
1516 START_TEST (two_of_three_get_changes_error)
1517 {
1518         char *testbed = setup_testbed("multisync_conflict_data_choose2");
1519         char *formatdir = g_strdup_printf("%s/formats", testbed);
1520         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1521
1522         g_setenv("GET_CHANGES_ERROR", "5", TRUE);
1523         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
1524
1525         OSyncError *error = NULL;
1526         OSyncGroup *group = osync_group_new(&error);
1527         osync_group_set_schemadir(group, testbed);
1528         osync_group_load(group, "configs/group", &error);
1529         fail_unless(error == NULL, NULL);
1530
1531         OSyncEngine *engine = osync_engine_new(group, &error);
1532         fail_unless(engine != NULL, NULL);
1533         fail_unless(error == NULL, NULL);
1534
1535         osync_engine_set_schemadir(engine, testbed);
1536         osync_engine_set_plugindir(engine, plugindir);
1537         osync_engine_set_formatdir(engine, formatdir);
1538
1539         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1540         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1541         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1542         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1543
1544         fail_unless(osync_engine_initialize(engine, &error), NULL);
1545         fail_unless(error == NULL, NULL);
1546
1547         fail_unless(!synchronize_once(engine, &error), NULL);
1548         fail_unless(error != NULL, NULL);
1549         fail_unless(osync_error_is_set(&error), NULL);
1550
1551         osync_error_unref(&error);
1552         osync_engine_finalize(engine, &error);
1553         osync_engine_unref(engine);
1554
1555         fail_unless(num_client_errors == 2, NULL);
1556         fail_unless(num_client_connected == 3, NULL);
1557         fail_unless(num_client_disconnected == 3, NULL);
1558         fail_unless(num_change_written == 0, NULL);
1559         fail_unless(num_mapping_conflicts == 0, NULL);
1560
1561         fail_unless(num_engine_errors == 1, NULL);
1562
1563         fail_unless(num_engine_successful == 0, NULL);
1564
1565         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1566
1567         g_free(formatdir);
1568         g_free(plugindir);
1569
1570         destroy_testbed(testbed);
1571 }
1572 END_TEST
1573
1574 START_TEST (one_of_three_get_changes_error)
1575 {
1576         char *testbed = setup_testbed("multisync_conflict_data_choose2");
1577         char *formatdir = g_strdup_printf("%s/formats", testbed);
1578         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1579
1580         g_setenv("GET_CHANGES_ERROR", "1", TRUE);
1581         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
1582
1583         OSyncError *error = NULL;
1584         OSyncGroup *group = osync_group_new(&error);
1585         osync_group_set_schemadir(group, testbed);
1586         osync_group_load(group, "configs/group", &error);
1587         fail_unless(error == NULL, NULL);
1588
1589         OSyncEngine *engine = osync_engine_new(group, &error);
1590         fail_unless(engine != NULL, NULL);
1591         fail_unless(error == NULL, NULL);
1592
1593         osync_engine_set_schemadir(engine, testbed);
1594         osync_engine_set_plugindir(engine, plugindir);
1595         osync_engine_set_formatdir(engine, formatdir);
1596
1597         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1598         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1599         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1600         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1601
1602         fail_unless(osync_engine_initialize(engine, &error), NULL);
1603         fail_unless(error == NULL, NULL);
1604
1605         fail_unless(!synchronize_once(engine, &error), NULL);
1606         fail_unless(error != NULL, NULL);
1607         fail_unless(osync_error_is_set(&error), NULL);
1608
1609         osync_error_unref(&error);
1610         osync_engine_finalize(engine, &error);
1611         osync_engine_unref(engine);
1612
1613         fail_unless(num_client_connected == 3, NULL);
1614         fail_unless(num_client_disconnected == 3, NULL);
1615         fail_unless(num_client_errors == 1, NULL);
1616         fail_unless(num_change_written == 0, NULL);
1617         fail_unless(num_mapping_conflicts == 0, NULL);
1618
1619         fail_unless(num_engine_errors == 1, NULL);
1620
1621         fail_unless(num_engine_successful == 0, NULL);
1622
1623         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1624
1625         g_free(formatdir);
1626         g_free(plugindir);
1627
1628         destroy_testbed(testbed);
1629 }
1630 END_TEST
1631
1632 START_TEST (one_of_three_get_changes_timeout)
1633 {
1634         char *testbed = setup_testbed("multisync_conflict_data_choose2");
1635         char *formatdir = g_strdup_printf("%s/formats", testbed);
1636         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1637
1638         g_setenv("GET_CHANGES_TIMEOUT", "1", TRUE);
1639         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
1640
1641         OSyncError *error = NULL;
1642         OSyncGroup *group = osync_group_new(&error);
1643         osync_group_set_schemadir(group, testbed);
1644         osync_group_load(group, "configs/group", &error);
1645         fail_unless(error == NULL, NULL);
1646
1647         OSyncEngine *engine = osync_engine_new(group, &error);
1648         fail_unless(engine != NULL, NULL);
1649         fail_unless(error == NULL, NULL);
1650
1651         osync_engine_set_schemadir(engine, testbed);
1652         osync_engine_set_plugindir(engine, plugindir);
1653         osync_engine_set_formatdir(engine, formatdir);
1654
1655         discover_all_once(engine, &error);
1656
1657         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1658         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1659         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1660         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1661
1662         fail_unless(osync_engine_initialize(engine, &error), NULL);
1663         fail_unless(error == NULL, NULL);
1664
1665         fail_unless(!synchronize_once(engine, &error), NULL);
1666         fail_unless(error != NULL, NULL);
1667         fail_unless(osync_error_is_set(&error), NULL);
1668
1669         osync_error_unref(&error);
1670         osync_engine_finalize(engine, &error);
1671         osync_engine_unref(engine);
1672
1673         fail_unless(num_client_connected == 3, NULL);
1674         fail_unless(num_client_disconnected == 3, NULL);
1675         fail_unless(num_client_errors == 1, NULL);
1676         fail_unless(num_client_read == 2, NULL);
1677         fail_unless(num_client_written == 0, NULL);
1678         fail_unless(num_change_read == 2, NULL);
1679         fail_unless(num_change_written == 0, NULL);
1680         fail_unless(num_mapping_conflicts == 0, NULL);
1681         fail_unless(num_engine_errors == 1, NULL);
1682         fail_unless(num_engine_successful == 0, NULL);
1683
1684         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1685
1686         g_free(formatdir);
1687         g_free(plugindir);
1688
1689         destroy_testbed(testbed);
1690 }
1691 END_TEST
1692
1693 START_TEST (get_changes_timeout_and_error)
1694 {
1695         char *testbed = setup_testbed("multisync_conflict_data_choose2");
1696         char *formatdir = g_strdup_printf("%s/formats", testbed);
1697         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1698
1699         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
1700         g_setenv("GET_CHANGES_TIMEOUT", "3", TRUE);
1701         g_setenv("GET_CHANGES_ERROR", "4", TRUE);
1702
1703         OSyncError *error = NULL;
1704         OSyncGroup *group = osync_group_new(&error);
1705         osync_group_set_schemadir(group, testbed);
1706         osync_group_load(group, "configs/group", &error);
1707         fail_unless(error == NULL, NULL);
1708
1709         OSyncEngine *engine = osync_engine_new(group, &error);
1710         fail_unless(engine != NULL, NULL);
1711         fail_unless(error == NULL, NULL);
1712
1713         osync_engine_set_schemadir(engine, testbed);
1714         osync_engine_set_plugindir(engine, plugindir);
1715         osync_engine_set_formatdir(engine, formatdir);
1716
1717         discover_all_once(engine, &error);
1718
1719         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1720         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1721         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1722         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1723
1724         fail_unless(osync_engine_initialize(engine, &error), NULL);
1725         fail_unless(error == NULL, NULL);
1726
1727         fail_unless(!synchronize_once(engine, &error), NULL);
1728         fail_unless(error != NULL, NULL);
1729         fail_unless(osync_error_is_set(&error), NULL);
1730
1731         osync_error_unref(&error);
1732         osync_engine_finalize(engine, &error);
1733         osync_engine_unref(engine);
1734
1735         fail_unless(num_client_errors == 3, NULL);
1736         fail_unless(num_client_connected == 3, NULL);
1737         fail_unless(num_client_disconnected == 3, NULL);
1738         fail_unless(num_client_read == 0, NULL);
1739         fail_unless(num_client_written == 0, NULL);
1740         fail_unless(num_change_read == 0, NULL);
1741         fail_unless(num_change_written == 0, NULL);
1742         fail_unless(num_mapping_conflicts == 0, NULL);
1743         fail_unless(num_engine_errors == 1, NULL);
1744         fail_unless(num_engine_successful == 0, NULL);
1745
1746         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1747
1748         g_free(formatdir);
1749         g_free(plugindir);
1750
1751         destroy_testbed(testbed);
1752 }
1753 END_TEST
1754
1755 /* FIXME */
1756 #if 0
1757 START_TEST (get_changes_timeout_sleep)
1758 {
1759         char *testbed = setup_testbed("multisync_conflict_data_choose2");
1760         char *formatdir = g_strdup_printf("%s/formats", testbed);
1761         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1762
1763         g_setenv("GET_CHANGES_TIMEOUT2", "7", TRUE);
1764         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
1765
1766         OSyncError *error = NULL;
1767         OSyncGroup *group = osync_group_new(&error);
1768         osync_group_set_schemadir(group, testbed);
1769         osync_group_load(group, "configs/group", &error);
1770         fail_unless(error == NULL, NULL);
1771
1772         OSyncEngine *engine = osync_engine_new(group, &error);
1773         fail_unless(engine != NULL, NULL);
1774         fail_unless(error == NULL, NULL);
1775
1776         osync_engine_set_schemadir(engine, testbed);
1777         osync_engine_set_plugindir(engine, plugindir);
1778         osync_engine_set_formatdir(engine, formatdir);
1779
1780         discover_all_once(engine, &error);
1781
1782         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1783         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1784         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1785         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1786
1787         fail_unless(osync_engine_initialize(engine, &error), NULL);
1788         fail_unless(error == NULL, NULL);
1789
1790         fail_unless(!synchronize_once(engine, &error), NULL);
1791         fail_unless(error != NULL, NULL);
1792         fail_unless(osync_error_is_set(&error), NULL);
1793
1794         osync_error_unref(&error);
1795         osync_engine_finalize(engine, &error);
1796         osync_engine_unref(engine);
1797
1798         fail_unless(num_client_errors == 3, NULL);
1799         fail_unless(num_client_connected == 3, NULL);
1800         fail_unless(num_client_disconnected == 3, NULL);
1801         fail_unless(num_client_read == 0, NULL);
1802         fail_unless(num_client_written == 0, NULL);
1803
1804         // FIXME: If get_changes delays and get timed out .. set change_callback to NULL. To make sure changes got completely ignored by the engine
1805         fail_unless(num_change_read == 0, NULL);
1806
1807         fail_unless(num_change_written == 0, NULL);
1808         fail_unless(num_mapping_conflicts == 0, NULL);
1809         fail_unless(num_engine_errors == 1, NULL);
1810         fail_unless(num_engine_successful == 0, NULL);
1811
1812         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1813
1814         g_free(formatdir);
1815         g_free(plugindir);
1816
1817         destroy_testbed(testbed);
1818 }
1819 END_TEST
1820 #endif /* FIXME */
1821
1822 START_TEST (single_commit_error)
1823 {
1824         char *testbed = setup_testbed("multisync_easy_new");
1825         char *formatdir = g_strdup_printf("%s/formats", testbed);
1826         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1827
1828         g_setenv("COMMIT_ERROR", "4", TRUE);
1829
1830         OSyncError *error = NULL;
1831         OSyncGroup *group = osync_group_new(&error);
1832         osync_group_set_schemadir(group, testbed);
1833         osync_group_load(group, "configs/group", &error);
1834         fail_unless(error == NULL, NULL);
1835
1836         OSyncEngine *engine = osync_engine_new(group, &error);
1837         fail_unless(engine != NULL, NULL);
1838         fail_unless(error == NULL, NULL);
1839
1840         osync_engine_set_schemadir(engine, testbed);
1841         osync_engine_set_plugindir(engine, plugindir);
1842         osync_engine_set_formatdir(engine, formatdir);
1843
1844         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1845         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1846         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1847         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
1848         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1849
1850         fail_unless(osync_engine_initialize(engine, &error), NULL);
1851         fail_unless(error == NULL, NULL);
1852
1853         fail_unless(!synchronize_once(engine, &error), NULL);
1854         fail_unless(error != NULL, NULL);
1855         fail_unless(osync_error_is_set(&error), NULL);
1856
1857         osync_error_unref(&error);
1858         osync_engine_finalize(engine, &error);
1859         osync_engine_unref(engine);
1860
1861         fail_unless(num_client_errors == 0, NULL);
1862         fail_unless(num_client_connected == 3, NULL);
1863         fail_unless(num_client_disconnected == 3, NULL);
1864         fail_unless(num_client_written == 3, NULL);
1865         fail_unless(num_change_read == 1, NULL);
1866         fail_unless(num_change_written == 1, NULL);
1867
1868         // TODO: Review, whats the diffent of mapping status emits and change status emits?! (dgollub)
1869         fail_unless(num_change_error == 1, NULL);
1870         // TODO: Review, whats the diffent of mapping status emits and change status emits?! (dgollub)
1871         fail_unless(num_mapping_errors == 1, NULL);
1872
1873         fail_unless(num_mapping_conflicts == 0, NULL);
1874         fail_unless(num_engine_errors == 1, NULL);
1875         fail_unless(num_engine_successful == 0, NULL);
1876
1877         fail_unless(osync_testing_diff("data1", "data2"));
1878         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
1879
1880         g_free(formatdir);
1881         g_free(plugindir);
1882
1883         destroy_testbed(testbed);
1884 }
1885 END_TEST
1886
1887 START_TEST (dual_commit_error)
1888 {
1889         char *testbed = setup_testbed("multisync_easy_new");
1890         char *formatdir = g_strdup_printf("%s/formats", testbed);
1891         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1892
1893         g_setenv("COMMIT_ERROR", "6", TRUE);
1894
1895         OSyncError *error = NULL;
1896         OSyncGroup *group = osync_group_new(&error);
1897         osync_group_set_schemadir(group, testbed);
1898         osync_group_load(group, "configs/group", &error);
1899         fail_unless(error == NULL, NULL);
1900
1901         OSyncEngine *engine = osync_engine_new(group, &error);
1902         fail_unless(engine != NULL, NULL);
1903         fail_unless(error == NULL, NULL);
1904
1905         osync_engine_set_schemadir(engine, testbed);
1906         osync_engine_set_plugindir(engine, plugindir);
1907         osync_engine_set_formatdir(engine, formatdir);
1908
1909         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1910         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1911         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1912         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
1913         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1914
1915         fail_unless(osync_engine_initialize(engine, &error), NULL);
1916         fail_unless(error == NULL, NULL);
1917
1918         fail_unless(!synchronize_once(engine, &error), NULL);
1919         fail_unless(error != NULL, NULL);
1920         fail_unless(osync_error_is_set(&error), NULL);
1921
1922         osync_error_unref(&error);
1923         osync_engine_finalize(engine, &error);
1924         osync_engine_unref(engine);
1925
1926         fail_unless(num_client_errors == 0, NULL);
1927         fail_unless(num_client_connected == 3, NULL);
1928         fail_unless(num_client_disconnected == 3, NULL);
1929         fail_unless(num_client_written == 3, NULL);
1930         fail_unless(num_change_read == 1, NULL);
1931         fail_unless(num_change_written == 0, NULL);
1932         fail_unless(num_change_error == 2, NULL);
1933         fail_unless(num_mapping_errors == 2, NULL);
1934         fail_unless(num_mapping_conflicts == 0, NULL);
1935         fail_unless(num_engine_errors == 1, NULL);
1936         fail_unless(num_engine_successful == 0, NULL);
1937
1938         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1939         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
1940
1941         g_free(formatdir);
1942         g_free(plugindir);
1943
1944         destroy_testbed(testbed);
1945 }
1946 END_TEST
1947
1948 START_TEST (single_commit_timeout)
1949 {
1950         char *testbed = setup_testbed("multisync_easy_new");
1951         char *formatdir = g_strdup_printf("%s/formats", testbed);
1952         char *plugindir = g_strdup_printf("%s/plugins", testbed);
1953
1954         g_setenv("COMMIT_TIMEOUT", "4", TRUE);
1955
1956         OSyncError *error = NULL;
1957         OSyncGroup *group = osync_group_new(&error);
1958         osync_group_set_schemadir(group, testbed);
1959         osync_group_load(group, "configs/group", &error);
1960         fail_unless(error == NULL, NULL);
1961
1962         OSyncEngine *engine = osync_engine_new(group, &error);
1963         fail_unless(engine != NULL, NULL);
1964         fail_unless(error == NULL, NULL);
1965
1966         osync_engine_set_schemadir(engine, testbed);
1967         osync_engine_set_plugindir(engine, plugindir);
1968         osync_engine_set_formatdir(engine, formatdir);
1969
1970         discover_all_once(engine, &error);
1971
1972         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
1973         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
1974         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
1975         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
1976         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1977
1978         fail_unless(osync_engine_initialize(engine, &error), NULL);
1979         fail_unless(error == NULL, NULL);
1980
1981         fail_unless(!synchronize_once(engine, &error), NULL);
1982         fail_unless(error != NULL, NULL);
1983         fail_unless(osync_error_is_set(&error), NULL);
1984
1985         osync_error_unref(&error);
1986         osync_engine_finalize(engine, &error);
1987         osync_engine_unref(engine);
1988
1989         fail_unless(num_client_errors == 0, NULL);
1990         fail_unless(num_client_connected == 3, NULL);
1991         fail_unless(num_client_disconnected == 3, NULL);
1992         fail_unless(num_client_written == 3, NULL);
1993         fail_unless(num_change_read == 1, NULL);
1994         fail_unless(num_change_written == 1, NULL);
1995         fail_unless(num_change_error == 1, NULL);
1996         fail_unless(num_mapping_errors == 1, NULL);
1997         fail_unless(num_mapping_conflicts == 0, NULL);
1998         fail_unless(num_engine_errors == 1, NULL);
1999         fail_unless(num_engine_successful == 0, NULL);
2000
2001         fail_unless(osync_testing_diff("data1", "data2"));
2002         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
2003
2004         g_free(formatdir);
2005         g_free(plugindir);
2006
2007         destroy_testbed(testbed);
2008 }
2009 END_TEST
2010
2011 START_TEST (dual_commit_timeout)
2012 {
2013         char *testbed = setup_testbed("multisync_easy_new");
2014         char *formatdir = g_strdup_printf("%s/formats", testbed);
2015         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2016
2017         g_setenv("COMMIT_TIMEOUT", "6", TRUE);
2018
2019         OSyncError *error = NULL;
2020         OSyncGroup *group = osync_group_new(&error);
2021         osync_group_set_schemadir(group, testbed);
2022         osync_group_load(group, "configs/group", &error);
2023         fail_unless(error == NULL, NULL);
2024
2025         OSyncEngine *engine = osync_engine_new(group, &error);
2026         fail_unless(engine != NULL, NULL);
2027         fail_unless(error == NULL, NULL);
2028
2029         osync_engine_set_schemadir(engine, testbed);
2030         osync_engine_set_plugindir(engine, plugindir);
2031         osync_engine_set_formatdir(engine, formatdir);
2032
2033         discover_all_once(engine, &error);
2034
2035         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2036         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2037         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2038         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2039         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2040
2041         fail_unless(osync_engine_initialize(engine, &error), NULL);
2042         fail_unless(error == NULL, NULL);
2043
2044         fail_unless(!synchronize_once(engine, &error), NULL);
2045         fail_unless(error != NULL, NULL);
2046         fail_unless(osync_error_is_set(&error), NULL);
2047
2048         osync_error_unref(&error);
2049         osync_engine_finalize(engine, &error);
2050         osync_engine_unref(engine);
2051
2052         fail_unless(num_client_errors == 0, NULL);
2053         fail_unless(num_client_connected == 3, NULL);
2054         fail_unless(num_client_disconnected == 3, NULL);
2055         fail_unless(num_client_written == 3, NULL);
2056         fail_unless(num_change_read == 1, NULL);
2057         fail_unless(num_change_written == 0, NULL);
2058         fail_unless(num_change_error == 2, NULL);
2059         fail_unless(num_mapping_errors == 2, NULL);
2060         fail_unless(num_mapping_conflicts == 0, NULL);
2061         fail_unless(num_engine_errors == 1, NULL);
2062         fail_unless(num_engine_successful == 0, NULL);
2063
2064         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
2065         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
2066
2067         g_free(formatdir);
2068         g_free(plugindir);
2069
2070         destroy_testbed(testbed);
2071 }
2072 END_TEST
2073
2074 START_TEST (commit_timeout_and_error)
2075 {
2076         char *testbed = setup_testbed("multisync_easy_new");
2077         char *formatdir = g_strdup_printf("%s/formats", testbed);
2078         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2079
2080         g_setenv("COMMIT_TIMEOUT", "4", TRUE);
2081         g_setenv("COMMIT_ERROR", "2", TRUE);
2082
2083         OSyncError *error = NULL;
2084         OSyncGroup *group = osync_group_new(&error);
2085         osync_group_set_schemadir(group, testbed);
2086         osync_group_load(group, "configs/group", &error);
2087         fail_unless(error == NULL, NULL);
2088
2089         OSyncEngine *engine = osync_engine_new(group, &error);
2090         fail_unless(engine != NULL, NULL);
2091         fail_unless(error == NULL, NULL);
2092
2093         osync_engine_set_schemadir(engine, testbed);
2094         osync_engine_set_plugindir(engine, plugindir);
2095         osync_engine_set_formatdir(engine, formatdir);
2096
2097         discover_all_once(engine, &error);
2098
2099         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2100         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2101         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2102         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2103         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2104
2105         fail_unless(osync_engine_initialize(engine, &error), NULL);
2106         fail_unless(error == NULL, NULL);
2107
2108         fail_unless(!synchronize_once(engine, &error), NULL);
2109         fail_unless(error != NULL, NULL);
2110         fail_unless(osync_error_is_set(&error), NULL);
2111
2112         osync_error_unref(&error);
2113         osync_engine_finalize(engine, &error);
2114         osync_engine_unref(engine);
2115
2116         fail_unless(num_client_errors == 0, NULL);
2117         fail_unless(num_client_connected == 3, NULL);
2118         fail_unless(num_client_disconnected == 3, NULL);
2119         fail_unless(num_client_written == 3, NULL);
2120         fail_unless(num_change_read == 1, NULL);
2121         fail_unless(num_change_written == 0, NULL);
2122         fail_unless(num_change_error == 2, NULL);
2123         fail_unless(num_mapping_errors == 2, NULL);
2124         fail_unless(num_mapping_conflicts == 0, NULL);
2125         fail_unless(num_engine_errors == 1, NULL);
2126         fail_unless(num_engine_successful == 0, NULL);
2127
2128         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
2129         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
2130
2131         g_free(formatdir);
2132         g_free(plugindir);
2133
2134         destroy_testbed(testbed);
2135 }
2136 END_TEST
2137
2138 START_TEST (commit_timeout_and_error2)
2139 {
2140         char *testbed = setup_testbed("multisync_easy_new");
2141         char *formatdir = g_strdup_printf("%s/formats", testbed);
2142         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2143
2144         g_setenv("COMMIT_TIMEOUT", "2", TRUE);
2145         g_setenv("COMMIT_ERROR", "4", TRUE);
2146
2147         OSyncError *error = NULL;
2148         OSyncGroup *group = osync_group_new(&error);
2149         osync_group_set_schemadir(group, testbed);
2150         osync_group_load(group, "configs/group", &error);
2151         fail_unless(error == NULL, NULL);
2152
2153         OSyncEngine *engine = osync_engine_new(group, &error);
2154         fail_unless(engine != NULL, NULL);
2155         fail_unless(error == NULL, NULL);
2156
2157         osync_engine_set_schemadir(engine, testbed);
2158         osync_engine_set_plugindir(engine, plugindir);
2159         osync_engine_set_formatdir(engine, formatdir);
2160
2161         discover_all_once(engine, &error);
2162
2163         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2164         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2165         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2166         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2167         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2168
2169         fail_unless(osync_engine_initialize(engine, &error), NULL);
2170         fail_unless(error == NULL, NULL);
2171
2172         fail_unless(!synchronize_once(engine, &error), NULL);
2173         fail_unless(error != NULL, NULL);
2174         fail_unless(osync_error_is_set(&error), NULL);
2175
2176         osync_error_unref(&error);
2177         osync_engine_finalize(engine, &error);
2178         osync_engine_unref(engine);
2179
2180         fail_unless(num_client_errors == 0, NULL);
2181         fail_unless(num_client_connected == 3, NULL);
2182         fail_unless(num_client_disconnected == 3, NULL);
2183         fail_unless(num_client_written == 3, NULL);
2184         fail_unless(num_change_read == 1, NULL);
2185         fail_unless(num_change_written == 0, NULL);
2186         fail_unless(num_change_error == 2, NULL);
2187         fail_unless(num_mapping_errors == 2, NULL);
2188         fail_unless(num_mapping_conflicts == 0, NULL);
2189         fail_unless(num_engine_errors == 1, NULL);
2190         fail_unless(num_engine_successful == 0, NULL);
2191
2192         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
2193         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
2194
2195         g_free(formatdir);
2196         g_free(plugindir);
2197
2198         destroy_testbed(testbed);
2199 }
2200 END_TEST
2201
2202 /* FIXME: timeout */
2203 START_TEST (commit_error_modify)
2204 {
2205         char *testbed = setup_testbed("multisync_easy_new");
2206         char *formatdir = g_strdup_printf("%s/formats", testbed);
2207         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2208
2209         OSyncError *error = NULL;
2210         OSyncGroup *group = osync_group_new(&error);
2211         osync_group_set_schemadir(group, testbed);
2212         osync_group_load(group, "configs/group", &error);
2213         fail_unless(error == NULL, NULL);
2214
2215         OSyncEngine *engine = osync_engine_new(group, &error);
2216         fail_unless(engine != NULL, NULL);
2217         fail_unless(error == NULL, NULL);
2218
2219         osync_engine_set_schemadir(engine, testbed);
2220         osync_engine_set_plugindir(engine, plugindir);
2221         osync_engine_set_formatdir(engine, formatdir);
2222
2223         discover_all_once(engine, &error);
2224
2225         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2226         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2227         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2228         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2229         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2230
2231         fail_unless(osync_engine_initialize(engine, &error), NULL);
2232         fail_unless(error == NULL, NULL);
2233
2234         fail_unless(synchronize_once(engine, &error), NULL);
2235         fail_unless(error == NULL, NULL);
2236         fail_unless(!osync_error_is_set(&error), NULL);
2237
2238         g_setenv("COMMIT_TIMEOUT", "2", TRUE);
2239         g_setenv("COMMIT_ERROR", "4", TRUE);
2240
2241         g_usleep(2*G_USEC_PER_SEC);
2242
2243         if (system("cp newdata2 data1/testdata"))
2244                 abort();
2245
2246         fail_unless(!synchronize_once(engine, &error), NULL);
2247         fail_unless(osync_error_is_set(&error), NULL);
2248
2249         osync_error_unref(&error);
2250         osync_engine_finalize(engine, &error);
2251         osync_engine_unref(engine);
2252
2253         fail_unless(num_client_errors == 0, NULL);
2254         fail_unless(num_client_connected == 3, NULL);
2255         fail_unless(num_client_disconnected == 3, NULL);
2256         fail_unless(num_client_written == 3, NULL);
2257         fail_unless(num_change_read == 1, NULL);
2258         fail_unless(num_change_written == 0, NULL);
2259         fail_unless(num_change_error == 2, NULL);
2260         fail_unless(num_mapping_errors == 2, NULL);
2261         fail_unless(num_mapping_conflicts == 0, NULL);
2262         fail_unless(num_engine_errors == 1, NULL);
2263         fail_unless(num_engine_successful == 0, NULL);
2264
2265         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
2266         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
2267         fail_unless(osync_testing_diff("data2", "data3"));
2268
2269         g_free(formatdir);
2270         g_free(plugindir);
2271
2272         destroy_testbed(testbed);
2273 }
2274 END_TEST
2275
2276 START_TEST (commit_error_delete)
2277 {
2278         char *testbed = setup_testbed("multisync_easy_new");
2279         char *formatdir = g_strdup_printf("%s/formats", testbed);
2280         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2281
2282         OSyncError *error = NULL;
2283
2284         OSyncGroup *group = osync_group_new(&error);
2285         osync_group_set_schemadir(group, testbed);
2286         osync_group_load(group, "configs/group", &error);
2287         fail_unless(error == NULL, NULL);
2288
2289         OSyncEngine *engine = osync_engine_new(group, &error);
2290         fail_unless(engine != NULL, NULL);
2291         fail_unless(error == NULL, NULL);
2292
2293         osync_engine_set_schemadir(engine, testbed);
2294         osync_engine_set_plugindir(engine, plugindir);
2295         osync_engine_set_formatdir(engine, formatdir);
2296
2297         discover_all_once(engine, &error);
2298
2299         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2300         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2301         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2302         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2303         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2304
2305         fail_unless(osync_engine_initialize(engine, &error), NULL);
2306         fail_unless(error == NULL, NULL);
2307
2308         fail_unless(synchronize_once(engine, &error), NULL);
2309         fail_unless(error == NULL, NULL);
2310         fail_unless(!osync_error_is_set(&error), NULL);
2311
2312         g_setenv("COMMIT_TIMEOUT", "2", TRUE);
2313         g_setenv("COMMIT_ERROR", "4", TRUE);
2314
2315         g_usleep(2*G_USEC_PER_SEC);
2316
2317         if (system("rm -f data1/testdata"))
2318                 abort();
2319
2320         fail_unless(!synchronize_once(engine, &error), NULL);
2321         fail_unless(osync_error_is_set(&error), NULL);
2322
2323         osync_error_unref(&error);
2324         osync_engine_finalize(engine, &error);
2325         osync_engine_unref(engine);
2326
2327         fail_unless(num_client_errors == 0, NULL);
2328         fail_unless(num_client_connected == 3, NULL);
2329         fail_unless(num_client_disconnected == 3, NULL);
2330         fail_unless(num_client_written == 3, NULL);
2331         fail_unless(num_change_read == 1, NULL);
2332         fail_unless(num_change_written == 0, NULL);
2333         fail_unless(num_change_error == 2, NULL);
2334         fail_unless(num_mapping_errors == 2, NULL);
2335         fail_unless(num_mapping_conflicts == 0, NULL);
2336         fail_unless(num_engine_errors == 1, NULL);
2337         fail_unless(num_engine_successful == 0, NULL);
2338
2339         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
2340         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
2341         fail_unless(osync_testing_diff("data2", "data3"));
2342
2343         g_free(formatdir);
2344         g_free(plugindir);
2345
2346         destroy_testbed(testbed);
2347 }
2348 END_TEST
2349
2350 START_TEST (committed_all_error)
2351 {
2352         char *testbed = setup_testbed("multisync_easy_new");
2353         char *formatdir = g_strdup_printf("%s/formats", testbed);
2354         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2355
2356         g_setenv("COMMITTED_ALL_ERROR", "3", TRUE);
2357
2358         OSyncError *error = NULL;
2359
2360         OSyncGroup *group = osync_group_new(&error);
2361         osync_group_set_schemadir(group, testbed);
2362         osync_group_load(group, "configs/group", &error);
2363         fail_unless(error == NULL, NULL);
2364
2365         OSyncEngine *engine = osync_engine_new(group, &error);
2366         fail_unless(engine != NULL, NULL);
2367         fail_unless(error == NULL, NULL);
2368
2369         osync_engine_set_schemadir(engine, testbed);
2370         osync_engine_set_plugindir(engine, plugindir);
2371         osync_engine_set_formatdir(engine, formatdir);
2372
2373         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2374         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2375         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2376         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2377         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2378
2379         fail_unless(osync_engine_initialize(engine, &error), NULL);
2380         fail_unless(error == NULL, NULL);
2381
2382         fail_unless(!synchronize_once(engine, &error), NULL);
2383         fail_unless(osync_error_is_set(&error), NULL);
2384
2385         osync_error_unref(&error);
2386         osync_engine_finalize(engine, &error);
2387         osync_engine_unref(engine);
2388
2389         fail_unless(num_client_errors == 2, NULL);
2390         fail_unless(num_client_connected == 3, NULL);
2391         fail_unless(num_client_disconnected == 3, NULL);
2392         fail_unless(num_client_written == 1, NULL);
2393         fail_unless(num_change_read == 1, NULL);
2394         fail_unless(num_change_written == 2, NULL);
2395         fail_unless(num_change_error == 0, NULL);
2396         fail_unless(num_mapping_errors == 0, NULL);
2397         fail_unless(num_mapping_conflicts == 0, NULL);
2398         fail_unless(num_engine_errors == 1, NULL);
2399         fail_unless(num_engine_successful == 0, NULL);
2400
2401         fail_unless(osync_testing_diff("data1", "data2"));
2402         fail_unless(osync_testing_diff("data1", "data3"));
2403
2404         g_free(formatdir);
2405         g_free(plugindir);
2406
2407         destroy_testbed(testbed);
2408 }
2409 END_TEST
2410
2411 START_TEST (committed_all_batch_error)
2412 {
2413         char *testbed = setup_testbed("multisync_easy_new");
2414         char *formatdir = g_strdup_printf("%s/formats", testbed);
2415         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2416
2417         g_setenv("BATCH_COMMIT", "7", TRUE);
2418         g_setenv("COMMITTED_ALL_ERROR", "3", TRUE);
2419
2420         OSyncError *error = NULL;
2421
2422         OSyncGroup *group = osync_group_new(&error);
2423         osync_group_set_schemadir(group, testbed);
2424         osync_group_load(group, "configs/group", &error);
2425         fail_unless(error == NULL, NULL);
2426
2427         OSyncEngine *engine = osync_engine_new(group, &error);
2428         fail_unless(engine != NULL, NULL);
2429         fail_unless(error == NULL, NULL);
2430
2431         osync_engine_set_schemadir(engine, testbed);
2432         osync_engine_set_plugindir(engine, plugindir);
2433         osync_engine_set_formatdir(engine, formatdir);
2434
2435         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2436         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2437         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2438         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2439         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2440
2441         fail_unless(osync_engine_initialize(engine, &error), NULL);
2442         fail_unless(error == NULL, NULL);
2443
2444         fail_unless(!synchronize_once(engine, &error), NULL);
2445         fail_unless(osync_error_is_set(&error), NULL);
2446
2447         osync_error_unref(&error);
2448         osync_engine_finalize(engine, &error);
2449         osync_engine_unref(engine);
2450
2451         fail_unless(num_client_errors == 2, NULL);
2452         fail_unless(num_client_connected == 3, NULL);
2453         fail_unless(num_client_disconnected == 3, NULL);
2454         fail_unless(num_client_written == 1, NULL);
2455         fail_unless(num_change_read == 1, NULL);
2456         fail_unless(num_change_written == 2, NULL);
2457         fail_unless(num_change_error == 0, NULL);
2458         fail_unless(num_mapping_errors == 0, NULL);
2459         fail_unless(num_mapping_conflicts == 0, NULL);
2460         fail_unless(num_engine_errors == 1, NULL);
2461         fail_unless(num_engine_successful == 0, NULL);
2462
2463         fail_unless(osync_testing_diff("data1", "data2"));
2464         fail_unless(osync_testing_diff("data1", "data3"));
2465
2466         g_free(formatdir);
2467         g_free(plugindir);
2468
2469         destroy_testbed(testbed);
2470 }
2471 END_TEST
2472
2473 START_TEST (single_sync_done_error)
2474 {
2475         char *testbed = setup_testbed("multisync_easy_new");
2476         char *formatdir = g_strdup_printf("%s/formats", testbed);
2477         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2478
2479         g_setenv("SYNC_DONE_ERROR", "4", TRUE);
2480
2481         OSyncError *error = NULL;
2482
2483         OSyncGroup *group = osync_group_new(&error);
2484         osync_group_set_schemadir(group, testbed);
2485         osync_group_load(group, "configs/group", &error);
2486         fail_unless(error == NULL, NULL);
2487
2488         OSyncEngine *engine = osync_engine_new(group, &error);
2489         fail_unless(engine != NULL, NULL);
2490         fail_unless(error == NULL, NULL);
2491
2492         osync_engine_set_schemadir(engine, testbed);
2493         osync_engine_set_plugindir(engine, plugindir);
2494         osync_engine_set_formatdir(engine, formatdir);
2495
2496         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2497         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2498         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2499         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2500         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2501
2502         fail_unless(osync_engine_initialize(engine, &error), NULL);
2503         fail_unless(error == NULL, NULL);
2504
2505         fail_unless(!synchronize_once(engine, &error), NULL);
2506         fail_unless(osync_error_is_set(&error), NULL);
2507
2508         osync_error_unref(&error);
2509         osync_engine_finalize(engine, &error);
2510         osync_engine_unref(engine);
2511
2512         fail_unless(num_client_errors == 1, NULL);
2513         fail_unless(num_client_connected == 3, NULL);
2514         fail_unless(num_client_disconnected == 3, NULL);
2515         fail_unless(num_client_written == 3, NULL);
2516         fail_unless(num_change_read == 1, NULL);
2517         fail_unless(num_change_written == 2, NULL);
2518         fail_unless(num_change_error == 0, NULL);
2519         fail_unless(num_mapping_errors == 0, NULL);
2520         fail_unless(num_mapping_conflicts == 0, NULL);
2521         fail_unless(num_engine_errors == 1, NULL);
2522         fail_unless(num_engine_successful == 0, NULL);
2523
2524         fail_unless(osync_testing_diff("data1", "data2"));
2525         fail_unless(osync_testing_diff("data1", "data3"));
2526
2527         g_free(formatdir);
2528         g_free(plugindir);
2529
2530         destroy_testbed(testbed);
2531 }
2532 END_TEST
2533
2534 START_TEST (dual_sync_done_error)
2535 {
2536         char *testbed = setup_testbed("multisync_easy_new");
2537         char *formatdir = g_strdup_printf("%s/formats", testbed);
2538         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2539
2540         g_setenv("SYNC_DONE_ERROR", "6", TRUE);
2541
2542         OSyncError *error = NULL;
2543
2544         OSyncGroup *group = osync_group_new(&error);
2545         osync_group_set_schemadir(group, testbed);
2546         osync_group_load(group, "configs/group", &error);
2547         fail_unless(error == NULL, NULL);
2548
2549         OSyncEngine *engine = osync_engine_new(group, &error);
2550         fail_unless(engine != NULL, NULL);
2551         fail_unless(error == NULL, NULL);
2552
2553         osync_engine_set_schemadir(engine, testbed);
2554         osync_engine_set_plugindir(engine, plugindir);
2555         osync_engine_set_formatdir(engine, formatdir);
2556
2557         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2558         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2559         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2560         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2561         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2562
2563         fail_unless(osync_engine_initialize(engine, &error), NULL);
2564         fail_unless(error == NULL, NULL);
2565
2566         fail_unless(!synchronize_once(engine, &error), NULL);
2567         fail_unless(osync_error_is_set(&error), NULL);
2568
2569         osync_error_unref(&error);
2570         osync_engine_finalize(engine, &error);
2571         osync_engine_unref(engine);
2572
2573         fail_unless(num_client_errors == 2, NULL);
2574         fail_unless(num_client_connected == 3, NULL);
2575         fail_unless(num_client_disconnected == 3, NULL);
2576         fail_unless(num_client_written == 3, NULL);
2577         fail_unless(num_change_read == 1, NULL);
2578         fail_unless(num_change_written == 2, NULL);
2579         fail_unless(num_change_error == 0, NULL);
2580         fail_unless(num_mapping_errors == 0, NULL);
2581         fail_unless(num_mapping_conflicts == 0, NULL);
2582         fail_unless(num_engine_errors == 1, NULL);
2583         fail_unless(num_engine_successful == 0, NULL);
2584
2585         fail_unless(osync_testing_diff("data1", "data2"));
2586         fail_unless(osync_testing_diff("data1", "data3"));
2587
2588         g_free(formatdir);
2589         g_free(plugindir);
2590
2591         destroy_testbed(testbed);
2592 }
2593 END_TEST
2594
2595 START_TEST (triple_sync_done_error)
2596 {
2597         char *testbed = setup_testbed("multisync_easy_new");
2598         char *formatdir = g_strdup_printf("%s/formats", testbed);
2599         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2600
2601         g_setenv("SYNC_DONE_ERROR", "7", TRUE);
2602
2603         OSyncError *error = NULL;
2604
2605         OSyncGroup *group = osync_group_new(&error);
2606         osync_group_set_schemadir(group, testbed);
2607         osync_group_load(group, "configs/group", &error);
2608         fail_unless(error == NULL, NULL);
2609
2610         OSyncEngine *engine = osync_engine_new(group, &error);
2611         fail_unless(engine != NULL, NULL);
2612         fail_unless(error == NULL, NULL);
2613
2614         osync_engine_set_schemadir(engine, testbed);
2615         osync_engine_set_plugindir(engine, plugindir);
2616         osync_engine_set_formatdir(engine, formatdir);
2617
2618         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2619         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2620         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2621         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2622         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2623
2624         fail_unless(osync_engine_initialize(engine, &error), NULL);
2625         fail_unless(error == NULL, NULL);
2626
2627         fail_unless(!synchronize_once(engine, &error), NULL);
2628         fail_unless(osync_error_is_set(&error), NULL);
2629
2630         osync_error_unref(&error);
2631         osync_engine_finalize(engine, &error);
2632         osync_engine_unref(engine);
2633
2634         fail_unless(num_client_errors == 3, NULL);
2635         fail_unless(num_client_connected == 3, NULL);
2636         fail_unless(num_client_disconnected == 3, NULL);
2637         fail_unless(num_client_written == 3, NULL);
2638         fail_unless(num_change_read == 1, NULL);
2639         fail_unless(num_change_written == 2, NULL);
2640         fail_unless(num_change_error == 0, NULL);
2641         fail_unless(num_mapping_errors == 0, NULL);
2642         fail_unless(num_mapping_conflicts == 0, NULL);
2643         fail_unless(num_engine_errors == 1, NULL);
2644         fail_unless(num_engine_successful == 0, NULL);
2645
2646         fail_unless(osync_testing_diff("data1", "data2"));
2647         fail_unless(osync_testing_diff("data1", "data3"));
2648
2649         g_free(formatdir);
2650         g_free(plugindir);
2651
2652         destroy_testbed(testbed);
2653 }
2654 END_TEST
2655
2656 START_TEST (single_sync_done_timeout)
2657 {
2658         char *testbed = setup_testbed("multisync_easy_new");
2659         char *formatdir = g_strdup_printf("%s/formats", testbed);
2660         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2661
2662         g_setenv("SYNC_DONE_TIMEOUT", "4", TRUE);
2663
2664         OSyncError *error = NULL;
2665
2666         OSyncGroup *group = osync_group_new(&error);
2667         osync_group_set_schemadir(group, testbed);
2668         osync_group_load(group, "configs/group", &error);
2669         fail_unless(error == NULL, NULL);
2670
2671         OSyncEngine *engine = osync_engine_new(group, &error);
2672         fail_unless(engine != NULL, NULL);
2673         fail_unless(error == NULL, NULL);
2674
2675         osync_engine_set_schemadir(engine, testbed);
2676         osync_engine_set_plugindir(engine, plugindir);
2677         osync_engine_set_formatdir(engine, formatdir);
2678
2679         discover_all_once(engine, &error);
2680
2681         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2682         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2683         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2684         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2685         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2686
2687         fail_unless(osync_engine_initialize(engine, &error), NULL);
2688         fail_unless(error == NULL, NULL);
2689
2690         fail_unless(!synchronize_once(engine, &error), NULL);
2691         fail_unless(osync_error_is_set(&error), NULL);
2692
2693         osync_error_unref(&error);
2694         osync_engine_finalize(engine, &error);
2695         osync_engine_unref(engine);
2696
2697         fail_unless(num_client_errors == 1, NULL);
2698         fail_unless(num_client_connected == 3, NULL);
2699         fail_unless(num_client_disconnected == 3, NULL);
2700         fail_unless(num_client_written == 3, NULL);
2701         fail_unless(num_change_read == 1, NULL);
2702         fail_unless(num_change_written == 2, NULL);
2703         fail_unless(num_change_error == 0, NULL);
2704         fail_unless(num_mapping_errors == 0, NULL);
2705         fail_unless(num_mapping_conflicts == 0, NULL);
2706         fail_unless(num_engine_errors == 1, NULL);
2707         fail_unless(num_engine_successful == 0, NULL);
2708
2709         fail_unless(osync_testing_diff("data1", "data2"));
2710         fail_unless(osync_testing_diff("data1", "data3"));
2711
2712         g_free(formatdir);
2713         g_free(plugindir);
2714
2715         destroy_testbed(testbed);
2716 }
2717 END_TEST
2718
2719 START_TEST (dual_sync_done_timeout)
2720 {
2721         char *testbed = setup_testbed("multisync_easy_new");
2722         char *formatdir = g_strdup_printf("%s/formats", testbed);
2723         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2724
2725         g_setenv("SYNC_DONE_TIMEOUT", "6", TRUE);
2726
2727         OSyncError *error = NULL;
2728
2729         OSyncGroup *group = osync_group_new(&error);
2730         osync_group_set_schemadir(group, testbed);
2731         osync_group_load(group, "configs/group", &error);
2732         fail_unless(error == NULL, NULL);
2733
2734         OSyncEngine *engine = osync_engine_new(group, &error);
2735         fail_unless(engine != NULL, NULL);
2736         fail_unless(error == NULL, NULL);
2737
2738         osync_engine_set_schemadir(engine, testbed);
2739         osync_engine_set_plugindir(engine, plugindir);
2740         osync_engine_set_formatdir(engine, formatdir);
2741
2742         discover_all_once(engine, &error);
2743
2744         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2745         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2746         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2747         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2748         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2749
2750         fail_unless(osync_engine_initialize(engine, &error), NULL);
2751         fail_unless(error == NULL, NULL);
2752
2753         fail_unless(!synchronize_once(engine, &error), NULL);
2754         fail_unless(osync_error_is_set(&error), NULL);
2755
2756         osync_error_unref(&error);
2757         osync_engine_finalize(engine, &error);
2758         osync_engine_unref(engine);
2759
2760         fail_unless(num_client_errors == 2, NULL);
2761         fail_unless(num_client_connected == 3, NULL);
2762         fail_unless(num_client_disconnected == 3, NULL);
2763         fail_unless(num_client_written == 3, NULL);
2764         fail_unless(num_change_read == 1, NULL);
2765         fail_unless(num_change_written == 2, NULL);
2766         fail_unless(num_change_error == 0, NULL);
2767         fail_unless(num_mapping_errors == 0, NULL);
2768         fail_unless(num_mapping_conflicts == 0, NULL);
2769         fail_unless(num_engine_errors == 1, NULL);
2770         fail_unless(num_engine_successful == 0, NULL);
2771
2772         fail_unless(osync_testing_diff("data1", "data2"));
2773         fail_unless(osync_testing_diff("data1", "data3"));
2774
2775         g_free(formatdir);
2776         g_free(plugindir);
2777
2778         destroy_testbed(testbed);
2779 }
2780 END_TEST
2781
2782 START_TEST (sync_done_timeout_and_error)
2783 {
2784         char *testbed = setup_testbed("multisync_easy_new");
2785         char *formatdir = g_strdup_printf("%s/formats", testbed);
2786         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2787
2788         g_setenv("SYNC_DONE_TIMEOUT", "5", TRUE);
2789         g_setenv("SYNC_DONE_ERROR", "2", TRUE);
2790
2791         OSyncError *error = NULL;
2792
2793         OSyncGroup *group = osync_group_new(&error);
2794         osync_group_set_schemadir(group, testbed);
2795         osync_group_load(group, "configs/group", &error);
2796         fail_unless(error == NULL, NULL);
2797
2798         OSyncEngine *engine = osync_engine_new(group, &error);
2799         fail_unless(engine != NULL, NULL);
2800         fail_unless(error == NULL, NULL);
2801
2802         osync_engine_set_schemadir(engine, testbed);
2803         osync_engine_set_plugindir(engine, plugindir);
2804         osync_engine_set_formatdir(engine, formatdir);
2805
2806         discover_all_once(engine, &error);
2807
2808         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2809         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2810         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2811         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2812         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2813
2814         fail_unless(osync_engine_initialize(engine, &error), NULL);
2815         fail_unless(error == NULL, NULL);
2816
2817         fail_unless(!synchronize_once(engine, &error), NULL);
2818         fail_unless(osync_error_is_set(&error), NULL);
2819
2820         osync_error_unref(&error);
2821         osync_engine_finalize(engine, &error);
2822         osync_engine_unref(engine);
2823
2824         fail_unless(num_client_errors == 3, NULL);
2825         fail_unless(num_client_connected == 3, NULL);
2826         fail_unless(num_client_disconnected == 3, NULL);
2827         fail_unless(num_client_written == 3, NULL);
2828         fail_unless(num_change_read == 1, NULL);
2829         fail_unless(num_change_written == 2, NULL);
2830         fail_unless(num_change_error == 0, NULL);
2831         fail_unless(num_mapping_errors == 0, NULL);
2832         fail_unless(num_mapping_conflicts == 0, NULL);
2833         fail_unless(num_engine_errors == 1, NULL);
2834         fail_unless(num_engine_successful == 0, NULL);
2835
2836         fail_unless(osync_testing_diff("data1", "data2"));
2837         fail_unless(osync_testing_diff("data1", "data3"));
2838
2839         g_free(formatdir);
2840         g_free(plugindir);
2841
2842         destroy_testbed(testbed);
2843 }
2844 END_TEST
2845
2846 START_TEST (single_disconnect_error)
2847 {
2848         char *testbed = setup_testbed("multisync_easy_new");
2849         char *formatdir = g_strdup_printf("%s/formats", testbed);
2850         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2851
2852         g_setenv("DISCONNECT_ERROR", "4", TRUE);
2853
2854         OSyncError *error = NULL;
2855
2856         OSyncGroup *group = osync_group_new(&error);
2857         osync_group_set_schemadir(group, testbed);
2858         osync_group_load(group, "configs/group", &error);
2859         fail_unless(error == NULL, NULL);
2860
2861         OSyncEngine *engine = osync_engine_new(group, &error);
2862         fail_unless(engine != NULL, NULL);
2863         fail_unless(error == NULL, NULL);
2864
2865         osync_engine_set_schemadir(engine, testbed);
2866         osync_engine_set_plugindir(engine, plugindir);
2867         osync_engine_set_formatdir(engine, formatdir);
2868
2869         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2870         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2871         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2872         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2873         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2874
2875         fail_unless(osync_engine_initialize(engine, &error), NULL);
2876         fail_unless(error == NULL, NULL);
2877
2878         fail_unless(synchronize_once(engine, &error), NULL);
2879         fail_unless(!osync_error_is_set(&error), NULL);
2880
2881         osync_error_unref(&error);
2882         osync_engine_finalize(engine, &error);
2883         osync_engine_unref(engine);
2884
2885         fail_unless(num_client_errors == 1, NULL);
2886         fail_unless(num_client_connected == 3, NULL);
2887         fail_unless(num_client_disconnected == 2, NULL);
2888         fail_unless(num_client_written == 3, NULL);
2889         fail_unless(num_change_read == 1, NULL);
2890         fail_unless(num_change_written == 2, NULL);
2891         fail_unless(num_change_error == 0, NULL);
2892         fail_unless(num_mapping_errors == 0, NULL);
2893         fail_unless(num_mapping_conflicts == 0, NULL);
2894         fail_unless(num_engine_errors == 0, NULL);
2895         fail_unless(num_engine_successful == 1, NULL);
2896
2897         fail_unless(osync_testing_diff("data1", "data2"));
2898         fail_unless(osync_testing_diff("data1", "data3"));
2899
2900         g_free(formatdir);
2901         g_free(plugindir);
2902
2903         destroy_testbed(testbed);
2904 }
2905 END_TEST
2906
2907 START_TEST (dual_disconnect_error)
2908 {
2909         char *testbed = setup_testbed("multisync_easy_new");
2910         char *formatdir = g_strdup_printf("%s/formats", testbed);
2911         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2912
2913         g_setenv("DISCONNECT_ERROR", "6", TRUE);
2914
2915         OSyncError *error = NULL;
2916
2917         OSyncGroup *group = osync_group_new(&error);
2918         osync_group_set_schemadir(group, testbed);
2919         osync_group_load(group, "configs/group", &error);
2920         fail_unless(error == NULL, NULL);
2921
2922         OSyncEngine *engine = osync_engine_new(group, &error);
2923         fail_unless(engine != NULL, NULL);
2924         fail_unless(error == NULL, NULL);
2925
2926         osync_engine_set_schemadir(engine, testbed);
2927         osync_engine_set_plugindir(engine, plugindir);
2928         osync_engine_set_formatdir(engine, formatdir);
2929
2930         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2931         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2932         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2933         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2934         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2935
2936         fail_unless(osync_engine_initialize(engine, &error), NULL);
2937         fail_unless(error == NULL, NULL);
2938
2939         fail_unless(synchronize_once(engine, &error), NULL);
2940         fail_unless(!osync_error_is_set(&error), NULL);
2941
2942         osync_error_unref(&error);
2943         osync_engine_finalize(engine, &error);
2944         osync_engine_unref(engine);
2945
2946         fail_unless(num_client_errors == 2, NULL);
2947         fail_unless(num_client_connected == 3, NULL);
2948         fail_unless(num_client_disconnected == 1, NULL);
2949         fail_unless(num_client_written == 3, NULL);
2950         fail_unless(num_change_read == 1, NULL);
2951         fail_unless(num_change_written == 2, NULL);
2952         fail_unless(num_change_error == 0, NULL);
2953         fail_unless(num_mapping_errors == 0, NULL);
2954         fail_unless(num_mapping_conflicts == 0, NULL);
2955         fail_unless(num_engine_errors == 0, NULL);
2956         fail_unless(num_engine_successful == 1, NULL);
2957
2958         fail_unless(osync_testing_diff("data1", "data2"));
2959         fail_unless(osync_testing_diff("data1", "data3"));
2960
2961         g_free(formatdir);
2962         g_free(plugindir);
2963
2964         destroy_testbed(testbed);
2965 }
2966 END_TEST
2967
2968 START_TEST (triple_disconnect_error)
2969 {
2970         char *testbed = setup_testbed("multisync_easy_new");
2971         char *formatdir = g_strdup_printf("%s/formats", testbed);
2972         char *plugindir = g_strdup_printf("%s/plugins", testbed);
2973
2974         g_setenv("DISCONNECT_ERROR", "7", TRUE);
2975
2976         OSyncError *error = NULL;
2977
2978         OSyncGroup *group = osync_group_new(&error);
2979         osync_group_set_schemadir(group, testbed);
2980         osync_group_load(group, "configs/group", &error);
2981         fail_unless(error == NULL, NULL);
2982
2983         OSyncEngine *engine = osync_engine_new(group, &error);
2984         fail_unless(engine != NULL, NULL);
2985         fail_unless(error == NULL, NULL);
2986
2987         osync_engine_set_schemadir(engine, testbed);
2988         osync_engine_set_plugindir(engine, plugindir);
2989         osync_engine_set_formatdir(engine, formatdir);
2990
2991         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
2992         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
2993         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
2994         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
2995         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2996
2997         fail_unless(osync_engine_initialize(engine, &error), NULL);
2998         fail_unless(error == NULL, NULL);
2999
3000         fail_unless(synchronize_once(engine, &error), NULL);
3001         fail_unless(!osync_error_is_set(&error), NULL);
3002
3003         osync_error_unref(&error);
3004         osync_engine_finalize(engine, &error);
3005         osync_engine_unref(engine);
3006
3007         fail_unless(num_client_errors == 3, NULL);
3008         fail_unless(num_client_connected == 3, NULL);
3009         fail_unless(num_client_disconnected == 0, NULL);
3010         fail_unless(num_client_written == 3, NULL);
3011         fail_unless(num_change_read == 1, NULL);
3012         fail_unless(num_change_written == 2, NULL);
3013         fail_unless(num_change_error == 0, NULL);
3014         fail_unless(num_mapping_errors == 0, NULL);
3015         fail_unless(num_mapping_conflicts == 0, NULL);
3016         fail_unless(num_engine_errors == 0, NULL);
3017         fail_unless(num_engine_successful == 1, NULL);
3018
3019         fail_unless(osync_testing_diff("data1", "data2"));
3020         fail_unless(osync_testing_diff("data1", "data3"));
3021
3022         g_free(formatdir);
3023         g_free(plugindir);
3024
3025         destroy_testbed(testbed);
3026 }
3027 END_TEST
3028
3029 START_TEST (single_disconnect_timeout)
3030 {
3031         char *testbed = setup_testbed("multisync_easy_new");
3032         char *formatdir = g_strdup_printf("%s/formats", testbed);
3033         char *plugindir = g_strdup_printf("%s/plugins", testbed);
3034
3035         g_setenv("DISCONNECT_TIMEOUT", "4", TRUE);
3036
3037         OSyncError *error = NULL;
3038
3039         OSyncGroup *group = osync_group_new(&error);
3040         osync_group_set_schemadir(group, testbed);
3041         osync_group_load(group, "configs/group", &error);
3042         fail_unless(error == NULL, NULL);
3043
3044         OSyncEngine *engine = osync_engine_new(group, &error);
3045         fail_unless(engine != NULL, NULL);
3046         fail_unless(error == NULL, NULL);
3047
3048         osync_engine_set_schemadir(engine, testbed);
3049         osync_engine_set_plugindir(engine, plugindir);
3050         osync_engine_set_formatdir(engine, formatdir);
3051
3052         discover_all_once(engine, &error);
3053
3054         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
3055         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
3056         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
3057         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
3058         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
3059
3060         fail_unless(osync_engine_initialize(engine, &error), NULL);
3061         fail_unless(error == NULL, NULL);
3062
3063         fail_unless(synchronize_once(engine, &error), NULL);
3064         fail_unless(!osync_error_is_set(&error), NULL);
3065
3066         osync_error_unref(&error);
3067         osync_engine_finalize(engine, &error);
3068         osync_engine_unref(engine);
3069
3070         fail_unless(num_client_errors == 1, NULL);
3071         fail_unless(num_client_connected == 3, NULL);
3072         fail_unless(num_client_disconnected == 2, NULL);
3073         fail_unless(num_client_written == 3, NULL);
3074         fail_unless(num_change_read == 1, NULL);
3075         fail_unless(num_change_written == 2, NULL);
3076         fail_unless(num_change_error == 0, NULL);
3077         fail_unless(num_mapping_errors == 0, NULL);
3078         fail_unless(num_mapping_conflicts == 0, NULL);
3079         fail_unless(num_engine_errors == 0, NULL);
3080         fail_unless(num_engine_successful == 1, NULL);
3081
3082         fail_unless(osync_testing_diff("data1", "data2"));
3083         fail_unless(osync_testing_diff("data1", "data3"));
3084
3085         g_free(formatdir);
3086         g_free(plugindir);
3087
3088         destroy_testbed(testbed);
3089 }
3090 END_TEST
3091
3092 START_TEST (dual_disconnect_timeout)
3093 {
3094         char *testbed = setup_testbed("multisync_easy_new");
3095         char *formatdir = g_strdup_printf("%s/formats", testbed);
3096         char *plugindir = g_strdup_printf("%s/plugins", testbed);
3097
3098         g_setenv("DISCONNECT_TIMEOUT", "6", TRUE);
3099
3100         OSyncError *error = NULL;
3101
3102         OSyncGroup *group = osync_group_new(&error);
3103         osync_group_set_schemadir(group, testbed);
3104         osync_group_load(group, "configs/group", &error);
3105         fail_unless(error == NULL, NULL);
3106
3107         OSyncEngine *engine = osync_engine_new(group, &error);
3108         fail_unless(engine != NULL, NULL);
3109         fail_unless(error == NULL, NULL);
3110
3111         osync_engine_set_schemadir(engine, testbed);
3112         osync_engine_set_plugindir(engine, plugindir);
3113         osync_engine_set_formatdir(engine, formatdir);
3114
3115         discover_all_once(engine, &error);
3116
3117         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
3118         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
3119         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
3120         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
3121         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
3122
3123         fail_unless(osync_engine_initialize(engine, &error), NULL);
3124         fail_unless(error == NULL, NULL);
3125
3126         fail_unless(synchronize_once(engine, &error), NULL);
3127         fail_unless(!osync_error_is_set(&error), NULL);
3128
3129         osync_error_unref(&error);
3130         osync_engine_finalize(engine, &error);
3131         osync_engine_unref(engine);
3132
3133         fail_unless(num_client_errors == 2, NULL);
3134         fail_unless(num_client_connected == 3, NULL);
3135         fail_unless(num_client_disconnected == 1, NULL);
3136         fail_unless(num_client_written == 3, NULL);
3137         fail_unless(num_change_read == 1, NULL);
3138         fail_unless(num_change_written == 2, NULL);
3139         fail_unless(num_change_error == 0, NULL);
3140         fail_unless(num_mapping_errors == 0, NULL);
3141         fail_unless(num_mapping_conflicts == 0, NULL);
3142         fail_unless(num_engine_errors == 0, NULL);
3143         fail_unless(num_engine_successful == 1, NULL);
3144
3145         fail_unless(osync_testing_diff("data1", "data2"));
3146         fail_unless(osync_testing_diff("data1", "data3"));
3147
3148         g_free(formatdir);
3149         g_free(plugindir);
3150
3151         destroy_testbed(testbed);
3152 }
3153 END_TEST
3154
3155 START_TEST (disconnect_timeout_and_error)
3156 {
3157         char *testbed = setup_testbed("multisync_easy_new");
3158         char *formatdir = g_strdup_printf("%s/formats", testbed);
3159         char *plugindir = g_strdup_printf("%s/plugins", testbed);
3160
3161         g_setenv("DISCONNECT_TIMEOUT", "5", TRUE);
3162         g_setenv("DISCONNECT_ERROR", "2", TRUE);
3163
3164         OSyncError *error = NULL;
3165
3166         OSyncGroup *group = osync_group_new(&error);
3167         osync_group_set_schemadir(group, testbed);
3168         osync_group_load(group, "configs/group", &error);
3169         fail_unless(error == NULL, NULL);
3170
3171         OSyncEngine *engine = osync_engine_new(group, &error);
3172         fail_unless(engine != NULL, NULL);
3173         fail_unless(error == NULL, NULL);
3174
3175         osync_engine_set_schemadir(engine, testbed);
3176         osync_engine_set_plugindir(engine, plugindir);
3177         osync_engine_set_formatdir(engine, formatdir);
3178
3179         discover_all_once(engine, &error);
3180
3181         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
3182         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
3183         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
3184         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
3185         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
3186
3187         fail_unless(osync_engine_initialize(engine, &error), NULL);
3188         fail_unless(error == NULL, NULL);
3189
3190         fail_unless(synchronize_once(engine, &error), NULL);
3191         fail_unless(!osync_error_is_set(&error), NULL);
3192
3193         osync_error_unref(&error);
3194         osync_engine_finalize(engine, &error);
3195         osync_engine_unref(engine);
3196
3197         fail_unless(num_client_errors == 3, NULL);
3198         fail_unless(num_client_connected == 3, NULL);
3199         fail_unless(num_client_disconnected == 0, NULL);
3200         fail_unless(num_client_written == 3, NULL);
3201         fail_unless(num_change_read == 1, NULL);
3202         fail_unless(num_change_written == 2, NULL);
3203         fail_unless(num_change_error == 0, NULL);
3204         fail_unless(num_mapping_errors == 0, NULL);
3205         fail_unless(num_mapping_conflicts == 0, NULL);
3206         fail_unless(num_engine_errors == 0, NULL);
3207         fail_unless(num_engine_successful == 1, NULL);
3208
3209         fail_unless(osync_testing_diff("data1", "data2"));
3210         fail_unless(osync_testing_diff("data1", "data3"));
3211
3212         g_free(formatdir);
3213         g_free(plugindir);
3214
3215         destroy_testbed(testbed);
3216 }
3217 END_TEST
3218
3219 START_TEST (get_changes_disconnect_error)
3220 {
3221         char *testbed = setup_testbed("multisync_easy_new");
3222         char *formatdir = g_strdup_printf("%s/formats", testbed);
3223         char *plugindir = g_strdup_printf("%s/plugins", testbed);
3224
3225         g_setenv("DISCONNECT_TIMEOUT", "1", TRUE);
3226         g_setenv("DISCONNECT_ERROR", "2", TRUE);
3227         g_setenv("GET_CHANGES_TIMEOUT", "6", TRUE);
3228         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
3229
3230         OSyncError *error = NULL;
3231
3232         OSyncGroup *group = osync_group_new(&error);
3233         osync_group_set_schemadir(group, testbed);
3234         osync_group_load(group, "configs/group", &error);
3235         fail_unless(error == NULL, NULL);
3236
3237         OSyncEngine *engine = osync_engine_new(group, &error);
3238         fail_unless(engine != NULL, NULL);
3239         fail_unless(error == NULL, NULL);
3240
3241         osync_engine_set_schemadir(engine, testbed);
3242         osync_engine_set_plugindir(engine, plugindir);
3243         osync_engine_set_formatdir(engine, formatdir);
3244
3245         discover_all_once(engine, &error);
3246
3247         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
3248         osync_engine_set_enginestatus_callback(engine, engine_status, GINT_TO_POINTER(1));
3249         osync_engine_set_changestatus_callback(engine, entry_status, GINT_TO_POINTER(1));
3250         osync_engine_set_mappingstatus_callback(engine, mapping_status, GINT_TO_POINTER(1));
3251         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
3252
3253         fail_unless(osync_engine_initialize(engine, &error), NULL);
3254         fail_unless(error == NULL, NULL);
3255
3256         fail_unless(!synchronize_once(engine, &error), NULL);
3257         fail_unless(osync_error_is_set(&error), NULL);
3258
3259         osync_error_unref(&error);
3260         osync_engine_finalize(engine, &error);
3261         osync_engine_unref(engine);
3262
3263         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
3264         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
3265
3266         g_free(formatdir);
3267         g_free(plugindir);
3268
3269         destroy_testbed(testbed);
3270 }
3271 END_TEST
3272
3273 START_TEST (missing_format_plugin)
3274 {
3275         char *testbed = setup_testbed("missing_format_plugin");
3276         char *formatdir = g_strdup_printf("%s/formats",  testbed);
3277         char *plugindir = g_strdup_printf("%s/plugins",  testbed);
3278
3279         OSyncError *error = NULL;
3280
3281         OSyncGroup *group = osync_group_new(&error);
3282         osync_group_set_schemadir(group, testbed);
3283         osync_group_load(group, "configs/group", &error);
3284         fail_unless(error == NULL, NULL);
3285
3286         OSyncEngine *engine = osync_engine_new(group, &error);
3287         fail_unless(engine != NULL, NULL);
3288         fail_unless(error == NULL, NULL);
3289
3290         osync_engine_set_schemadir(engine, testbed);
3291         osync_engine_set_plugindir(engine, plugindir);
3292         osync_engine_set_formatdir(engine, formatdir);
3293
3294         fail_unless(osync_engine_initialize(engine, &error) == FALSE, NULL); /* Intended fail */
3295         fail_unless(osync_error_is_set(&error), "No expected error about MISSINGFORMAT!");
3296
3297         osync_error_unref(&error);
3298         osync_engine_unref(engine);
3299
3300         g_free(formatdir);
3301         g_free(plugindir);
3302
3303         destroy_testbed(testbed);
3304
3305 }
3306 END_TEST
3307
3308 Suite *error_suite(void)
3309 {
3310         Suite *s = suite_create("Engine Errors");
3311         //Suite *s2 = suite_create("Engine Errors");
3312
3313         /* Temprorarly disabled until reviewed/fixed - see #995
3314         create_case(s, "single_init_error", single_init_error);
3315         create_case(s, "double_init_error", double_init_error);
3316         */
3317
3318         create_case(s, "no_config_error", no_config_error);
3319         create_case(s, "no_objtype_error", no_objtype_error);
3320
3321         /* Temprorarly disabled until reviewed/fixed - see #995
3322         create_case(s, "dual_connect_error", dual_connect_error);
3323         */
3324
3325         create_case(s, "one_of_two_connect_error", one_of_two_connect_error);
3326         create_case(s, "two_of_three_connect_error", two_of_three_connect_error);
3327         create_case(s, "two_of_three_connect_error2", two_of_three_connect_error2);
3328         create_case(s, "three_of_three_connect_error", three_of_three_connect_error);
3329
3330         create_case(s, "one_of_three_connect_error", one_of_three_connect_error);
3331         create_case(s, "no_connect_error", no_connect_error);
3332
3333         create_case(s, "single_connect_timeout", single_connect_timeout);
3334         create_case(s, "dual_connect_timeout", dual_connect_timeout);
3335         create_case(s, "one_of_three_timeout", one_of_three_timeout);
3336         create_case(s, "timeout_and_error", timeout_and_error);
3337
3338         create_case(s, "single_get_changes_error", single_get_changes_error);
3339         create_case(s, "dual_get_changes_error", dual_get_changes_error);
3340         create_case(s, "two_of_three_get_changes_error", two_of_three_get_changes_error);
3341         create_case(s, "one_of_three_get_changes_error", one_of_three_get_changes_error);
3342
3343         create_case(s, "one_of_three_get_changes_timeout", one_of_three_get_changes_timeout);
3344         create_case(s, "get_changes_timeout_and_error", get_changes_timeout_and_error);
3345
3346         /* FIXME: If get_changes delays and got timed out .. set change_callback to NULL.
3347            Make sure changes from the plugin got completely ignored by the engine when the timout handler got called.
3348            Even better would be to abort the get_changes call from the plugin process...
3349
3350         create_case(s2, "get_changes_timeout_sleep", get_changes_timeout_sleep);
3351         */
3352
3353         create_case(s, "single_commit_error", single_commit_error);
3354         create_case(s, "dual_commit_error", dual_commit_error);
3355
3356         create_case(s, "single_commit_timeout", single_commit_timeout);
3357         create_case(s, "dual_commit_timeout", dual_commit_timeout);
3358         create_case(s, "commit_timeout_and_error", commit_timeout_and_error);
3359         create_case(s, "commit_timeout_and_error2", commit_timeout_and_error2);
3360
3361         create_case(s, "commit_error_modify", commit_error_modify);
3362         create_case(s, "commit_error_delete", commit_error_delete);
3363
3364         create_case(s, "committed_all_error", committed_all_error);
3365         create_case(s, "committed_all_batch_error", committed_all_batch_error);
3366
3367         create_case(s, "single_sync_done_error", single_sync_done_error);
3368         create_case(s, "dual_sync_done_error", dual_sync_done_error);
3369         create_case(s, "triple_sync_done_error", triple_sync_done_error);
3370
3371         create_case(s, "single_sync_done_timeout", single_sync_done_timeout);
3372         create_case(s, "dual_sync_done_timeout", dual_sync_done_timeout);
3373         create_case(s, "sync_done_timeout_and_error", sync_done_timeout_and_error);
3374
3375         create_case(s, "single_disconnect_error", single_disconnect_error);
3376         create_case(s, "dual_disconnect_error", dual_disconnect_error);
3377         create_case(s, "triple_disconnect_error", triple_disconnect_error);
3378
3379         create_case(s, "single_disconnect_timeout", single_disconnect_timeout);
3380         create_case(s, "dual_disconnect_timeout", dual_disconnect_timeout);
3381         create_case(s, "disconnect_timeout_and_error", disconnect_timeout_and_error);
3382
3383         create_case(s, "get_changes_disconnect_error", get_changes_disconnect_error);
3384
3385         create_case(s, "missing_format_plugin", missing_format_plugin);
3386
3387         return s;
3388 }
3389
3390 int main(void)
3391 {
3392         int nf;
3393
3394         Suite *s = error_suite();
3395
3396         SRunner *sr;
3397         sr = srunner_create(s);
3398         srunner_run_all(sr, CK_VERBOSE);
3399         nf = srunner_ntests_failed(sr);
3400         srunner_free(sr);
3401         return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
3402 }