tests/support.c

   1 #include "support.h"
   2 #ifndef _WIN32
   3 #include <sys/wait.h> /* For WEXITSTATUS */
   4 #endif
   5
   6 #include "opensync/engine/opensync_engine_internals.h"
   7
   8 char *olddir = NULL;
   9
  10
  11 void osync_testsuite_all(Suite *s, struct osync_testcase_s *tc)
  12 {
  13         unsigned int i;
  14         for (i=0; tc[i].name; i++)
  15                 create_case(s, tc[i].name, tc[i].func);
  16 }
  17
  18 unsigned int osync_testsuite_selected(Suite *s, int argc, char **argv,
  19                 struct osync_testcase_s *tc)
  20 {
  21         unsigned int i, j, n=0;
  22         /* Also argv[0]! for symlink-ed calls */
  23         for (i=0; argc > i; i++) {
  24                 for (j=0; tc[j].name; j++) {
  25                         if (strcmp(g_basename(argv[i]), tc[j].name))
  26                                         continue;
  27
  28                         create_case(s, tc[j].name, tc[j].func);
  29                         n++;
  30                 }
  31         }
  32
  33         return n;
  34 }
  35
  36 int osync_testsuite(int argc, char **argv, const char *unittest,
  37                 struct osync_testcase_s *tc)
  38 {
  39         int nf;
  40         Suite *s = suite_create(unittest);
  41         SRunner *sr;
  42
  43         check_env();
  44
  45         if (!osync_testsuite_selected(s, argc, argv, tc))
  46                 osync_testsuite_all(s, tc);
  47
  48         sr = srunner_create(s);
  49         srunner_run_all(sr, CK_VERBOSE);
  50         nf = srunner_ntests_failed(sr);
  51         srunner_free(sr);
  52         return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
  53 }
  54
  55 static void reset_env(void)
  56 {
  57         g_unsetenv("CONNECT_ERROR");
  58         g_unsetenv("CONNECT_TIMEOUT");
  59         g_unsetenv("CONNECT_SLOWSYNC");
  60         g_unsetenv("INIT_NULL");
  61         g_unsetenv("INIT_NULL_NOERROR");
  62         g_unsetenv("GET_CHANGES_ERROR");
  63         g_unsetenv("GET_CHANGES_TIMEOUT");
  64         g_unsetenv("GET_CHANGES_TIMEOUT2");
  65         g_unsetenv("COMMIT_ERROR");
  66         g_unsetenv("COMMIT_TIMEOUT");
  67         g_unsetenv("SYNC_DONE_ERROR");
  68         g_unsetenv("SYNC_DONE_TIMEOUT");
  69         g_unsetenv("DISCONNECT_ERROR");
  70         g_unsetenv("DISCONNECT_TIMEOUT");
  71         g_unsetenv("BATCH_COMMIT");
  72         g_unsetenv("COMMITTED_ALL_ERROR");
  73         g_unsetenv("NO_COMMITTED_ALL_CHECK");
  74         g_unsetenv("MAINSINK_CONNECT");
  75
  76         g_unsetenv("OSYNC_NOMEMORY");
  77         g_unsetenv("MOCK_SYNC_EXPECT_COMMIT_ALWAYS_ADDED");
  78         g_unsetenv("MOCK_SYNC_ALWAYS_CHANGETYPE_MODIFIED");
  79
  80         g_unsetenv("MOCK_FORMAT_PATH_COMPARE_NO");
  81 }
  82
  83
  84 void check_env(void) {
  85
  86         if (g_getenv("OSYNC_TRACE"))
  87                 fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
  88                                 "WARNING! Environment variable OSYNC_TRACE is set.\n"
  89                                 "This unit contains stress & performance tests which\n"
  90                                 "will fail/timeout because of bad performance impact of\n"
  91                                 "the i/o which will be produced by OSYNC_TRACE!\n"
  92                                 "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n");
  93 }
  94
  95 char *setup_testbed(const char *fkt_name)
  96 {
  97 #ifndef _WIN32
  98         setuid(65534);
  99 #endif
 100         char *testbed = g_strdup_printf("%s/testbed.XXXXXX", g_get_tmp_dir());
 101         char *command = NULL, *dirname = NULL;
 102 #ifdef _WIN32
 103         if(g_file_test(testbed, G_FILE_TEST_IS_DIR))
 104                 destroy_testbed(g_strdup(testbed));
 105
 106         if(g_mkdir(testbed,0777) < 0){
 107                         osync_trace(TRACE_INTERNAL, "%s: Cannot create testbed directory %s", __func__, testbed);
 108                         abort();
 109         }
 110 #else /* WIN32 */
 111         if (!mkdtemp(testbed))
 112                 abort();
 113 #endif /* WIN32 */
 114
 115         if (fkt_name) {
 116                 dirname = g_strdup_printf(OPENSYNC_TESTDATA"/%s", fkt_name);
 117                 if (!g_file_test(dirname, G_FILE_TEST_IS_DIR)) {
 118                         osync_trace(TRACE_INTERNAL, "%s: Path %s not exist.", __func__, dirname);
 119                         abort();
 120                 }
 121                 command = g_strdup_printf("cp -R %s/* %s", dirname, testbed);
 122                 if (system(command))
 123                         abort();
 124                 g_free(command);
 125                 g_free(dirname);
 126         }
 127
 128         dirname = g_strdup_printf("%s/formats",  testbed);
 129         if (!g_file_test(dirname, G_FILE_TEST_IS_DIR)) {
 130                 if (g_mkdir(dirname,0777) < 0) {
 131                         osync_trace(TRACE_ERROR, "Could not create format direcotry %s", dirname);
 132                         abort();
 133                 }
 134         }
 135         g_free(dirname);
 136
 137         dirname = g_strdup_printf("%s/plugins",  testbed);
 138         if (!g_file_test(dirname, G_FILE_TEST_IS_DIR)) {
 139                 if (g_mkdir(dirname,0777) < 0) {
 140                         osync_trace(TRACE_ERROR, "Could not create plugin direcotry %s", dirname);
 141                         abort();
 142                 }
 143         }
 144         g_free(dirname);
 145
 146         command = g_strdup_printf("cp ./mock-plugin/mock-sync.%s %s/plugins", G_MODULE_SUFFIX, testbed);
 147         if (system(command))
 148                 abort();
 149         g_free(command);
 150
 151         command = g_strdup_printf("cp ./mock-plugin/mock-format.%s %s/formats", G_MODULE_SUFFIX, testbed);
 152         if (system(command))
 153                 abort();
 154         g_free(command);
 155
 156         command = g_strdup_printf("cp -R %s/../../misc/schemas/*.xsd %s", OPENSYNC_TESTDATA, testbed);
 157         if (system(command))
 158                 abort();
 159         g_free(command);
 160
 161 #ifndef _WIN32  /* chmod is useless on windows system */
 162         command = g_strdup_printf("chmod -R 700 %s", testbed);
 163         if (system(command))
 164                 abort();
 165         g_free(command);
 166 #endif
 167
 168         olddir = g_get_current_dir();
 169         if (g_chdir(testbed) < 0){
 170                 osync_trace(TRACE_ERROR, "Could not chdir to testbed");
 171                 abort();
 172         }
 173
 174         reset_counters();
 175
 176         osync_trace(TRACE_INTERNAL, "Seting up %s at %s", fkt_name, testbed);
 177 /*      printf(".");
 178         fflush(NULL);*/
 179         reset_env();
 180         return testbed;
 181 }
 182
 183 void destroy_testbed(char *path)
 184 {
 185         char *command = g_strdup_printf("rm -rf %s", path);
 186         if (olddir) {
 187                 if (g_chdir(olddir) < 0)
 188                         abort();
 189                 g_free(olddir);
 190         }
 191         if (system(command))
 192                 abort();
 193
 194         g_free(command);
 195         osync_trace(TRACE_INTERNAL, "Tearing down %s", path);
 196         g_free(path);
 197 }
 198
 199 void create_case(Suite *s, const char *name, TFun function)
 200 {
 201         TCase *tc_new = tcase_create(name);
 202         tcase_set_timeout(tc_new, 30);
 203         suite_add_tcase (s, tc_new);
 204         tcase_add_test(tc_new, function);
 205 }
 206
 207
 208 // create_case_timeout() allow to specific a specific timeout - intended for breaking testcases which needs longer then 30seconds (default)
 209 void create_case_timeout(Suite *s, const char *name, TFun function, int timeout)
 210 {
 211         TCase *tc_new = tcase_create(name);
 212         tcase_set_timeout(tc_new, timeout);
 213         suite_add_tcase (s, tc_new);
 214         tcase_add_test(tc_new, function);
 215 }
 216
 217 OSyncMappingTable *mappingtable_load(const char *path, const char *objtype, int num_mappings)
 218 {
 219         OSyncError *error = NULL;
 220         OSyncMappingTable *table = NULL;
 221         OSyncArchive *archive = NULL;
 222
 223         osync_trace(TRACE_ENTRY, "%s(%s, %s, %i)", __func__, path, objtype, num_mappings);
 224
 225         table = osync_mapping_table_new(&error);
 226         fail_unless(table != NULL, NULL);
 227         fail_unless(error == NULL, NULL);
 228
 229         archive = osync_archive_new(path, &error);
 230         fail_unless(archive != NULL, NULL);
 231         fail_unless(error == NULL, NULL);
 232
 233         fail_unless(osync_mapping_table_load(table, archive, objtype, &error), NULL);
 234         fail_unless(error == NULL, NULL);
 235
 236         osync_archive_unref(archive);
 237
 238         fail_unless(osync_mapping_table_num_mappings(table) == num_mappings, NULL);
 239
 240         osync_trace(TRACE_EXIT, "%s: %p", __func__, table);
 241         return table;
 242 }
 243
 244 void check_mapping(OSyncMappingTable *maptable, int memberid, int mappingid, int numentries, const char *uid)
 245 {
 246         int i = 0;
 247         osync_trace(TRACE_ENTRY, "%s(%p, %i, %i, %i, %s)", __func__, maptable, memberid, mappingid, numentries, uid);
 248
 249         for (i = 0; i < osync_mapping_table_num_mappings(maptable); i++) {
 250                 OSyncMapping *mapping = osync_mapping_table_nth_mapping(maptable, i);
 251                 OSyncMappingEntry *testentry = osync_mapping_find_entry_by_member_id(mapping, memberid);
 252                 if ((mappingid != -1 && osync_mapping_get_id(mapping) == mappingid) || (mappingid == -1 && !strcmp(osync_mapping_entry_get_uid(testentry), uid))) {
 253                         int n = 0;
 254                         fail_unless(osync_mapping_num_entries(mapping) == numentries);
 255                         for (n = 0; n < osync_mapping_num_entries(mapping); n++) {
 256                                 OSyncMappingEntry *entry = osync_mapping_nth_entry(mapping, n);
 257                                 if (osync_mapping_entry_get_member_id(entry) == memberid) {
 258                                         fail_unless(!strcmp(osync_mapping_entry_get_uid(entry), uid), NULL);
 259                                         goto out;
 260                                 }
 261                         }
 262                         fail(NULL);
 263                 }
 264         }
 265         fail(NULL);
 266
 267 out:
 268         osync_trace(TRACE_EXIT, "%s", __func__);
 269 }
 270
 271 OSyncHashTable *hashtable_load(const char *path, const char *objtype, int entries)
 272 {
 273         OSyncError *error = NULL;
 274         OSyncHashTable *table = osync_hashtable_new(path, objtype, &error);
 275         fail_unless(table != NULL, NULL);
 276         fail_unless(error == NULL, NULL);
 277
 278         fail_unless(osync_hashtable_load(table, &error), NULL);
 279
 280         fail_unless(osync_hashtable_num_entries(table) == entries, NULL);
 281
 282         return table;
 283 }
 284
 285 void check_hash(OSyncHashTable *table, const char *cmpuid)
 286 {
 287         fail_unless(!!osync_hashtable_get_hash(table, cmpuid), "Couldn't find hash!");
 288 }
 289
 290
 291 void create_random_file(const char *path)
 292 {
 293         char *content = osync_rand_str(g_random_int_range(100, 200));
 294         osync_assert(osync_file_write(path, content, strlen(content), 0700, NULL) == TRUE);
 295         g_free(content);
 296 }
 297
 298 void member_status(OSyncMemberUpdate *status, void *user_data)
 299 {
 300         osync_trace(TRACE_ENTRY, "%s(%p (%i), %p)", __func__, status, status->type, user_data);
 301         fail_unless(GINT_TO_POINTER(1) == user_data, NULL);
 302
 303         switch (status->type) {
 304                 case OSYNC_CLIENT_EVENT_CONNECTED:
 305                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 306
 307                         if (status->objtype == NULL) {
 308                                 num_client_main_connected++;
 309                         } else {
 310                                 fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL);
 311                                 num_client_connected++;
 312                         }
 313
 314                         break;
 315                 case OSYNC_CLIENT_EVENT_CONNECT_DONE:
 316                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 317
 318                         if (status->objtype == NULL) {
 319                                 num_client_main_connect_done++;
 320                         } else {
 321                                 fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL);
 322                                 num_client_connect_done++;
 323                         }
 324                         break;
 325                 case OSYNC_CLIENT_EVENT_DISCONNECTED:
 326                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 327
 328                         if (status->objtype == NULL) {
 329                                 num_client_main_disconnected++;
 330                         } else {
 331                                 fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL);
 332                                 num_client_disconnected++;
 333                         }
 334
 335                         break;
 336                 case OSYNC_CLIENT_EVENT_READ:
 337                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 338
 339                         if (status->objtype == NULL) {
 340                                 num_client_main_read++;
 341                         } else {
 342                                 fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL);
 343                                 num_client_read++;
 344                         }
 345
 346                         break;
 347                 case OSYNC_CLIENT_EVENT_WRITTEN:
 348                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 349
 350                         if (status->objtype == NULL) {
 351                                 num_client_main_written++;
 352                         } else {
 353                                 fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL);
 354                                 num_client_written++;
 355                         }
 356
 357                         break;
 358                 case OSYNC_CLIENT_EVENT_ERROR:
 359                         fail_unless(osync_error_is_set(&(status->error)), NULL);
 360                         num_client_errors++;
 361                         break;
 362                 case OSYNC_CLIENT_EVENT_SYNC_DONE:
 363                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 364
 365                         if (status->objtype == NULL) {
 366                                 num_client_main_sync_done++;
 367                         } else {
 368                                 fail_unless(!strncmp(status->objtype, "mockobjtype", 11), NULL);
 369                                 num_client_sync_done++;
 370                         }
 371
 372                         break;
 373                 case OSYNC_CLIENT_EVENT_DISCOVERED:
 374                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 375                         num_client_discovered++;
 376                         break;
 377         }
 378
 379         osync_trace(TRACE_EXIT, "%s", __func__);
 380 }
 381
 382 void entry_status(OSyncChangeUpdate *status, void *user_data)
 383 {
 384         osync_trace(TRACE_ENTRY, "%s(%p (%i), %p)", __func__, status, status->type, user_data);
 385
 386         switch (status->type) {
 387                 case OSYNC_CHANGE_EVENT_READ:
 388                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 389                         num_change_read++;
 390                         break;
 391                 case OSYNC_CHANGE_EVENT_WRITTEN:
 392                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 393                         num_change_written++;
 394                         break;
 395                 case OSYNC_CHANGE_EVENT_ERROR:
 396                         fail_unless(osync_error_is_set(&(status->error)), NULL);
 397                         num_change_error++;
 398                         break;
 399         }
 400
 401         osync_trace(TRACE_EXIT, "%s", __func__);
 402 }
 403
 404 void engine_status(OSyncEngineUpdate *status, void *user_data)
 405 {
 406         osync_trace(TRACE_ENTRY, "%s(%p(%i), %p)", __func__, status, status->type, user_data);
 407         switch (status->type) {
 408                 case OSYNC_ENGINE_EVENT_CONNECTED:
 409                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 410                         num_engine_connected++;
 411                         break;
 412                 case OSYNC_ENGINE_EVENT_CONNECT_DONE:
 413                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 414                         num_engine_connect_done++;
 415                         break;
 416                 case OSYNC_ENGINE_EVENT_READ:
 417                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 418                         num_engine_read++;
 419                         break;
 420                 case OSYNC_ENGINE_EVENT_PREPARED_MAP:
 421                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 422                         num_engine_prepared_map++;
 423                         break;
 424                 case OSYNC_ENGINE_EVENT_MAPPED:
 425                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 426                         num_engine_mapped++;
 427                         break;
 428                 case OSYNC_ENGINE_EVENT_MULTIPLIED:
 429                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 430                         num_engine_multiplied++;
 431                         break;
 432                 case OSYNC_ENGINE_EVENT_PREPARED_WRITE:
 433                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 434                         num_engine_prepared_write++;
 435                         break;
 436                 case OSYNC_ENGINE_EVENT_WRITTEN:
 437                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 438                         num_engine_written++;
 439                         break;
 440                 case OSYNC_ENGINE_EVENT_DISCONNECTED:
 441                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 442                         num_engine_disconnected++;
 443                         break;
 444                 case OSYNC_ENGINE_EVENT_ERROR:
 445                         fail_unless(osync_error_is_set(&(status->error)), NULL);
 446                         num_engine_errors++;
 447                         break;
 448                 case OSYNC_ENGINE_EVENT_SUCCESSFUL:
 449                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 450                         num_engine_successful++;
 451                         break;
 452                 case OSYNC_ENGINE_EVENT_PREV_UNCLEAN:
 453                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 454                         num_engine_prev_unclean++;
 455                         break;
 456                 case OSYNC_ENGINE_EVENT_END_CONFLICTS:
 457                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 458                         num_engine_end_conflicts++;
 459                         break;
 460                 case OSYNC_ENGINE_EVENT_SYNC_DONE:
 461                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 462                         num_engine_sync_done++;
 463                         break;
 464         }
 465
 466         osync_trace(TRACE_EXIT, "%s", __func__);
 467 }
 468
 469 void mapping_status(OSyncMappingUpdate *status, void *user_data)
 470 {
 471         switch (status->type) {
 472                 case OSYNC_MAPPING_EVENT_SOLVED:
 473                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 474                         num_mapping_solved++;
 475                         break;
 476                 /*case OSYNC_MAPPING_EVENT_WRITTEN:
 477                         fail_unless(!osync_error_is_set(&(status->error)), NULL);
 478                         num_mapping_written++;
 479                         break;*/
 480                 case OSYNC_MAPPING_EVENT_ERROR:
 481                         fail_unless(osync_error_is_set(&(status->error)), NULL);
 482                         num_mapping_errors++;
 483                         break;
 484         }
 485 }
 486
 487 void conflict_handler_choose_first(OSyncEngine *engine, OSyncMappingEngine *mapping, void *user_data)
 488 {
 489         OSyncChange *change = NULL;
 490         OSyncError *error = NULL;
 491
 492         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, engine, mapping, user_data);
 493
 494         num_mapping_conflicts++;
 495         fail_unless(osync_mapping_engine_num_changes(mapping) == GPOINTER_TO_INT(user_data), NULL);
 496         fail_unless(num_engine_end_conflicts == 0, NULL);
 497
 498         change = osync_mapping_engine_member_change(mapping, 1);
 499         osync_assert(osync_engine_mapping_solve(engine, mapping, change, &error));
 500         osync_assert(error == NULL);
 501
 502         osync_trace(TRACE_EXIT, "%s", __func__);
 503 }
 504
 505 void conflict_handler_choose_deleted(OSyncEngine *engine, OSyncMappingEngine *mapping, void *user_data)
 506 {
 507         OSyncError *error = NULL;
 508         int i;
 509         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, engine, mapping, user_data);
 510
 511         num_mapping_conflicts++;
 512         fail_unless(osync_mapping_engine_num_changes(mapping) == GPOINTER_TO_INT(user_data), NULL);
 513         fail_unless(num_engine_end_conflicts == 0, NULL);
 514
 515         for (i = 0; i < osync_mapping_engine_num_changes(mapping); i++) {
 516                 OSyncChange *change = osync_mapping_engine_nth_change(mapping, i);
 517                 if (osync_change_get_changetype(change) == OSYNC_CHANGE_TYPE_DELETED) {
 518                         osync_assert(osync_engine_mapping_solve(engine, mapping, change, &error));
 519                         osync_assert(error == NULL);
 520
 521                         osync_trace(TRACE_EXIT, "%s", __func__);
 522                         return;
 523                 }
 524         }
 525         fail(NULL);
 526 }
 527
 528 void conflict_handler_choose_modified(OSyncEngine *engine, OSyncMappingEngine *mapping, void *user_data)
 529 {
 530         OSyncError *error = NULL;
 531         int i;
 532         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, engine, mapping, user_data);
 533
 534         num_mapping_conflicts++;
 535         fail_unless(osync_mapping_engine_num_changes(mapping) == GPOINTER_TO_INT(user_data), NULL);
 536         fail_unless(num_engine_end_conflicts == 0, NULL);
 537
 538         for (i = 0; i < osync_mapping_engine_num_changes(mapping); i++) {
 539                 OSyncChange *change = osync_mapping_engine_nth_change(mapping, i);
 540                 if (osync_change_get_changetype(change) == OSYNC_CHANGE_TYPE_MODIFIED) {
 541                         osync_assert(osync_mapping_engine_solve(mapping, change, &error));
 542                         osync_assert(error == NULL);
 543                         osync_trace(TRACE_EXIT, "%s", __func__);
 544                         return;
 545                 }
 546         }
 547         fail("");
 548 }
 549
 550 void conflict_handler_ignore(OSyncEngine *engine, OSyncMappingEngine *mapping, void *user_data)
 551 {
 552         OSyncError *error = NULL;
 553         num_mapping_conflicts++;
 554         if (user_data)
 555                 fail_unless(osync_mapping_engine_num_changes(mapping) == GPOINTER_TO_INT(user_data), NULL);
 556         fail_unless(num_engine_end_conflicts == 0, NULL);
 557
 558         osync_engine_mapping_ignore_conflict(engine, mapping, &error);
 559         fail_unless(error == NULL, NULL);
 560 }
 561
 562 void conflict_handler_duplicate(OSyncEngine *engine, OSyncMappingEngine *mapping, void *user_data)
 563 {
 564         OSyncError *error = NULL;
 565         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, engine, mapping, user_data);
 566
 567         num_mapping_conflicts++;
 568         fail_unless(osync_mapping_engine_num_changes(mapping) == GPOINTER_TO_INT(user_data), NULL);
 569         fail_unless(num_engine_end_conflicts == 0, NULL);
 570
 571         fail_unless(osync_engine_mapping_duplicate(engine, mapping, &error), NULL);
 572
 573         osync_trace(TRACE_EXIT, "%s", __func__);
 574 }
 575
 576 void conflict_handler_abort(OSyncEngine *engine, OSyncMappingEngine *mapping, void *user_data)
 577 {
 578         OSyncError *error = NULL;
 579         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, engine, mapping, user_data);
 580
 581         fail_unless(osync_mapping_engine_num_changes(mapping) == GPOINTER_TO_INT(user_data), NULL);
 582         fail_unless(num_engine_end_conflicts == 0, NULL);
 583
 584         fail_unless(osync_engine_abort(engine, &error), NULL);
 585
 586         osync_trace(TRACE_EXIT, "%s", __func__);
 587 }
 588
 589 OSyncEngine *gengine = NULL;
 590
 591 void solve_conflict(OSyncMappingEngine *mapping)
 592 {
 593         OSyncChange *change = NULL;
 594         OSyncError *error = NULL;
 595
 596         g_usleep(5*G_USEC_PER_SEC);
 597
 598         change = osync_mapping_engine_nth_change(mapping, 0);
 599         osync_assert(osync_engine_mapping_solve(gengine, mapping, change, &error));
 600         osync_assert(error == NULL);
 601 }
 602
 603 void conflict_handler_delay(OSyncEngine *engine, OSyncMappingEngine *mapping, void *user_data)
 604 {
 605         osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, engine, mapping, user_data);
 606
 607         num_mapping_conflicts++;
 608         fail_unless(osync_mapping_engine_num_changes(mapping) == GPOINTER_TO_INT(user_data), NULL);
 609         fail_unless(num_engine_end_conflicts == 0, NULL);
 610         gengine = engine;
 611         g_thread_create ((GThreadFunc)solve_conflict, mapping, TRUE, NULL);
 612
 613         osync_trace(TRACE_EXIT, "%s", __func__);
 614 }
 615
 616 void reset_counters()
 617 {
 618         num_client_connected = 0;
 619         num_client_main_connected = 0;
 620         num_client_disconnected = 0;
 621         num_client_main_disconnected = 0;
 622         num_client_read = 0;
 623         num_client_main_read = 0;
 624         num_client_written = 0;
 625         num_client_main_written = 0;
 626         num_client_errors = 0;
 627         num_client_sync_done = 0;
 628         num_client_main_sync_done = 0;
 629         num_client_discovered = 0;
 630
 631         num_change_read = 0;
 632         num_change_written = 0;
 633         num_change_error = 0;
 634
 635         num_engine_connected = 0;
 636         num_engine_read = 0;
 637         num_engine_prepared_map = 0;
 638         num_engine_mapped = 0;
 639         num_engine_multiplied = 0;
 640         num_engine_written = 0;
 641         num_engine_disconnected = 0;
 642         num_engine_errors = 0;
 643         num_engine_successful = 0;
 644         num_engine_end_conflicts = 0;
 645         num_engine_prev_unclean = 0;
 646         num_engine_sync_done = 0;
 647
 648         num_mapping_solved = 0;
 649         num_mapping_written = 0;
 650         num_mapping_errors = 0;
 651
 652         num_mapping_conflicts = 0;
 653 }
 654
 655 osync_bool synchronize_once(OSyncEngine *engine, OSyncError **error)
 656 {
 657         reset_counters();
 658         fail_unless(osync_engine_repair(engine, error), "Repair of engine failed: %s", osync_error_print(error));
 659         return osync_engine_synchronize_and_block(engine, error);
 660 }
 661
 662 void discover_all_once(OSyncEngine *engine, OSyncError **error)
 663 {
 664         OSyncGroup *group = osync_engine_get_group(engine);
 665         int i, max = osync_group_num_members(group);
 666         for (i=0; i < max; i++) {
 667                 OSyncMember *member = osync_group_nth_member(group, i);
 668                 osync_engine_discover_and_block(engine, member, error);
 669                 osync_member_save(member, error);
 670         }
 671 }
 672
 673 OSyncFormatEnv *osync_testing_load_formatenv(const char *formatdir)
 674 {
 675         OSyncError *error = NULL;
 676         OSyncFormatEnv *formatenv = osync_format_env_new(&error);
 677         fail_unless(formatenv != NULL, NULL);
 678         fail_unless(error == NULL, NULL);
 679         fail_unless(osync_format_env_load_plugins(formatenv, formatdir, &error));
 680         return formatenv;
 681 }
 682
 683 /** @brief Check if file or directory exists. No check for regular file!
 684  *
 685  * @param file filename or fullpath of file/directory
 686  * @returns TRUE if exists, FALSE otherwise
 687  *
 688  */
 689 osync_bool osync_testing_file_exists(const char *file)
 690 {
 691         return g_file_test(file, G_FILE_TEST_EXISTS);
 692 }
 693
 694 /** @brief Removes files and directories
 695  *
 696  * @param file filename or fullpath of file/directory
 697  * @returns TRUE on success, FALSE otherwise
 698  *
 699  */
 700 osync_bool osync_testing_file_remove(const char *file)
 701 {
 702         return g_remove(file);
 703 }
 704
 705 /** @brief Modifies permission of file - like chmod()
 706  *
 707  * @param file filename or fullpath of file
 708  * @param mode the permission mode like chmod()
 709  * @returns TRUE on success, FALSE otherwise
 710  *
 711  */
 712 osync_bool osync_testing_file_chmod(const char *file, int mode)
 713 {
 714         /* GLib 2.16.3 Note:
 715            "[...] Software that needs to manage file
 716            permissions on Windows exactly should use the Win32 API."
 717         TODO: Do we have to care about this on Windows?! */
 718         return g_chmod(file, mode);
 719 }
 720
 721 /** @brief Copy files
 722  *
 723  * @param source source filename
 724  * @param dest destination filename
 725  * @returns TRUE on success, FALSE otherwise
 726  *
 727  */
 728 osync_bool osync_testing_file_copy(const char *source, const char *dest)
 729 {
 730         gboolean ret;
 731         const char *argv[] = { "cp", source, dest, NULL };
 732         int exitstatus = -1;
 733
 734         ret = g_spawn_sync(NULL,                        /* working directory */
 735                                                 (char **)argv,  /* arguments */
 736                                                 NULL,                   /* environment */
 737                                                 G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL,
 738                                                 NULL,                   /* child setup function */
 739                                                 NULL,                   /* user data for child setup func */
 740                                                 NULL,                   /* stdin */
 741                                                 NULL,                   /* stdout */
 742                                                 &exitstatus,    /* exit status */
 743                                                 NULL                    /* error function */
 744                                                 );
 745 #ifndef _WIN32
 746         return ret && WEXITSTATUS(exitstatus) == 0;
 747 #else
 748         return ret;
 749 #endif
 750 }
 751
 752 /** @brief Find differences between two files
 753  *
 754  * @param source source filename
 755  * @param dest destination filename
 756  * @returns TRUE on when equal/success, FALSE otherwise
 757  *
 758  */
 759 osync_bool osync_testing_diff(const char *file1, const char *file2)
 760 {
 761         gchar *cmd;
 762         int ret;
 763
 764         osync_assert(file1);
 765         osync_assert(file2);
 766
 767         cmd = g_strdup_printf(DIFF " -x \".*\" %s %s", file1, file2);
 768         ret = system(cmd);
 769         g_free(cmd);
 770
 771         return !ret;
 772 }
 773
 774 /** @brief Creates a simple OSyncPluginConfig with a single resource.
 775  *         If config is not null the resource information gets added.
 776  *
 777  * @param config OSyncPluginConfig pointer to add resource info
 778  * @param path relative path of resource
 779  * @param objformat the objformat of the resource
 780  * @param format_config the format converter config paramter
 781  * @returns OSyncPluginConfig pointer or asserts on error
 782  *
 783  */
 784 OSyncPluginConfig *simple_plugin_config(OSyncPluginConfig *config, const char *path, const char *objtype, const char *objformat, const char *format_config) {
 785         OSyncError *error = NULL;
 786         OSyncObjFormatSink *format_sink = NULL;
 787         OSyncPluginResource *res = NULL;
 788         osync_assert(objtype);
 789         osync_assert(objformat);
 790
 791         if (!config)
 792                 config = osync_plugin_config_new(&error);
 793
 794         fail_unless(config != NULL, NULL);
 795         fail_unless(error == NULL, NULL);
 796
 797         format_sink = osync_objformat_sink_new(objformat, &error);
 798         if (format_config)
 799                 osync_objformat_sink_set_config(format_sink, format_config);
 800
 801         res = osync_plugin_resource_new(&error);
 802         osync_plugin_resource_set_objtype(res, objtype);
 803         osync_plugin_resource_set_path(res, path);
 804         osync_plugin_resource_enable(res, TRUE);
 805         osync_plugin_resource_add_objformat_sink(res, format_sink);
 806
 807
 808         osync_plugin_config_add_resource(config, res);
 809
 810         return config;
 811 }
 812
 813 /** @brief Creates a simple OSyncEngine with nth Members with mock-sync
 814  *         plugins.
 815  *
 816  * @param member_size The number of member the Group for this Engine should have
 817  * @returns OSyncEngine pointer or asserts on error
 818  *
 819  */
 820 OSyncEngine *osync_testing_create_engine_dummy(unsigned int member_size)
 821 {
 822         unsigned int u;
 823         OSyncError *error = NULL;
 824         OSyncEngine *engine = NULL;
 825         OSyncGroup *group = osync_group_new(&error);
 826
 827         fail_unless(group != NULL, NULL);
 828         fail_unless(error == NULL, NULL);
 829
 830         for (u=0; u < member_size; u++) {
 831                 OSyncMember *member = osync_member_new(&error);
 832                 fail_unless(member != NULL, NULL);
 833                 fail_unless(error == NULL, NULL);
 834
 835                 osync_group_add_member(group, member);
 836         }
 837
 838         engine = osync_engine_new(group, &error);
 839         fail_unless(engine != NULL, NULL);
 840         fail_unless(error == NULL, NULL);
 841
 842         return engine;
 843 }
 844
 845 void osync_testing_system_abort(const char *command)
 846 {
 847         if (system(command))
 848                 abort();
 849 }
 850