tests/sync-tests/check_sync_error.c

   1 #include "support.h"
   2
   3 #include "opensync/group/opensync_group_internals.h"
   4 #include "opensync/engine/opensync_engine_internals.h"
   5
   6 /* Regression test for Ticket #988 */
   7 START_TEST (single_init_error_noerror)
   8 {
   9         char *testbed = setup_testbed("sync");
  10         char *formatdir = g_strdup_printf("%s/formats", testbed);
  11         char *plugindir = g_strdup_printf("%s/plugins", testbed);
  12
  13         g_setenv("INIT_NULL_NOERROR", "2", TRUE);
  14
  15         OSyncError *error = NULL;
  16         OSyncGroup *group = osync_group_new(&error);
  17         fail_unless(group != NULL, NULL);
  18         fail_unless(error == NULL, NULL);
  19
  20         osync_group_set_schemadir(group, testbed);
  21         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
  22         fail_unless(error == NULL, NULL);
  23
  24         OSyncEngine *engine = osync_engine_new(group, &error);
  25         fail_unless(engine != NULL, NULL);
  26         fail_unless(error == NULL, NULL);
  27         osync_group_unref(group);
  28
  29         osync_engine_set_schemadir(engine, testbed);
  30         osync_engine_set_plugindir(engine, plugindir);
  31         osync_engine_set_formatdir(engine, formatdir);
  32
  33         osync_engine_set_memberstatus_callback(engine, member_status, GINT_TO_POINTER(1));
  34
  35         fail_unless(!osync_engine_initialize(engine, &error), NULL);
  36         fail_unless(error != NULL, NULL);
  37
  38         osync_engine_unref(engine);
  39         g_free(formatdir);
  40         g_free(plugindir);
  41
  42         destroy_testbed(testbed);
  43 }
  44 END_TEST
  45
  46 START_TEST (single_init_error)
  47 {
  48         char *testbed = setup_testbed("multisync_easy_new");
  49
  50         g_setenv("INIT_NULL", "2", TRUE);
  51
  52         OSyncError *error = NULL;
  53         OSyncGroup *group = osync_group_new(&error);
  54         fail_unless(group != NULL, NULL);
  55         fail_unless(error == NULL, NULL);
  56
  57         osync_group_set_schemadir(group, testbed);
  58         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
  59         fail_unless(error == NULL, NULL);
  60
  61         OSyncEngine *engine = osync_engine_new(group, &error);
  62         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
  63         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
  64         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
  65         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
  66
  67         /* this is a bug - please see sml_fail_unless for details */
  68         fail_unless(osync_engine_initialize(engine, &error), osync_error_print(&error));
  69         fail_unless(!synchronize_once(engine, &error), NULL);
  70         fail_unless(osync_error_is_set(&error), NULL);
  71
  72         osync_error_unref(&error);
  73         osync_engine_finalize(engine, &error);
  74         osync_engine_unref(engine);
  75
  76         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
  77
  78         destroy_testbed(testbed);
  79 }
  80 END_TEST
  81
  82 START_TEST (dual_connect_error)
  83 {
  84         char *testbed = setup_testbed("sync_easy_new");
  85
  86         g_setenv("CONNECT_ERROR", "3", TRUE);
  87
  88         OSyncError *error = NULL;
  89         OSyncGroup *group = osync_group_new(&error);
  90         fail_unless(group != NULL, NULL);
  91         fail_unless(error == NULL, NULL);
  92
  93         osync_group_set_schemadir(group, testbed);
  94         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
  95         fail_unless(error == NULL, NULL);
  96
  97         OSyncEngine *engine = osync_engine_new(group, &error);
  98         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
  99         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 100         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 101         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 102         fail_unless(osync_engine_initialize(engine, &error), NULL);
 103
 104         fail_unless(!synchronize_once(engine, &error), NULL);
 105         fail_unless(osync_error_is_set(&error), NULL);
 106
 107         fail_unless(num_client_errors == 2, NULL);
 108         fail_unless(num_client_connected == 0, NULL);
 109         fail_unless(num_client_disconnected == 0, NULL);
 110         fail_unless(num_engine_errors == 1, NULL);
 111
 112         osync_error_unref(&error);
 113         osync_engine_finalize(engine, &error);
 114         osync_engine_unref(engine);
 115
 116         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 117
 118         destroy_testbed(testbed);
 119 }
 120 END_TEST
 121
 122 START_TEST (one_of_two_connect_error)
 123 {
 124         char *testbed = setup_testbed("sync_easy_new");
 125
 126         g_setenv("CONNECT_ERROR", "1", TRUE);
 127
 128         OSyncError *error = NULL;
 129         OSyncGroup *group = osync_group_new(&error);
 130         fail_unless(group != NULL, NULL);
 131         fail_unless(error == NULL, NULL);
 132
 133         osync_group_set_schemadir(group, testbed);
 134         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 135         fail_unless(error == NULL, NULL);
 136
 137         OSyncEngine *engine = osync_engine_new(group, &error);
 138         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 139         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 140         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 141         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 142         fail_unless(osync_engine_initialize(engine, &error), NULL);
 143
 144         fail_unless(!synchronize_once(engine, &error), NULL);
 145         fail_unless(osync_error_is_set(&error), NULL);
 146
 147         fail_unless(num_client_errors == 1, NULL);
 148         fail_unless(num_client_connected == 1, NULL);
 149         fail_unless(num_client_disconnected == 1, NULL);
 150         //fail_unless(num_member_sent_changes == 0, NULL);
 151         fail_unless(num_engine_errors == 1, NULL);
 152
 153         osync_error_unref(&error);
 154         osync_engine_finalize(engine, &error);
 155         osync_engine_unref(engine);
 156
 157         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 158
 159         destroy_testbed(testbed);
 160 }
 161 END_TEST
 162
 163 START_TEST (two_of_three_connect_error)
 164 {
 165         char *testbed = setup_testbed("multisync_easy_new");
 166
 167         g_setenv("CONNECT_ERROR", "5", TRUE);
 168
 169         OSyncError *error = NULL;
 170         OSyncGroup *group = osync_group_new(&error);
 171         fail_unless(group != NULL, NULL);
 172         fail_unless(error == NULL, NULL);
 173
 174         osync_group_set_schemadir(group, testbed);
 175         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 176         fail_unless(error == NULL, NULL);
 177
 178         OSyncEngine *engine = osync_engine_new(group, &error);
 179         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 180         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 181         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 182         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 183         fail_unless(osync_engine_initialize(engine, &error), NULL);
 184
 185         fail_unless(!synchronize_once(engine, &error), NULL);
 186         fail_unless(osync_error_is_set(&error), NULL);
 187
 188         fail_unless(num_client_errors == 2, NULL);
 189         fail_unless(num_client_connected == 1, NULL);
 190         fail_unless(num_client_disconnected == 1, NULL);
 191         //fail_unless(num_member_sent_changes == 0, NULL);
 192         fail_unless(num_engine_errors == 1, NULL);
 193
 194         osync_error_unref(&error);
 195         osync_engine_finalize(engine, &error);
 196         osync_engine_unref(engine);
 197
 198         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 199
 200         destroy_testbed(testbed);
 201 }
 202 END_TEST
 203
 204 START_TEST (two_of_three_connect_error2)
 205 {
 206         char *testbed = setup_testbed("multisync_easy_new");
 207
 208         g_setenv("CONNECT_ERROR", "6", TRUE);
 209
 210         OSyncError *error = NULL;
 211         OSyncGroup *group = osync_group_new(&error);
 212         fail_unless(group != NULL, NULL);
 213         fail_unless(error == NULL, NULL);
 214
 215         osync_group_set_schemadir(group, testbed);
 216         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 217         fail_unless(error == NULL, NULL);
 218
 219         OSyncEngine *engine = osync_engine_new(group, &error);
 220         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 221         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 222         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 223         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 224         fail_unless(osync_engine_initialize(engine, &error), NULL);
 225
 226         fail_unless(!synchronize_once(engine, &error), NULL);
 227         fail_unless(osync_error_is_set(&error), NULL);
 228
 229         fail_unless(num_client_errors == 2, NULL);
 230         fail_unless(num_client_connected == 1, NULL);
 231         fail_unless(num_client_disconnected == 1, NULL);
 232         //fail_unless(num_member_sent_changes == 0, NULL);
 233         fail_unless(num_engine_errors == 1, NULL);
 234
 235         osync_error_unref(&error);
 236         osync_engine_finalize(engine, &error);
 237         osync_engine_unref(engine);
 238
 239         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 240
 241         destroy_testbed(testbed);
 242 }
 243 END_TEST
 244
 245 START_TEST (three_of_three_connect_error)
 246 {
 247         char *testbed = setup_testbed("multisync_easy_new");
 248
 249         g_setenv("CONNECT_ERROR", "7", TRUE);
 250
 251         OSyncError *error = NULL;
 252         OSyncGroup *group = osync_group_new(&error);
 253         fail_unless(group != NULL, NULL);
 254         fail_unless(error == NULL, NULL);
 255
 256         osync_group_set_schemadir(group, testbed);
 257         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 258         fail_unless(error == NULL, NULL);
 259
 260         OSyncEngine *engine = osync_engine_new(group, &error);
 261         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 262         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 263         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 264         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 265         fail_unless(osync_engine_initialize(engine, &error), NULL);
 266
 267         fail_unless(!synchronize_once(engine, &error), NULL);
 268         fail_unless(osync_error_is_set(&error), NULL);
 269
 270         fail_unless(num_client_errors == 3, NULL);
 271         fail_unless(num_client_connected == 0, NULL);
 272         fail_unless(num_client_disconnected == 0, NULL);
 273         //fail_unless(num_member_sent_changes == 0, NULL);
 274         fail_unless(num_engine_errors == 1, NULL);
 275
 276         osync_error_unref(&error);
 277         osync_engine_finalize(engine, &error);
 278         osync_engine_unref(engine);
 279
 280         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 281
 282         destroy_testbed(testbed);
 283 }
 284 END_TEST
 285
 286 START_TEST (one_of_three_connect_error)
 287 {
 288         char *testbed = setup_testbed("multisync_easy_new");
 289
 290         g_setenv("CONNECT_ERROR", "2", TRUE);
 291
 292         OSyncError *error = NULL;
 293         OSyncGroup *group = osync_group_new(&error);
 294         fail_unless(group != NULL, NULL);
 295         fail_unless(error == NULL, NULL);
 296
 297         osync_group_set_schemadir(group, testbed);
 298         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 299         fail_unless(error == NULL, NULL);
 300
 301         OSyncEngine *engine = osync_engine_new(group, &error);
 302         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 303         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 304         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 305         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 306         fail_unless(osync_engine_initialize(engine, &error), NULL);
 307
 308         fail_unless(!synchronize_once(engine, &error), NULL);
 309         fail_unless(osync_error_is_set(&error), NULL);
 310
 311         fail_unless(num_client_errors == 1, NULL);
 312         fail_unless(num_client_connected == 2, NULL);
 313         fail_unless(num_client_disconnected == 2, NULL);
 314         //fail_unless(num_member_sent_changes == 0, NULL);
 315         fail_unless(num_engine_errors == 1, NULL);
 316
 317         osync_error_unref(&error);
 318         osync_engine_finalize(engine, &error);
 319         osync_engine_unref(engine);
 320
 321         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 322
 323         destroy_testbed(testbed);
 324 }
 325 END_TEST
 326
 327 START_TEST (no_connect_error)
 328 {
 329         char *testbed = setup_testbed("multisync_easy_new");
 330
 331         g_setenv("CONNECT_ERROR", "0", TRUE);
 332
 333         OSyncError *error = NULL;
 334         OSyncGroup *group = osync_group_new(&error);
 335         fail_unless(group != NULL, NULL);
 336         fail_unless(error == NULL, NULL);
 337
 338         osync_group_set_schemadir(group, testbed);
 339         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 340         fail_unless(error == NULL, NULL);
 341
 342         OSyncEngine *engine = osync_engine_new(group, &error);
 343         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 344         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 345         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 346         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 347         fail_unless(osync_engine_initialize(engine, &error), NULL);
 348
 349         fail_unless(synchronize_once(engine, &error), NULL);
 350         fail_unless(!osync_error_is_set(&error), NULL);
 351
 352         fail_unless(num_client_errors == 0, NULL);
 353         fail_unless(num_client_connected == 3, NULL);
 354         fail_unless(num_client_disconnected == 3, NULL);
 355         //fail_unless(num_member_sent_changes == 3, NULL);
 356         fail_unless(num_engine_errors == 0, NULL);
 357         fail_unless(num_engine_successful == 1, NULL);
 358
 359         osync_engine_finalize(engine, &error);
 360         osync_engine_unref(engine);
 361
 362         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
 363         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
 364
 365         destroy_testbed(testbed);
 366 }
 367 END_TEST
 368
 369 START_TEST (single_connect_timeout)
 370 {
 371         char *testbed = setup_testbed("sync_easy_new");
 372
 373         g_setenv("CONNECT_TIMEOUT", "2", TRUE);
 374
 375         OSyncError *error = NULL;
 376         OSyncGroup *group = osync_group_new(&error);
 377         fail_unless(group != NULL, NULL);
 378         fail_unless(error == NULL, NULL);
 379
 380         osync_group_set_schemadir(group, testbed);
 381         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 382         fail_unless(error == NULL, NULL);
 383
 384         OSyncEngine *engine = osync_engine_new(group, &error);
 385         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 386         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 387         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 388         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 389         fail_unless(osync_engine_initialize(engine, &error), NULL);
 390
 391         fail_unless(!synchronize_once(engine, &error), NULL);
 392         fail_unless(osync_error_is_set(&error), NULL);
 393
 394         fail_unless(num_client_errors == 1, NULL);
 395         fail_unless(num_client_connected == 1, NULL);
 396         fail_unless(num_client_disconnected == 1, NULL);
 397         //fail_unless(num_member_sent_changes == 0, NULL);
 398         fail_unless(num_engine_errors == 1, NULL);
 399         fail_unless(num_engine_successful == 0, NULL);
 400
 401         osync_error_unref(&error);
 402         osync_engine_finalize(engine, &error);
 403         osync_engine_unref(engine);
 404
 405         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 406
 407         destroy_testbed(testbed);
 408 }
 409 END_TEST
 410
 411 START_TEST (dual_connect_timeout)
 412 {
 413         char *testbed = setup_testbed("sync_easy_new");
 414
 415         g_setenv("CONNECT_TIMEOUT", "3", TRUE);
 416
 417         OSyncError *error = NULL;
 418         OSyncGroup *group = osync_group_new(&error);
 419         fail_unless(group != NULL, NULL);
 420         fail_unless(error == NULL, NULL);
 421
 422         osync_group_set_schemadir(group, testbed);
 423         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 424         fail_unless(error == NULL, NULL);
 425
 426         OSyncEngine *engine = osync_engine_new(group, &error);
 427         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 428         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 429         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 430         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 431         fail_unless(osync_engine_initialize(engine, &error), NULL);
 432
 433         fail_unless(!synchronize_once(engine, &error), NULL);
 434         fail_unless(osync_error_is_set(&error), NULL);
 435
 436         fail_unless(num_client_errors == 2, NULL);
 437         fail_unless(num_client_connected == 0, NULL);
 438         fail_unless(num_client_disconnected == 0, NULL);
 439         //fail_unless(num_member_sent_changes == 0, NULL);
 440         fail_unless(num_engine_errors == 1, NULL);
 441         fail_unless(num_engine_successful == 0, NULL);
 442
 443         osync_error_unref(&error);
 444         osync_engine_finalize(engine, &error);
 445         osync_engine_unref(engine);
 446
 447         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 448
 449         destroy_testbed(testbed);
 450 }
 451 END_TEST
 452
 453 START_TEST (one_of_three_timeout)
 454 {
 455         char *testbed = setup_testbed("multisync_easy_new");
 456
 457         g_setenv("CONNECT_TIMEOUT", "2", TRUE);
 458
 459         OSyncError *error = NULL;
 460         OSyncGroup *group = osync_group_new(&error);
 461         fail_unless(group != NULL, NULL);
 462         fail_unless(error == NULL, NULL);
 463
 464         osync_group_set_schemadir(group, testbed);
 465         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 466         fail_unless(error == NULL, NULL);
 467
 468         OSyncEngine *engine = osync_engine_new(group, &error);
 469         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 470         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 471         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 472         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 473         fail_unless(osync_engine_initialize(engine, &error), NULL);
 474
 475         fail_unless(!synchronize_once(engine, &error), NULL);
 476         fail_unless(osync_error_is_set(&error), NULL);
 477
 478         fail_unless(num_client_errors == 1, NULL);
 479         fail_unless(num_client_connected == 2, NULL);
 480         fail_unless(num_client_disconnected == 2, NULL);
 481         //fail_unless(num_member_sent_changes == 0, NULL);
 482         fail_unless(num_engine_errors == 1, NULL);
 483         fail_unless(num_engine_successful == 0, NULL);
 484
 485         osync_error_unref(&error);
 486         osync_engine_finalize(engine, &error);
 487         osync_engine_unref(engine);
 488
 489         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 490
 491         destroy_testbed(testbed);
 492 }
 493 END_TEST
 494
 495 START_TEST (timeout_and_error)
 496 {
 497         char *testbed = setup_testbed("multisync_easy_new");
 498
 499         g_setenv("CONNECT_TIMEOUT", "2", TRUE);
 500         g_setenv("CONNECT_ERROR", "4", TRUE);
 501
 502         OSyncError *error = NULL;
 503         OSyncGroup *group = osync_group_new(&error);
 504         fail_unless(group != NULL, NULL);
 505         fail_unless(error == NULL, NULL);
 506
 507         osync_group_set_schemadir(group, testbed);
 508         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 509         fail_unless(error == NULL, NULL);
 510
 511         OSyncEngine *engine = osync_engine_new(group, &error);
 512         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 513         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 514         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 515         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 516         fail_unless(osync_engine_initialize(engine, &error), NULL);
 517
 518         fail_unless(!synchronize_once(engine, &error), NULL);
 519         fail_unless(osync_error_is_set(&error), NULL);
 520
 521         fail_unless(num_client_errors == 2, NULL);
 522         fail_unless(num_client_connected == 1, NULL);
 523         fail_unless(num_client_disconnected == 1, NULL);
 524         //fail_unless(num_member_sent_changes == 0, NULL);
 525         fail_unless(num_engine_errors == 1, NULL);
 526         fail_unless(num_engine_successful == 0, NULL);
 527
 528         osync_error_unref(&error);
 529         osync_engine_finalize(engine, &error);
 530         osync_engine_unref(engine);
 531
 532         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 533
 534         destroy_testbed(testbed);
 535 }
 536 END_TEST
 537
 538 START_TEST (single_get_changes_error)
 539 {
 540         char *testbed = setup_testbed("sync_easy_conflict");
 541
 542         g_setenv("GET_CHANGES_ERROR", "2", TRUE);
 543         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
 544
 545         OSyncError *error = NULL;
 546         OSyncGroup *group = osync_group_new(&error);
 547         fail_unless(group != NULL, NULL);
 548         fail_unless(error == NULL, NULL);
 549
 550         osync_group_set_schemadir(group, testbed);
 551         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 552         fail_unless(error == NULL, NULL);
 553
 554         OSyncEngine *engine = osync_engine_new(group, &error);
 555         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 556         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 557         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 558         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 559         fail_unless(osync_engine_initialize(engine, &error), NULL);
 560
 561         fail_unless(!synchronize_once(engine, &error), NULL);
 562         fail_unless(osync_error_is_set(&error), NULL);
 563
 564         fail_unless(num_client_errors == 0, NULL);
 565         fail_unless(num_client_connected == 2, NULL);
 566         fail_unless(num_client_disconnected == 2, NULL);
 567         //fail_unless(num_member_get_changes_errors == 1, NULL);
 568         fail_unless(num_client_written == 0, NULL);
 569         //fail_unless(num_conflicts == 0, NULL);
 570         fail_unless(num_engine_errors == 1, NULL);
 571         fail_unless(num_engine_successful == 0, NULL);
 572
 573         osync_error_unref(&error);
 574         osync_engine_finalize(engine, &error);
 575         osync_engine_unref(engine);
 576
 577         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 578
 579         destroy_testbed(testbed);
 580 }
 581 END_TEST
 582
 583 START_TEST (dual_get_changes_error)
 584 {
 585         char *testbed = setup_testbed("sync_easy_conflict");
 586
 587         g_setenv("GET_CHANGES_ERROR", "3", TRUE);
 588
 589         OSyncError *error = NULL;
 590         OSyncGroup *group = osync_group_new(&error);
 591         fail_unless(group != NULL, NULL);
 592         fail_unless(error == NULL, NULL);
 593
 594         osync_group_set_schemadir(group, testbed);
 595         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 596         fail_unless(error == NULL, NULL);
 597
 598         OSyncEngine *engine = osync_engine_new(group, &error);
 599         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 600         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 601         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 602         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 603         fail_unless(osync_engine_initialize(engine, &error), NULL);
 604
 605         fail_unless(!synchronize_once(engine, &error), NULL);
 606         fail_unless(osync_error_is_set(&error), NULL);
 607
 608         fail_unless(num_client_errors == 0, NULL);
 609         fail_unless(num_client_connected == 2, NULL);
 610         fail_unless(num_client_disconnected == 2, NULL);
 611         //fail_unless(num_member_sent_changes == 0, NULL);
 612         fail_unless(num_client_read == 0, NULL);
 613         fail_unless(num_client_written == 0, NULL);
 614         //fail_unless(num_conflicts == 0, NULL);
 615         fail_unless(num_engine_errors == 1, NULL);
 616         fail_unless(num_engine_successful == 0, NULL);
 617
 618         osync_error_unref(&error);
 619         osync_engine_finalize(engine, &error);
 620         osync_engine_unref(engine);
 621
 622         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 623
 624         destroy_testbed(testbed);
 625 }
 626 END_TEST
 627
 628 START_TEST (two_of_three_get_changes_error)
 629 {
 630         char *testbed = setup_testbed("multisync_conflict_data_choose2");
 631
 632         g_setenv("GET_CHANGES_ERROR", "5", TRUE);
 633         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
 634
 635         OSyncError *error = NULL;
 636         OSyncGroup *group = osync_group_new(&error);
 637         fail_unless(group != NULL, NULL);
 638         fail_unless(error == NULL, NULL);
 639
 640         osync_group_set_schemadir(group, testbed);
 641         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 642         fail_unless(error == NULL, NULL);
 643
 644         OSyncEngine *engine = osync_engine_new(group, &error);
 645         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 646         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 647         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 648         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 649         fail_unless(osync_engine_initialize(engine, &error), NULL);
 650
 651         fail_unless(!synchronize_once(engine, &error), NULL);
 652         fail_unless(osync_error_is_set(&error), NULL);
 653
 654         fail_unless(num_client_errors == 0, NULL);
 655         fail_unless(num_client_connected == 3, NULL);
 656         fail_unless(num_client_disconnected == 3, NULL);
 657         fail_unless(num_client_written == 0, NULL);
 658         //fail_unless(num_conflicts == 0, NULL);
 659         fail_unless(num_engine_errors == 1, NULL);
 660         fail_unless(num_engine_successful == 0, NULL);
 661
 662         osync_error_unref(&error);
 663         osync_engine_finalize(engine, &error);
 664         osync_engine_unref(engine);
 665
 666         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 667
 668         destroy_testbed(testbed);
 669 }
 670 END_TEST
 671
 672 START_TEST (one_of_three_get_changes_error)
 673 {
 674         char *testbed = setup_testbed("multisync_conflict_data_choose2");
 675
 676         g_setenv("GET_CHANGES_ERROR", "1", TRUE);
 677         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
 678
 679         OSyncError *error = NULL;
 680         OSyncGroup *group = osync_group_new(&error);
 681         fail_unless(group != NULL, NULL);
 682         fail_unless(error == NULL, NULL);
 683
 684         osync_group_set_schemadir(group, testbed);
 685         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 686         fail_unless(error == NULL, NULL);
 687
 688         OSyncEngine *engine = osync_engine_new(group, &error);
 689         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 690         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 691         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 692         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 693         fail_unless(osync_engine_initialize(engine, &error), NULL);
 694
 695         fail_unless(!synchronize_once(engine, &error), NULL);
 696         fail_unless(osync_error_is_set(&error), NULL);
 697
 698         fail_unless(num_client_errors == 0, NULL);
 699         fail_unless(num_client_connected == 3, NULL);
 700         fail_unless(num_client_disconnected == 3, NULL);
 701         //fail_unless(num_member_get_changes_errors == 1, NULL);
 702         fail_unless(num_client_written == 0, NULL);
 703         //fail_unless(num_conflicts == 0, NULL);
 704         fail_unless(num_engine_errors == 1, NULL);
 705         fail_unless(num_engine_successful == 0, NULL);
 706
 707         osync_error_unref(&error);
 708         osync_engine_finalize(engine, &error);
 709         osync_engine_unref(engine);
 710
 711         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 712
 713         destroy_testbed(testbed);
 714 }
 715 END_TEST
 716
 717 START_TEST (one_of_three_get_changes_timeout)
 718 {
 719         char *testbed = setup_testbed("multisync_conflict_data_choose2");
 720
 721         g_setenv("GET_CHANGES_TIMEOUT", "1", TRUE);
 722         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
 723
 724         OSyncError *error = NULL;
 725         OSyncGroup *group = osync_group_new(&error);
 726         fail_unless(group != NULL, NULL);
 727         fail_unless(error == NULL, NULL);
 728
 729         osync_group_set_schemadir(group, testbed);
 730         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 731         fail_unless(error == NULL, NULL);
 732
 733         OSyncEngine *engine = osync_engine_new(group, &error);
 734         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 735         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 736         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 737         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 738         fail_unless(osync_engine_initialize(engine, &error), NULL);
 739
 740         fail_unless(!synchronize_once(engine, &error), NULL);
 741         fail_unless(osync_error_is_set(&error), NULL);
 742
 743         fail_unless(num_client_errors == 0, NULL);
 744         fail_unless(num_client_connected == 3, NULL);
 745         fail_unless(num_client_disconnected == 3, NULL);
 746         //fail_unless(num_member_get_changes_errors == 1, NULL);
 747         //fail_unless(num_member_sent_changes == 2, NULL);
 748         fail_unless(num_client_read == 2, NULL);
 749         fail_unless(num_client_written == 0, NULL);
 750         //fail_unless(num_conflicts == 0, NULL);
 751         fail_unless(num_engine_errors == 1, NULL);
 752         fail_unless(num_engine_successful == 0, NULL);
 753
 754         osync_error_unref(&error);
 755         osync_engine_finalize(engine, &error);
 756         osync_engine_unref(engine);
 757
 758         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 759
 760         destroy_testbed(testbed);
 761 }
 762 END_TEST
 763
 764 START_TEST (get_changes_timeout_and_error)
 765 {
 766         char *testbed = setup_testbed("multisync_conflict_data_choose2");
 767
 768         g_setenv("GET_CHANGES_TIMEOUT", "3", TRUE);
 769         g_setenv("GET_CHANGES_ERROR", "4", TRUE);
 770
 771         OSyncError *error = NULL;
 772         OSyncGroup *group = osync_group_new(&error);
 773         fail_unless(group != NULL, NULL);
 774         fail_unless(error == NULL, NULL);
 775
 776         osync_group_set_schemadir(group, testbed);
 777         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 778         fail_unless(error == NULL, NULL);
 779
 780         OSyncEngine *engine = osync_engine_new(group, &error);
 781         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 782         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 783         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 784         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 785         fail_unless(osync_engine_initialize(engine, &error), NULL);
 786
 787         fail_unless(!synchronize_once(engine, &error), NULL);
 788         fail_unless(osync_error_is_set(&error), NULL);
 789
 790         fail_unless(num_client_errors == 0, NULL);
 791         fail_unless(num_client_connected == 3, NULL);
 792         fail_unless(num_client_disconnected == 3, NULL);
 793         //fail_unless(num_member_sent_changes == 0, NULL);
 794         fail_unless(num_client_read == 0, NULL);
 795         fail_unless(num_client_written == 0, NULL);
 796         //fail_unless(num_conflicts == 0, NULL);
 797         fail_unless(num_engine_errors == 1, NULL);
 798         fail_unless(num_engine_successful == 0, NULL);
 799
 800         osync_error_unref(&error);
 801         osync_engine_finalize(engine, &error);
 802         osync_engine_unref(engine);
 803
 804         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 805
 806         destroy_testbed(testbed);
 807 }
 808 END_TEST
 809
 810 START_TEST (get_changes_timeout_sleep)
 811 {
 812         char *testbed = setup_testbed("multisync_conflict_data_choose2");
 813
 814         g_setenv("GET_CHANGES_TIMEOUT2", "7", TRUE);
 815         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
 816
 817         OSyncError *error = NULL;
 818         OSyncGroup *group = osync_group_new(&error);
 819         fail_unless(group != NULL, NULL);
 820         fail_unless(error == NULL, NULL);
 821
 822         osync_group_set_schemadir(group, testbed);
 823         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 824         fail_unless(error == NULL, NULL);
 825
 826         OSyncEngine *engine = osync_engine_new(group, &error);
 827         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 828         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 829         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 830         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 831         fail_unless(osync_engine_initialize(engine, &error), NULL);
 832
 833         fail_unless(!synchronize_once(engine, &error), NULL);
 834         fail_unless(osync_error_is_set(&error), NULL);
 835
 836         mark_point();
 837         osync_error_unref(&error);
 838         mark_point();
 839         osync_engine_finalize(engine, &error);
 840         mark_point();
 841         osync_engine_unref(engine);
 842
 843         fail_unless(num_client_errors == 0, NULL);
 844         fail_unless(num_client_connected == 3, NULL);
 845         fail_unless(num_client_disconnected == 3, NULL);
 846         //fail_unless(num_member_sent_changes == 0, NULL);
 847         fail_unless(num_client_read == 0, NULL);
 848         fail_unless(num_client_written == 0, NULL);
 849         //fail_unless(num_conflicts == 0, NULL);
 850         fail_unless(num_engine_errors == 1, NULL);
 851         fail_unless(num_engine_successful == 0, NULL);
 852
 853         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 854
 855         destroy_testbed(testbed);
 856 }
 857 END_TEST
 858
 859 START_TEST (single_commit_error)
 860 {
 861         char *testbed = setup_testbed("multisync_easy_new");
 862
 863         g_setenv("COMMIT_ERROR", "4", TRUE);
 864
 865         OSyncError *error = NULL;
 866         OSyncGroup *group = osync_group_new(&error);
 867         fail_unless(group != NULL, NULL);
 868         fail_unless(error == NULL, NULL);
 869
 870         osync_group_set_schemadir(group, testbed);
 871         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 872         fail_unless(error == NULL, NULL);
 873
 874         OSyncEngine *engine = osync_engine_new(group, &error);
 875         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 876         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 877         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 878         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
 879         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 880         fail_unless(osync_engine_initialize(engine, &error), NULL);
 881
 882         fail_unless(!synchronize_once(engine, &error), NULL);
 883         fail_unless(osync_error_is_set(&error), NULL);
 884
 885         mark_point();
 886         osync_error_unref(&error);
 887         mark_point();
 888         osync_engine_finalize(engine, &error);
 889         mark_point();
 890         osync_engine_unref(engine);
 891
 892         fail_unless(num_client_errors == 0, NULL);
 893         fail_unless(num_client_connected == 3, NULL);
 894         fail_unless(num_client_disconnected == 3, NULL);
 895         //fail_unless(num_member_sent_changes == 3, NULL);
 896         fail_unless(num_client_read == 1, NULL);
 897         fail_unless(num_client_written == 1, NULL);
 898         //fail_unless(num_written_errors == 1, NULL);
 899         fail_unless(num_mapping_errors == 1, NULL);
 900         //fail_unless(num_conflicts == 0, NULL);
 901         fail_unless(num_engine_errors == 1, NULL);
 902         fail_unless(num_engine_successful == 0, NULL);
 903
 904         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
 905         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
 906
 907         destroy_testbed(testbed);
 908 }
 909 END_TEST
 910
 911 START_TEST (dual_commit_error)
 912 {
 913         char *testbed = setup_testbed("multisync_easy_new");
 914
 915         g_setenv("COMMIT_ERROR", "6", TRUE);
 916
 917         OSyncError *error = NULL;
 918         OSyncGroup *group = osync_group_new(&error);
 919         fail_unless(group != NULL, NULL);
 920         fail_unless(error == NULL, NULL);
 921
 922         osync_group_set_schemadir(group, testbed);
 923         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 924         fail_unless(error == NULL, NULL);
 925
 926         OSyncEngine *engine = osync_engine_new(group, &error);
 927         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 928         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 929         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 930         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
 931         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 932         fail_unless(osync_engine_initialize(engine, &error), NULL);
 933
 934         fail_unless(!synchronize_once(engine, &error), NULL);
 935         fail_unless(osync_error_is_set(&error), NULL);
 936
 937         mark_point();
 938         osync_error_unref(&error);
 939         mark_point();
 940         osync_engine_finalize(engine, &error);
 941         mark_point();
 942         osync_engine_unref(engine);
 943
 944         fail_unless(num_client_errors == 0, NULL);
 945         fail_unless(num_client_connected == 3, NULL);
 946         fail_unless(num_client_disconnected == 3, NULL);
 947         //fail_unless(num_member_sent_changes == 3, NULL);
 948         fail_unless(num_client_read == 1, NULL);
 949         fail_unless(num_client_written == 0, NULL);
 950         //fail_unless(num_written_errors == 2, NULL);
 951         fail_unless(num_mapping_errors == 2, NULL);
 952         //fail_unless(num_conflicts == 0, NULL);
 953         fail_unless(num_engine_errors == 1, NULL);
 954         fail_unless(num_engine_successful == 0, NULL);
 955
 956         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
 957         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
 958
 959         destroy_testbed(testbed);
 960 }
 961 END_TEST
 962
 963 START_TEST (single_commit_timeout)
 964 {
 965         char *testbed = setup_testbed("multisync_easy_new");
 966
 967         g_setenv("COMMIT_TIMEOUT", "4", TRUE);
 968
 969         OSyncError *error = NULL;
 970         OSyncGroup *group = osync_group_new(&error);
 971         fail_unless(group != NULL, NULL);
 972         fail_unless(error == NULL, NULL);
 973
 974         osync_group_set_schemadir(group, testbed);
 975         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
 976         fail_unless(error == NULL, NULL);
 977
 978         OSyncEngine *engine = osync_engine_new(group, &error);
 979         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
 980         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
 981         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
 982         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
 983         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
 984         fail_unless(osync_engine_initialize(engine, &error), NULL);
 985
 986         fail_unless(!synchronize_once(engine, &error), NULL);
 987         fail_unless(osync_error_is_set(&error), NULL);
 988
 989         mark_point();
 990         osync_error_unref(&error);
 991         mark_point();
 992         osync_engine_finalize(engine, &error);
 993         mark_point();
 994         osync_engine_unref(engine);
 995
 996         fail_unless(num_client_errors == 0, NULL);
 997         fail_unless(num_client_connected == 3, NULL);
 998         fail_unless(num_client_disconnected == 3, NULL);
 999         //fail_unless(num_member_sent_changes == 3, NULL);
1000         fail_unless(num_client_read == 1, NULL);
1001         fail_unless(num_client_written == 1, NULL);
1002         //fail_unless(num_written_errors == 1, NULL);
1003         fail_unless(num_mapping_errors == 1, NULL);
1004         //fail_unless(num_conflicts == 0, NULL);
1005         fail_unless(num_engine_errors == 1, NULL);
1006         fail_unless(num_engine_successful == 0, NULL);
1007
1008         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1009         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
1010
1011         destroy_testbed(testbed);
1012 }
1013 END_TEST
1014
1015 START_TEST (dual_commit_timeout)
1016 {
1017         char *testbed = setup_testbed("multisync_easy_new");
1018
1019         g_setenv("COMMIT_TIMEOUT", "6", TRUE);
1020
1021         OSyncError *error = NULL;
1022         OSyncGroup *group = osync_group_new(&error);
1023         fail_unless(group != NULL, NULL);
1024         fail_unless(error == NULL, NULL);
1025
1026         osync_group_set_schemadir(group, testbed);
1027         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1028         fail_unless(error == NULL, NULL);
1029
1030         OSyncEngine *engine = osync_engine_new(group, &error);
1031         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1032         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1033         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1034         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1035         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1036         fail_unless(osync_engine_initialize(engine, &error), NULL);
1037
1038         fail_unless(!synchronize_once(engine, &error), NULL);
1039         fail_unless(osync_error_is_set(&error), NULL);
1040
1041         mark_point();
1042         osync_error_unref(&error);
1043         mark_point();
1044         osync_engine_finalize(engine, &error);
1045         mark_point();
1046         osync_engine_unref(engine);
1047
1048         fail_unless(num_client_errors == 0, NULL);
1049         fail_unless(num_client_connected == 3, NULL);
1050         fail_unless(num_client_disconnected == 3, NULL);
1051         //fail_unless(num_member_sent_changes == 3, NULL);
1052         fail_unless(num_client_read == 1, NULL);
1053         fail_unless(num_client_written == 0, NULL);
1054         //fail_unless(num_written_errors == 2, NULL);
1055         fail_unless(num_mapping_errors == 2, NULL);
1056         //fail_unless(num_conflicts == 0, NULL);
1057         fail_unless(num_engine_errors == 1, NULL);
1058         fail_unless(num_engine_successful == 0, NULL);
1059
1060         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1061         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
1062
1063         destroy_testbed(testbed);
1064 }
1065 END_TEST
1066
1067 START_TEST (commit_timeout_and_error)
1068 {
1069         char *testbed = setup_testbed("multisync_easy_new");
1070
1071         g_setenv("COMMIT_TIMEOUT", "4", TRUE);
1072         g_setenv("COMMIT_ERROR", "2", TRUE);
1073
1074         OSyncError *error = NULL;
1075         OSyncGroup *group = osync_group_new(&error);
1076         fail_unless(group != NULL, NULL);
1077         fail_unless(error == NULL, NULL);
1078
1079         osync_group_set_schemadir(group, testbed);
1080         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1081         fail_unless(error == NULL, NULL);
1082
1083         OSyncEngine *engine = osync_engine_new(group, &error);
1084         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1085         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1086         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1087         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1088         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1089         fail_unless(osync_engine_initialize(engine, &error), NULL);
1090
1091         fail_unless(!synchronize_once(engine, &error), NULL);
1092         fail_unless(osync_error_is_set(&error), NULL);
1093
1094         mark_point();
1095         osync_error_unref(&error);
1096         mark_point();
1097         osync_engine_finalize(engine, &error);
1098         mark_point();
1099         osync_engine_unref(engine);
1100
1101         fail_unless(num_client_errors == 0, NULL);
1102         fail_unless(num_client_connected == 3, NULL);
1103         fail_unless(num_client_disconnected == 3, NULL);
1104         //fail_unless(num_member_sent_changes == 3, NULL);
1105         fail_unless(num_client_read == 1, NULL);
1106         fail_unless(num_client_written == 0, NULL);
1107         //fail_unless(num_written_errors == 2, NULL);
1108         fail_unless(num_mapping_errors == 2, NULL);
1109         //fail_unless(num_conflicts == 0, NULL);
1110         fail_unless(num_engine_errors == 1, NULL);
1111         fail_unless(num_engine_successful == 0, NULL);
1112
1113         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1114         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
1115
1116         destroy_testbed(testbed);
1117 }
1118 END_TEST
1119
1120 START_TEST (commit_timeout_and_error2)
1121 {
1122         char *testbed = setup_testbed("multisync_easy_new");
1123
1124         g_setenv("COMMIT_TIMEOUT", "2", TRUE);
1125         g_setenv("COMMIT_ERROR", "4", TRUE);
1126
1127         OSyncError *error = NULL;
1128         OSyncGroup *group = osync_group_new(&error);
1129         fail_unless(group != NULL, NULL);
1130         fail_unless(error == NULL, NULL);
1131
1132         osync_group_set_schemadir(group, testbed);
1133         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1134         fail_unless(error == NULL, NULL);
1135
1136         OSyncEngine *engine = osync_engine_new(group, &error);
1137         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1138         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1139         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1140         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1141         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1142         fail_unless(osync_engine_initialize(engine, &error), NULL);
1143
1144         fail_unless(!synchronize_once(engine, &error), NULL);
1145         fail_unless(osync_error_is_set(&error), NULL);
1146
1147         mark_point();
1148         osync_error_unref(&error);
1149         mark_point();
1150         osync_engine_finalize(engine, &error);
1151         mark_point();
1152         osync_engine_unref(engine);
1153
1154         fail_unless(num_client_errors == 0, NULL);
1155         fail_unless(num_client_connected == 3, NULL);
1156         fail_unless(num_client_disconnected == 3, NULL);
1157         //fail_unless(num_member_sent_changes == 3, NULL);
1158         fail_unless(num_client_read == 1, NULL);
1159         fail_unless(num_client_written == 0, NULL);
1160         //fail_unless(num_written_errors == 2, NULL);
1161         fail_unless(num_mapping_errors == 2, NULL);
1162         //fail_unless(num_conflicts == 0, NULL);
1163         fail_unless(num_engine_errors == 1, NULL);
1164         fail_unless(num_engine_successful == 0, NULL);
1165
1166         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1167         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
1168
1169         destroy_testbed(testbed);
1170 }
1171 END_TEST
1172
1173 START_TEST (commit_error_modify)
1174 {
1175         char *testbed = setup_testbed("multisync_easy_new");
1176
1177         OSyncError *error = NULL;
1178         OSyncGroup *group = osync_group_new(&error);
1179         fail_unless(group != NULL, NULL);
1180         fail_unless(error == NULL, NULL);
1181
1182         osync_group_set_schemadir(group, testbed);
1183         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1184         fail_unless(error == NULL, NULL);
1185
1186         OSyncEngine *engine = osync_engine_new(group, &error);
1187         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1188         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1189         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1190         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1191         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1192         fail_unless(osync_engine_initialize(engine, &error), NULL);
1193
1194         fail_unless(synchronize_once(engine, &error), NULL);
1195         fail_unless(!osync_error_is_set(&error), NULL);
1196
1197         g_setenv("COMMIT_TIMEOUT", "2", TRUE);
1198         g_setenv("COMMIT_ERROR", "4", TRUE);
1199
1200         g_usleep(2*G_USEC_PER_SEC);
1201
1202         osync_testing_system_abort("cp newdata2 data1/testdata");
1203
1204         fail_unless(!synchronize_once(engine, &error), NULL);
1205         fail_unless(osync_error_is_set(&error), NULL);
1206
1207         mark_point();
1208         osync_error_unref(&error);
1209         mark_point();
1210         osync_engine_finalize(engine, &error);
1211         mark_point();
1212         osync_engine_unref(engine);
1213
1214         fail_unless(num_client_errors == 0, NULL);
1215         fail_unless(num_client_connected == 3, NULL);
1216         fail_unless(num_client_disconnected == 3, NULL);
1217         //fail_unless(num_member_sent_changes == 3, NULL);
1218         fail_unless(num_client_read == 1, NULL);
1219         fail_unless(num_client_written == 0, NULL);
1220         //fail_unless(num_written_errors == 2, NULL);
1221         fail_unless(num_mapping_errors == 2, NULL);
1222         //fail_unless(num_conflicts == 0, NULL);
1223         fail_unless(num_engine_errors == 1, NULL);
1224         fail_unless(num_engine_successful == 0, NULL);
1225
1226         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1227         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
1228         fail_unless(!system("test \"x$(diff -x \".*\" data2 data3)\" == \"x\""), NULL);
1229
1230         destroy_testbed(testbed);
1231 }
1232 END_TEST
1233
1234 START_TEST (commit_error_delete)
1235 {
1236         char *testbed = setup_testbed("multisync_easy_new");
1237
1238         OSyncError *error = NULL;
1239         OSyncGroup *group = osync_group_new(&error);
1240         fail_unless(group != NULL, NULL);
1241         fail_unless(error == NULL, NULL);
1242
1243         osync_group_set_schemadir(group, testbed);
1244         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1245         fail_unless(error == NULL, NULL);
1246
1247         OSyncEngine *engine = osync_engine_new(group, &error);
1248         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1249         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1250         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1251         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1252         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1253         fail_unless(osync_engine_initialize(engine, &error), NULL);
1254
1255         fail_unless(synchronize_once(engine, &error), NULL);
1256         fail_unless(!osync_error_is_set(&error), NULL);
1257
1258         g_setenv("COMMIT_TIMEOUT", "2", TRUE);
1259         g_setenv("COMMIT_ERROR", "4", TRUE);
1260
1261         g_usleep(2*G_USEC_PER_SEC);
1262
1263         osync_testing_system_abort("rm -f data1/testdata");
1264
1265         fail_unless(!synchronize_once(engine, &error), NULL);
1266         fail_unless(osync_error_is_set(&error), NULL);
1267
1268         mark_point();
1269         osync_error_unref(&error);
1270         mark_point();
1271         osync_engine_finalize(engine, &error);
1272         mark_point();
1273         osync_engine_unref(engine);
1274
1275         fail_unless(num_client_errors == 0, NULL);
1276         fail_unless(num_client_connected == 3, NULL);
1277         fail_unless(num_client_disconnected == 3, NULL);
1278         //fail_unless(num_member_sent_changes == 3, NULL);
1279         fail_unless(num_client_read == 1, NULL);
1280         fail_unless(num_client_written == 0, NULL);
1281         //fail_unless(num_written_errors == 2, NULL);
1282         fail_unless(num_mapping_errors == 2, NULL);
1283         //fail_unless(num_conflicts == 0, NULL);
1284         fail_unless(num_engine_errors == 1, NULL);
1285         fail_unless(num_engine_successful == 0, NULL);
1286
1287         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
1288         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
1289         fail_unless(!system("test \"x$(diff -x \".*\" data2 data3)\" == \"x\""), NULL);
1290
1291         destroy_testbed(testbed);
1292 }
1293 END_TEST
1294
1295 START_TEST (committed_all_error)
1296 {
1297         char *testbed = setup_testbed("multisync_easy_new");
1298
1299         g_setenv("COMMITTED_ALL_ERROR", "3", TRUE);
1300
1301         OSyncError *error = NULL;
1302         OSyncGroup *group = osync_group_new(&error);
1303         fail_unless(group != NULL, NULL);
1304         fail_unless(error == NULL, NULL);
1305
1306         osync_group_set_schemadir(group, testbed);
1307         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1308         fail_unless(error == NULL, NULL);
1309
1310         OSyncEngine *engine = osync_engine_new(group, &error);
1311         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1312         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1313         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1314         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1315         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1316         fail_unless(osync_engine_initialize(engine, &error), NULL);
1317
1318         fail_unless(!synchronize_once(engine, &error), NULL);
1319         fail_unless(osync_error_is_set(&error), NULL);
1320
1321         mark_point();
1322         osync_error_unref(&error);
1323         mark_point();
1324         osync_engine_finalize(engine, &error);
1325         mark_point();
1326         osync_engine_unref(engine);
1327
1328         fail_unless(num_client_errors == 0, NULL);
1329         fail_unless(num_client_connected == 3, NULL);
1330         fail_unless(num_client_disconnected == 3, NULL);
1331         //fail_unless(num_member_sent_changes == 3, NULL);
1332         fail_unless(num_client_read == 1, NULL);
1333         fail_unless(num_client_written == 2, NULL);
1334         //fail_unless(num_written_errors == 0, NULL);
1335         fail_unless(num_mapping_errors == 0, NULL);
1336         //fail_unless(num_conflicts == 0, NULL);
1337         fail_unless(num_engine_errors == 1, NULL);
1338         fail_unless(num_engine_successful == 0, NULL);
1339
1340         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" = \"x\""), NULL);
1341         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" = \"x\""), NULL);
1342
1343         destroy_testbed(testbed);
1344 }
1345 END_TEST
1346
1347 START_TEST (committed_all_batch_error)
1348 {
1349         char *testbed = setup_testbed("multisync_easy_new");
1350
1351         g_setenv("BATCH_COMMIT", "7", TRUE);
1352         g_setenv("COMMITTED_ALL_ERROR", "3", TRUE);
1353
1354         OSyncError *error = NULL;
1355         OSyncGroup *group = osync_group_new(&error);
1356         fail_unless(group != NULL, NULL);
1357         fail_unless(error == NULL, NULL);
1358
1359         osync_group_set_schemadir(group, testbed);
1360         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1361         fail_unless(error == NULL, NULL);
1362
1363         OSyncEngine *engine = osync_engine_new(group, &error);
1364         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1365         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1366         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1367         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1368         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1369         fail_unless(osync_engine_initialize(engine, &error), NULL);
1370
1371         fail_unless(!synchronize_once(engine, &error), NULL);
1372         fail_unless(osync_error_is_set(&error), NULL);
1373
1374         mark_point();
1375         osync_error_unref(&error);
1376         mark_point();
1377         osync_engine_finalize(engine, &error);
1378         mark_point();
1379         osync_engine_unref(engine);
1380
1381         fail_unless(num_client_errors == 0, NULL);
1382         fail_unless(num_client_connected == 3, NULL);
1383         fail_unless(num_client_disconnected == 3, NULL);
1384         //fail_unless(num_member_sent_changes == 3, NULL);
1385         fail_unless(num_client_read == 1, NULL);
1386         fail_unless(num_client_written == 2, NULL);
1387         //fail_unless(num_written_errors == 0, NULL);
1388         fail_unless(num_mapping_errors == 0, NULL);
1389         //fail_unless(num_conflicts == 0, NULL);
1390         fail_unless(num_engine_errors == 1, NULL);
1391         fail_unless(num_engine_successful == 0, NULL);
1392
1393         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" = \"x\""), NULL);
1394         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" = \"x\""), NULL);
1395
1396         destroy_testbed(testbed);
1397 }
1398 END_TEST
1399
1400 START_TEST (single_sync_done_error)
1401 {
1402         char *testbed = setup_testbed("multisync_easy_new");
1403
1404         g_setenv("SYNC_DONE_ERROR", "4", TRUE);
1405
1406         OSyncError *error = NULL;
1407         OSyncGroup *group = osync_group_new(&error);
1408         fail_unless(group != NULL, NULL);
1409         fail_unless(error == NULL, NULL);
1410
1411         osync_group_set_schemadir(group, testbed);
1412         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1413         fail_unless(error == NULL, NULL);
1414
1415         OSyncEngine *engine = osync_engine_new(group, &error);
1416         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1417         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1418         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1419         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1420         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1421         fail_unless(osync_engine_initialize(engine, &error), NULL);
1422
1423         fail_unless(!synchronize_once(engine, &error), NULL);
1424         fail_unless(osync_error_is_set(&error), NULL);
1425
1426         mark_point();
1427         osync_error_unref(&error);
1428         mark_point();
1429         osync_engine_finalize(engine, &error);
1430         mark_point();
1431         osync_engine_unref(engine);
1432
1433         fail_unless(num_client_errors == 0, NULL);
1434         fail_unless(num_client_connected == 3, NULL);
1435         fail_unless(num_client_disconnected == 3, NULL);
1436         //fail_unless(num_member_sent_changes == 3, NULL);
1437         fail_unless(num_client_read == 1, NULL);
1438         fail_unless(num_client_written == 2, NULL);
1439         //fail_unless(num_written_errors == 0, NULL);
1440         fail_unless(num_mapping_errors == 0, NULL);
1441         //fail_unless(num_member_sync_done_errors == 1, NULL);
1442         //fail_unless(num_conflicts == 0, NULL);
1443         fail_unless(num_engine_errors == 1, NULL);
1444         fail_unless(num_engine_successful == 0, NULL);
1445
1446         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1447         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1448
1449         destroy_testbed(testbed);
1450 }
1451 END_TEST
1452
1453 START_TEST (dual_sync_done_error)
1454 {
1455         char *testbed = setup_testbed("multisync_easy_new");
1456
1457         g_setenv("SYNC_DONE_ERROR", "6", TRUE);
1458
1459         OSyncError *error = NULL;
1460         OSyncGroup *group = osync_group_new(&error);
1461         fail_unless(group != NULL, NULL);
1462         fail_unless(error == NULL, NULL);
1463
1464         osync_group_set_schemadir(group, testbed);
1465         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1466         fail_unless(error == NULL, NULL);
1467
1468         OSyncEngine *engine = osync_engine_new(group, &error);
1469         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1470         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1471         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1472         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1473         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1474         fail_unless(osync_engine_initialize(engine, &error), NULL);
1475
1476         fail_unless(!synchronize_once(engine, &error), NULL);
1477         fail_unless(osync_error_is_set(&error), NULL);
1478
1479         mark_point();
1480         osync_error_unref(&error);
1481         mark_point();
1482         osync_engine_finalize(engine, &error);
1483         mark_point();
1484         osync_engine_unref(engine);
1485
1486         fail_unless(num_client_errors == 0, NULL);
1487         fail_unless(num_client_connected == 3, NULL);
1488         fail_unless(num_client_disconnected == 3, NULL);
1489         //fail_unless(num_member_sent_changes == 3, NULL);
1490         fail_unless(num_client_read == 1, NULL);
1491         fail_unless(num_client_written == 2, NULL);
1492         //fail_unless(num_written_errors == 0, NULL);
1493         fail_unless(num_mapping_errors == 0, NULL);
1494         //fail_unless(num_conflicts == 0, NULL);
1495         //fail_unless(num_member_sync_done_errors == 2, NULL);
1496         fail_unless(num_engine_errors == 1, NULL);
1497         fail_unless(num_engine_successful == 0, NULL);
1498
1499         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1500         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1501
1502         destroy_testbed(testbed);
1503 }
1504 END_TEST
1505
1506 START_TEST (triple_sync_done_error)
1507 {
1508         char *testbed = setup_testbed("multisync_easy_new");
1509
1510         g_setenv("SYNC_DONE_ERROR", "7", TRUE);
1511
1512         OSyncError *error = NULL;
1513         OSyncGroup *group = osync_group_new(&error);
1514         fail_unless(group != NULL, NULL);
1515         fail_unless(error == NULL, NULL);
1516
1517         osync_group_set_schemadir(group, testbed);
1518         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1519         fail_unless(error == NULL, NULL);
1520
1521         OSyncEngine *engine = osync_engine_new(group, &error);
1522         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1523         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1524         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1525         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1526         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1527         fail_unless(osync_engine_initialize(engine, &error), NULL);
1528
1529         fail_unless(!synchronize_once(engine, &error), NULL);
1530         fail_unless(osync_error_is_set(&error), NULL);
1531
1532         mark_point();
1533         osync_error_unref(&error);
1534         mark_point();
1535         osync_engine_finalize(engine, &error);
1536         mark_point();
1537         osync_engine_unref(engine);
1538
1539         fail_unless(num_client_errors == 0, NULL);
1540         fail_unless(num_client_connected == 3, NULL);
1541         fail_unless(num_client_disconnected == 3, NULL);
1542         //fail_unless(num_member_sent_changes == 3, NULL);
1543         fail_unless(num_client_read == 1, NULL);
1544         fail_unless(num_client_written == 2, NULL);
1545         //fail_unless(num_written_errors == 0, NULL);
1546         fail_unless(num_mapping_errors == 0, NULL);
1547         //fail_unless(num_conflicts == 0, NULL);
1548         //fail_unless(num_member_sync_done_errors == 3, NULL);
1549         fail_unless(num_engine_errors == 1, NULL);
1550         fail_unless(num_engine_successful == 0, NULL);
1551
1552         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1553         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1554
1555         destroy_testbed(testbed);
1556 }
1557 END_TEST
1558
1559 START_TEST (single_sync_done_timeout)
1560 {
1561         char *testbed = setup_testbed("multisync_easy_new");
1562
1563         g_setenv("SYNC_DONE_TIMEOUT", "4", TRUE);
1564
1565         OSyncError *error = NULL;
1566         OSyncGroup *group = osync_group_new(&error);
1567         fail_unless(group != NULL, NULL);
1568         fail_unless(error == NULL, NULL);
1569
1570         osync_group_set_schemadir(group, testbed);
1571         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1572         fail_unless(error == NULL, NULL);
1573
1574         OSyncEngine *engine = osync_engine_new(group, &error);
1575         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1576         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1577         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1578         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1579         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1580         fail_unless(osync_engine_initialize(engine, &error), NULL);
1581
1582         fail_unless(!synchronize_once(engine, &error), NULL);
1583         fail_unless(osync_error_is_set(&error), NULL);
1584
1585         mark_point();
1586         osync_error_unref(&error);
1587         mark_point();
1588         osync_engine_finalize(engine, &error);
1589         mark_point();
1590         osync_engine_unref(engine);
1591
1592         fail_unless(num_client_errors == 0, NULL);
1593         fail_unless(num_client_connected == 3, NULL);
1594         fail_unless(num_client_disconnected == 3, NULL);
1595         //fail_unless(num_member_sent_changes == 3, NULL);
1596         fail_unless(num_client_read == 1, NULL);
1597         fail_unless(num_client_written == 2, NULL);
1598         //fail_unless(num_written_errors == 0, NULL);
1599         fail_unless(num_mapping_errors == 0, NULL);
1600         //fail_unless(num_conflicts == 0, NULL);
1601         //fail_unless(num_member_sync_done_errors == 1, NULL);
1602         fail_unless(num_engine_errors == 1, NULL);
1603         fail_unless(num_engine_successful == 0, NULL);
1604
1605         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1606         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1607
1608         destroy_testbed(testbed);
1609 }
1610 END_TEST
1611
1612 START_TEST (dual_sync_done_timeout)
1613 {
1614         char *testbed = setup_testbed("multisync_easy_new");
1615
1616         g_setenv("SYNC_DONE_TIMEOUT", "6", TRUE);
1617
1618         OSyncError *error = NULL;
1619         OSyncGroup *group = osync_group_new(&error);
1620         fail_unless(group != NULL, NULL);
1621         fail_unless(error == NULL, NULL);
1622
1623         osync_group_set_schemadir(group, testbed);
1624         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1625         fail_unless(error == NULL, NULL);
1626
1627         OSyncEngine *engine = osync_engine_new(group, &error);
1628         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1629         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1630         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1631         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1632         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1633         fail_unless(osync_engine_initialize(engine, &error), NULL);
1634
1635         fail_unless(!synchronize_once(engine, &error), NULL);
1636         fail_unless(osync_error_is_set(&error), NULL);
1637
1638         mark_point();
1639         osync_error_unref(&error);
1640         mark_point();
1641         osync_engine_finalize(engine, &error);
1642         mark_point();
1643         osync_engine_unref(engine);
1644
1645         fail_unless(num_client_errors == 0, NULL);
1646         fail_unless(num_client_connected == 3, NULL);
1647         fail_unless(num_client_disconnected == 3, NULL);
1648         //fail_unless(num_member_sent_changes == 3, NULL);
1649         fail_unless(num_client_read == 1, NULL);
1650         fail_unless(num_client_written == 2, NULL);
1651         //fail_unless(num_written_errors == 0, NULL);
1652         fail_unless(num_mapping_errors == 0, NULL);
1653         //fail_unless(num_conflicts == 0, NULL);
1654         //fail_unless(num_member_sync_done_errors == 2, NULL);
1655         fail_unless(num_engine_errors == 1, NULL);
1656         fail_unless(num_engine_successful == 0, NULL);
1657
1658         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1659         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1660
1661         destroy_testbed(testbed);
1662 }
1663 END_TEST
1664
1665 START_TEST (sync_done_timeout_and_error)
1666 {
1667         char *testbed = setup_testbed("multisync_easy_new");
1668
1669         g_setenv("SYNC_DONE_TIMEOUT", "5", TRUE);
1670         g_setenv("SYNC_DONE_ERROR", "2", TRUE);
1671
1672         OSyncError *error = NULL;
1673         OSyncGroup *group = osync_group_new(&error);
1674         fail_unless(group != NULL, NULL);
1675         fail_unless(error == NULL, NULL);
1676
1677         osync_group_set_schemadir(group, testbed);
1678         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1679         fail_unless(error == NULL, NULL);
1680
1681         OSyncEngine *engine = osync_engine_new(group, &error);
1682         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1683         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1684         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1685         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1686         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1687         fail_unless(osync_engine_initialize(engine, &error), NULL);
1688
1689         fail_unless(!synchronize_once(engine, &error), NULL);
1690         fail_unless(osync_error_is_set(&error), NULL);
1691
1692         mark_point();
1693         osync_error_unref(&error);
1694         mark_point();
1695         osync_engine_finalize(engine, &error);
1696         mark_point();
1697         osync_engine_unref(engine);
1698
1699         fail_unless(num_client_errors == 0, NULL);
1700         fail_unless(num_client_connected == 3, NULL);
1701         fail_unless(num_client_disconnected == 3, NULL);
1702         //fail_unless(num_member_sent_changes == 3, NULL);
1703         fail_unless(num_client_read == 1, NULL);
1704         fail_unless(num_client_written == 2, NULL);
1705         //fail_unless(num_written_errors == 0, NULL);
1706         fail_unless(num_mapping_errors == 0, NULL);
1707         //fail_unless(num_conflicts == 0, NULL);
1708         //fail_unless(num_member_sync_done_errors == 3, NULL);
1709         fail_unless(num_engine_errors == 1, NULL);
1710         fail_unless(num_engine_successful == 0, NULL);
1711
1712         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1713         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1714
1715         destroy_testbed(testbed);
1716 }
1717 END_TEST
1718
1719 START_TEST (single_disconnect_error)
1720 {
1721         char *testbed = setup_testbed("multisync_easy_new");
1722
1723         g_setenv("DISCONNECT_ERROR", "4", TRUE);
1724
1725         OSyncError *error = NULL;
1726         OSyncGroup *group = osync_group_new(&error);
1727         fail_unless(group != NULL, NULL);
1728         fail_unless(error == NULL, NULL);
1729
1730         osync_group_set_schemadir(group, testbed);
1731         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1732         fail_unless(error == NULL, NULL);
1733
1734         OSyncEngine *engine = osync_engine_new(group, &error);
1735         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1736         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1737         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1738         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1739         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1740         fail_unless(osync_engine_initialize(engine, &error), NULL);
1741
1742         fail_unless(synchronize_once(engine, &error), NULL);
1743         fail_unless(!osync_error_is_set(&error), NULL);
1744
1745         mark_point();
1746         osync_error_unref(&error);
1747         mark_point();
1748         osync_engine_finalize(engine, &error);
1749         mark_point();
1750         osync_engine_unref(engine);
1751
1752         fail_unless(num_client_errors == 1, NULL);
1753         fail_unless(num_client_connected == 3, NULL);
1754         fail_unless(num_client_disconnected == 2, NULL);
1755         //fail_unless(num_member_sent_changes == 3, NULL);
1756         fail_unless(num_client_read == 1, NULL);
1757         fail_unless(num_client_written == 2, NULL);
1758         //fail_unless(num_written_errors == 0, NULL);
1759         fail_unless(num_mapping_errors == 0, NULL);
1760         //fail_unless(num_member_sync_done_errors == 0, NULL);
1761         //fail_unless(num_conflicts == 0, NULL);
1762         fail_unless(num_engine_errors == 0, NULL);
1763         fail_unless(num_engine_successful == 1, NULL);
1764
1765         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1766         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1767
1768         destroy_testbed(testbed);
1769 }
1770 END_TEST
1771
1772 START_TEST (dual_disconnect_error)
1773 {
1774         char *testbed = setup_testbed("multisync_easy_new");
1775
1776         g_setenv("DISCONNECT_ERROR", "6", TRUE);
1777
1778         OSyncError *error = NULL;
1779         OSyncGroup *group = osync_group_new(&error);
1780         fail_unless(group != NULL, NULL);
1781         fail_unless(error == NULL, NULL);
1782
1783         osync_group_set_schemadir(group, testbed);
1784         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1785         fail_unless(error == NULL, NULL);
1786
1787         OSyncEngine *engine = osync_engine_new(group, &error);
1788         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1789         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1790         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1791         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1792         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1793         fail_unless(osync_engine_initialize(engine, &error), NULL);
1794
1795         fail_unless(synchronize_once(engine, &error), NULL);
1796         fail_unless(!osync_error_is_set(&error), NULL);
1797
1798         mark_point();
1799         osync_error_unref(&error);
1800         mark_point();
1801         osync_engine_finalize(engine, &error);
1802         mark_point();
1803         osync_engine_unref(engine);
1804
1805         fail_unless(num_client_errors == 2, NULL);
1806         fail_unless(num_client_connected == 3, NULL);
1807         fail_unless(num_client_disconnected == 1, NULL);
1808         //fail_unless(num_member_sent_changes == 3, NULL);
1809         fail_unless(num_client_read == 1, NULL);
1810         fail_unless(num_client_written == 2, NULL);
1811         //fail_unless(num_written_errors == 0, NULL);
1812         fail_unless(num_mapping_errors == 0, NULL);
1813         //fail_unless(num_conflicts == 0, NULL);
1814         //fail_unless(num_member_sync_done_errors == 0, NULL);
1815         fail_unless(num_engine_errors == 0, NULL);
1816         fail_unless(num_engine_successful == 1, NULL);
1817
1818         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1819         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1820
1821         destroy_testbed(testbed);
1822 }
1823 END_TEST
1824
1825 START_TEST (triple_disconnect_error)
1826 {
1827         char *testbed = setup_testbed("multisync_easy_new");
1828
1829         g_setenv("DISCONNECT_ERROR", "7", TRUE);
1830
1831         OSyncError *error = NULL;
1832         OSyncGroup *group = osync_group_new(&error);
1833         fail_unless(group != NULL, NULL);
1834         fail_unless(error == NULL, NULL);
1835
1836         osync_group_set_schemadir(group, testbed);
1837         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1838         fail_unless(error == NULL, NULL);
1839
1840         OSyncEngine *engine = osync_engine_new(group, &error);
1841         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1842         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1843         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1844         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1845         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1846         fail_unless(osync_engine_initialize(engine, &error), NULL);
1847
1848         fail_unless(synchronize_once(engine, &error), NULL);
1849         fail_unless(!osync_error_is_set(&error), NULL);
1850
1851         mark_point();
1852         osync_error_unref(&error);
1853         mark_point();
1854         osync_engine_finalize(engine, &error);
1855         mark_point();
1856         osync_engine_unref(engine);
1857
1858         fail_unless(num_client_errors == 3, NULL);
1859         fail_unless(num_client_connected == 3, NULL);
1860         fail_unless(num_client_disconnected == 0, NULL);
1861         //fail_unless(num_member_sent_changes == 3, NULL);
1862         fail_unless(num_client_read == 1, NULL);
1863         fail_unless(num_client_written == 2, NULL);
1864         //fail_unless(num_written_errors == 0, NULL);
1865         fail_unless(num_mapping_errors == 0, NULL);
1866         //fail_unless(num_conflicts == 0, NULL);
1867         //fail_unless(num_member_sync_done_errors == 0, NULL);
1868         fail_unless(num_engine_errors == 0, NULL);
1869         fail_unless(num_engine_successful == 1, NULL);
1870
1871         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1872         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1873
1874         destroy_testbed(testbed);
1875 }
1876 END_TEST
1877
1878 START_TEST (single_disconnect_timeout)
1879 {
1880         char *testbed = setup_testbed("multisync_easy_new");
1881
1882         g_setenv("DISCONNECT_TIMEOUT", "4", TRUE);
1883
1884         OSyncError *error = NULL;
1885         OSyncGroup *group = osync_group_new(&error);
1886         fail_unless(group != NULL, NULL);
1887         fail_unless(error == NULL, NULL);
1888
1889         osync_group_set_schemadir(group, testbed);
1890         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1891         fail_unless(error == NULL, NULL);
1892
1893         OSyncEngine *engine = osync_engine_new(group, &error);
1894         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1895         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1896         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1897         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1898         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1899         fail_unless(osync_engine_initialize(engine, &error), NULL);
1900
1901         fail_unless(synchronize_once(engine, &error), NULL);
1902         fail_unless(!osync_error_is_set(&error), NULL);
1903
1904         mark_point();
1905         osync_error_unref(&error);
1906         mark_point();
1907         osync_engine_finalize(engine, &error);
1908         mark_point();
1909         osync_engine_unref(engine);
1910
1911         fail_unless(num_client_errors == 1, NULL);
1912         fail_unless(num_client_connected == 3, NULL);
1913         fail_unless(num_client_disconnected == 2, NULL);
1914         //fail_unless(num_member_sent_changes == 3, NULL);
1915         fail_unless(num_client_read == 1, NULL);
1916         fail_unless(num_client_written == 2, NULL);
1917         //fail_unless(num_written_errors == 0, NULL);
1918         fail_unless(num_mapping_errors == 0, NULL);
1919         //fail_unless(num_conflicts == 0, NULL);
1920         //fail_unless(num_member_sync_done_errors == 0, NULL);
1921         fail_unless(num_engine_errors == 0, NULL);
1922         fail_unless(num_engine_successful == 1, NULL);
1923
1924         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1925         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1926
1927         destroy_testbed(testbed);
1928 }
1929 END_TEST
1930
1931 START_TEST (dual_disconnect_timeout)
1932 {
1933         char *testbed = setup_testbed("multisync_easy_new");
1934
1935         g_setenv("DISCONNECT_TIMEOUT", "6", TRUE);
1936
1937         OSyncError *error = NULL;
1938         OSyncGroup *group = osync_group_new(&error);
1939         fail_unless(group != NULL, NULL);
1940         fail_unless(error == NULL, NULL);
1941
1942         osync_group_set_schemadir(group, testbed);
1943         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1944         fail_unless(error == NULL, NULL);
1945
1946         OSyncEngine *engine = osync_engine_new(group, &error);
1947         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
1948         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
1949         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
1950         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
1951         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
1952         fail_unless(osync_engine_initialize(engine, &error), NULL);
1953
1954         fail_unless(synchronize_once(engine, &error), NULL);
1955         fail_unless(!osync_error_is_set(&error), NULL);
1956
1957         mark_point();
1958         osync_error_unref(&error);
1959         mark_point();
1960         osync_engine_finalize(engine, &error);
1961         mark_point();
1962         osync_engine_unref(engine);
1963
1964         fail_unless(num_client_errors == 2, NULL);
1965         fail_unless(num_client_connected == 3, NULL);
1966         fail_unless(num_client_disconnected == 1, NULL);
1967         //fail_unless(num_member_sent_changes == 3, NULL);
1968         fail_unless(num_client_read == 1, NULL);
1969         fail_unless(num_client_written == 2, NULL);
1970         //fail_unless(num_written_errors == 0, NULL);
1971         fail_unless(num_mapping_errors == 0, NULL);
1972         //fail_unless(num_conflicts == 0, NULL);
1973         //fail_unless(num_member_sync_done_errors == 0, NULL);
1974         fail_unless(num_engine_errors == 0, NULL);
1975         fail_unless(num_engine_successful == 1, NULL);
1976
1977         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
1978         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
1979
1980         destroy_testbed(testbed);
1981 }
1982 END_TEST
1983
1984 START_TEST (disconnect_timeout_and_error)
1985 {
1986         char *testbed = setup_testbed("multisync_easy_new");
1987
1988         g_setenv("DISCONNECT_TIMEOUT", "5", TRUE);
1989         g_setenv("DISCONNECT_ERROR", "2", TRUE);
1990
1991         OSyncError *error = NULL;
1992         OSyncGroup *group = osync_group_new(&error);
1993         fail_unless(group != NULL, NULL);
1994         fail_unless(error == NULL, NULL);
1995
1996         osync_group_set_schemadir(group, testbed);
1997         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
1998         fail_unless(error == NULL, NULL);
1999
2000         OSyncEngine *engine = osync_engine_new(group, &error);
2001         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
2002         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
2003         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
2004         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
2005         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2006         fail_unless(osync_engine_initialize(engine, &error), NULL);
2007
2008         fail_unless(synchronize_once(engine, &error), NULL);
2009         fail_unless(!osync_error_is_set(&error), NULL);
2010
2011         mark_point();
2012         osync_error_unref(&error);
2013         mark_point();
2014         osync_engine_finalize(engine, &error);
2015         mark_point();
2016         osync_engine_unref(engine);
2017
2018         fail_unless(num_client_errors == 3, NULL);
2019         fail_unless(num_client_connected == 3, NULL);
2020         fail_unless(num_client_disconnected == 0, NULL);
2021         //fail_unless(num_member_sent_changes == 3, NULL);
2022         fail_unless(num_client_read == 1, NULL);
2023         fail_unless(num_client_written == 2, NULL);
2024         //fail_unless(num_written_errors == 0, NULL);
2025         fail_unless(num_mapping_errors == 0, NULL);
2026         //fail_unless(num_conflicts == 0, NULL);
2027         //fail_unless(num_member_sync_done_errors == 0, NULL);
2028         fail_unless(num_engine_errors == 0, NULL);
2029         fail_unless(num_engine_successful == 1, NULL);
2030
2031         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" == \"x\""), NULL);
2032         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" == \"x\""), NULL);
2033
2034         destroy_testbed(testbed);
2035 }
2036 END_TEST
2037
2038 START_TEST (get_changes_disconnect_error)
2039 {
2040         char *testbed = setup_testbed("multisync_easy_new");
2041
2042         g_setenv("DISCONNECT_TIMEOUT", "1", TRUE);
2043         g_setenv("DISCONNECT_ERROR", "2", TRUE);
2044         g_setenv("GET_CHANGES_TIMEOUT", "6", TRUE);
2045         g_setenv("NO_COMMITTED_ALL_CHECK", "1", TRUE);
2046
2047         OSyncError *error = NULL;
2048         OSyncGroup *group = osync_group_new(&error);
2049         fail_unless(group != NULL, NULL);
2050         fail_unless(error == NULL, NULL);
2051
2052         osync_group_set_schemadir(group, testbed);
2053         fail_unless(osync_group_load(group, "configs/group", &error), NULL);
2054         fail_unless(error == NULL, NULL);
2055
2056         OSyncEngine *engine = osync_engine_new(group, &error);
2057         osync_engine_set_memberstatus_callback(engine, member_status, NULL);
2058         osync_engine_set_enginestatus_callback(engine, engine_status, NULL);
2059         osync_engine_set_changestatus_callback(engine, entry_status, NULL);
2060         osync_engine_set_mappingstatus_callback(engine, mapping_status, NULL);
2061         osync_engine_set_conflict_callback(engine, conflict_handler_choose_modified, GINT_TO_POINTER(3));
2062         fail_unless(osync_engine_initialize(engine, &error), NULL);
2063
2064         fail_unless(!synchronize_once(engine, &error), NULL);
2065         fail_unless(osync_error_is_set(&error), NULL);
2066
2067         fail_unless(num_client_errors == 2, NULL);
2068         fail_unless(num_client_connected == 3, NULL);
2069         fail_unless(num_client_disconnected == 1, NULL);
2070         //fail_unless(num_member_sent_changes == 1, NULL);
2071         fail_unless(num_client_read == 1, NULL);
2072         fail_unless(num_client_written == 0, NULL);
2073         //fail_unless(num_written_errors == 0, NULL);
2074         fail_unless(num_mapping_errors == 0, NULL);
2075         //fail_unless(num_conflicts == 0, NULL);
2076         //fail_unless(num_member_sync_done_errors == 0, NULL);
2077         fail_unless(num_engine_errors == 1, NULL);
2078         fail_unless(num_engine_successful == 0, NULL);
2079
2080         mark_point();
2081         osync_error_unref(&error);
2082         mark_point();
2083         osync_engine_finalize(engine, &error);
2084         mark_point();
2085         osync_engine_unref(engine);
2086
2087         fail_unless(!system("test \"x$(diff -x \".*\" data1 data2)\" != \"x\""), NULL);
2088         fail_unless(!system("test \"x$(diff -x \".*\" data1 data3)\" != \"x\""), NULL);
2089
2090         destroy_testbed(testbed);
2091 }
2092 END_TEST
2093
2094
2095 Suite *multisync_suite(void)
2096 {
2097         Suite *s = suite_create("Error Codes");
2098         //Suite *s2 = suite_create("Error Codes");
2099         create_case(s, "single_init_error_noerror", single_init_error_noerror);
2100
2101         /* Disabled as not ported see http://opensync.org/ticket/980
2102
2103         create_case(s, "single_init_error", single_init_error);
2104         create_case(s, "dual_connect_error", dual_connect_error);
2105         create_case(s, "one_of_two_connect_error", one_of_two_connect_error);
2106         create_case(s, "two_of_three_connect_error", two_of_three_connect_error);
2107         create_case(s, "two_of_three_connect_error2", two_of_three_connect_error2);
2108         create_case(s, "three_of_three_connect_error", three_of_three_connect_error);
2109         create_case(s, "one_of_three_connect_error", one_of_three_connect_error);
2110         create_case(s, "no_connect_error", no_connect_error);
2111         create_case(s, "single_connect_timeout", single_connect_timeout);
2112         create_case(s, "dual_connect_timeout", dual_connect_timeout);
2113         create_case(s, "one_of_three_timeout", one_of_three_timeout);
2114         create_case(s, "timeout_and_error", timeout_and_error);
2115         create_case(s, "single_get_changes_error", single_get_changes_error);
2116         create_case(s, "dual_get_changes_error", dual_get_changes_error);
2117         create_case(s, "two_of_three_get_changes_error", two_of_three_get_changes_error);
2118         create_case(s, "one_of_three_get_changes_error", one_of_three_get_changes_error);
2119         create_case(s, "one_of_three_get_changes_timeout", one_of_three_get_changes_timeout);
2120         create_case(s, "get_changes_timeout_and_error", get_changes_timeout_and_error);
2121         create_case(s, "get_changes_timeout_sleep", get_changes_timeout_sleep);
2122         create_case(s, "single_commit_error", single_commit_error);
2123         create_case(s, "dual_commit_error", dual_commit_error);
2124         create_case(s, "single_commit_timeout", single_commit_timeout);
2125         create_case(s, "dual_commit_timeout", dual_commit_timeout);
2126         create_case(s, "commit_timeout_and_error", commit_timeout_and_error);
2127         create_case(s, "commit_timeout_and_error2", commit_timeout_and_error2);
2128         create_case(s, "commit_error_modify", commit_error_modify);
2129         create_case(s, "commit_error_delete", commit_error_delete);
2130         create_case(s, "committed_all_error", committed_all_error);
2131         create_case(s, "committed_all_batch_error", committed_all_batch_error);
2132         create_case(s, "single_sync_done_error", single_sync_done_error);
2133         create_case(s, "dual_sync_done_error", dual_sync_done_error);
2134         create_case(s, "triple_sync_done_error", triple_sync_done_error);
2135         create_case(s, "single_sync_done_timeout", single_sync_done_timeout);
2136         create_case(s, "dual_sync_done_timeout", dual_sync_done_timeout);
2137         create_case(s, "sync_done_timeout_and_error", sync_done_timeout_and_error);
2138         create_case(s, "single_disconnect_error", single_disconnect_error);
2139         create_case(s, "dual_disconnect_error", dual_disconnect_error);
2140         create_case(s, "triple_disconnect_error", triple_disconnect_error);
2141         create_case(s, "single_disconnect_timeout", single_disconnect_timeout);
2142         create_case(s, "dual_disconnect_timeout", dual_disconnect_timeout);
2143         create_case(s, "disconnect_timeout_and_error", disconnect_timeout_and_error);
2144         create_case(s, "get_changes_disconnect_error", get_changes_disconnect_error);
2145         */
2146         return s;
2147 }
2148
2149 int main(void)
2150 {
2151         int nf;
2152
2153         check_env();
2154
2155         Suite *s = multisync_suite();
2156
2157         SRunner *sr;
2158         sr = srunner_create(s);
2159         srunner_run_all(sr, CK_VERBOSE);
2160         nf = srunner_ntests_failed(sr);
2161         srunner_free(sr);
2162         return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2163 }