tests/format-tests/check_conv.c

   1 #include "support.h"
   2
   3 #include <opensync/opensync-format.h>
   4 #include "opensync/format/opensync_filter_internals.h"
   5 #include "opensync/format/opensync_format_env_internals.h"
   6
   7 START_TEST (conv_env_create)
   8 {
   9         char *testbed = setup_testbed(NULL);
  10
  11         OSyncError *error = NULL;
  12         OSyncFormatEnv *env = osync_format_env_new(&error);
  13         fail_unless(env != NULL, NULL);
  14         fail_unless(error == NULL, NULL);
  15
  16         osync_format_env_unref(env);
  17
  18         destroy_testbed(testbed);
  19 }
  20 END_TEST
  21
  22 START_TEST (conv_env_register_objformat)
  23 {
  24         char *testbed = setup_testbed(NULL);
  25
  26         OSyncError *error = NULL;
  27         OSyncFormatEnv *env = osync_format_env_new(&error);
  28         fail_unless(env != NULL, NULL);
  29         fail_unless(error == NULL, NULL);
  30
  31         OSyncObjFormat *format = osync_objformat_new("format", "objtype", &error);
  32         fail_unless(format != NULL, NULL);
  33         fail_unless(error == NULL, NULL);
  34
  35         osync_format_env_register_objformat(env, format);
  36
  37         osync_objformat_unref(format);
  38
  39         osync_format_env_unref(env);
  40
  41         destroy_testbed(testbed);
  42 }
  43 END_TEST
  44
  45 START_TEST (conv_env_register_objformat_count)
  46 {
  47         char *testbed = setup_testbed(NULL);
  48
  49         OSyncError *error = NULL;
  50         OSyncFormatEnv *env = osync_format_env_new(&error);
  51         fail_unless(env != NULL, NULL);
  52         fail_unless(error == NULL, NULL);
  53
  54         OSyncObjFormat *format = osync_objformat_new("format", "objtype", &error);
  55         fail_unless(format != NULL, NULL);
  56         fail_unless(error == NULL, NULL);
  57
  58         fail_unless(osync_format_env_num_objformats(env) == 0, NULL);
  59
  60         osync_format_env_register_objformat(env, format);
  61         osync_objformat_unref(format);
  62
  63         fail_unless(osync_format_env_num_objformats(env) == 1, NULL);
  64         fail_unless(osync_format_env_nth_objformat(env, 0) == format, NULL);
  65
  66         osync_format_env_unref(env);
  67
  68         destroy_testbed(testbed);
  69 }
  70 END_TEST
  71
  72 START_TEST (conv_env_objformat_find)
  73 {
  74         char *testbed = setup_testbed(NULL);
  75
  76         OSyncError *error = NULL;
  77         OSyncFormatEnv *env = osync_format_env_new(&error);
  78         fail_unless(env != NULL, NULL);
  79         fail_unless(error == NULL, NULL);
  80
  81         OSyncObjFormat *format = osync_objformat_new("format", "objtype", &error);
  82         fail_unless(format != NULL, NULL);
  83         fail_unless(error == NULL, NULL);
  84
  85         osync_format_env_register_objformat(env, format);
  86         osync_objformat_unref(format);
  87
  88         fail_unless(osync_format_env_find_objformat(env, "format") == format, NULL);
  89
  90         osync_format_env_unref(env);
  91
  92         destroy_testbed(testbed);
  93 }
  94 END_TEST
  95
  96 START_TEST (conv_env_objformat_find_false)
  97 {
  98         char *testbed = setup_testbed(NULL);
  99
 100         OSyncError *error = NULL;
 101         OSyncFormatEnv *env = osync_format_env_new(&error);
 102         fail_unless(env != NULL, NULL);
 103         fail_unless(error == NULL, NULL);
 104
 105         OSyncObjFormat *format = osync_objformat_new("format", "objtype", &error);
 106         fail_unless(format != NULL, NULL);
 107         fail_unless(error == NULL, NULL);
 108
 109         osync_format_env_register_objformat(env, format);
 110         osync_objformat_unref(format);
 111
 112         fail_unless(osync_format_env_find_objformat(env, "format2") == NULL, NULL);
 113
 114         osync_format_env_unref(env);
 115
 116         destroy_testbed(testbed);
 117 }
 118 END_TEST
 119
 120 osync_bool convert_func(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void* user_data, OSyncError **error)
 121 {
 122         *free_input = TRUE;
 123         *output = g_strdup("test");
 124         *outpsize = 5;
 125         return TRUE;
 126 }
 127
 128 START_TEST (conv_env_register_converter)
 129 {
 130         char *testbed = setup_testbed(NULL);
 131
 132         OSyncError *error = NULL;
 133         OSyncFormatEnv *env = osync_format_env_new(&error);
 134         fail_unless(env != NULL, NULL);
 135         fail_unless(error == NULL, NULL);
 136
 137         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 138         fail_unless(format1 != NULL, NULL);
 139         fail_unless(error == NULL, NULL);
 140         osync_format_env_register_objformat(env, format1);
 141
 142         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 143         fail_unless(format2 != NULL, NULL);
 144         fail_unless(error == NULL, NULL);
 145         osync_format_env_register_objformat(env, format2);
 146
 147         OSyncFormatConverter *converter = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 148         fail_unless(converter != NULL, NULL);
 149         fail_unless(error == NULL, NULL);
 150
 151         osync_format_env_register_converter(env, converter);
 152
 153         osync_converter_unref(converter);
 154
 155         osync_format_env_unref(env);
 156
 157         osync_objformat_unref(format1);
 158         osync_objformat_unref(format2);
 159
 160         destroy_testbed(testbed);
 161 }
 162 END_TEST
 163
 164 START_TEST (conv_env_register_converter_count)
 165 {
 166         char *testbed = setup_testbed(NULL);
 167
 168         OSyncError *error = NULL;
 169         OSyncFormatEnv *env = osync_format_env_new(&error);
 170         fail_unless(env != NULL, NULL);
 171         fail_unless(error == NULL, NULL);
 172
 173         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 174         fail_unless(format1 != NULL, NULL);
 175         fail_unless(error == NULL, NULL);
 176         osync_format_env_register_objformat(env, format1);
 177
 178         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 179         fail_unless(format2 != NULL, NULL);
 180         fail_unless(error == NULL, NULL);
 181         osync_format_env_register_objformat(env, format2);
 182
 183         OSyncFormatConverter *converter = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 184         fail_unless(converter != NULL, NULL);
 185         fail_unless(error == NULL, NULL);
 186
 187         fail_unless(osync_format_env_num_converters(env) == 0, NULL);
 188
 189         osync_format_env_register_converter(env, converter);
 190
 191         fail_unless(osync_format_env_num_converters(env) == 1, NULL);
 192         fail_unless(osync_format_env_nth_converter(env, 0) == converter, NULL);
 193
 194         osync_converter_unref(converter);
 195
 196         osync_format_env_unref(env);
 197
 198         osync_objformat_unref(format1);
 199         osync_objformat_unref(format2);
 200
 201         destroy_testbed(testbed);
 202 }
 203 END_TEST
 204
 205 START_TEST (conv_env_converter_find)
 206 {
 207         char *testbed = setup_testbed(NULL);
 208
 209         OSyncError *error = NULL;
 210         OSyncFormatEnv *env = osync_format_env_new(&error);
 211         fail_unless(env != NULL, NULL);
 212         fail_unless(error == NULL, NULL);
 213
 214         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 215         fail_unless(format1 != NULL, NULL);
 216         fail_unless(error == NULL, NULL);
 217         osync_format_env_register_objformat(env, format1);
 218
 219         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 220         fail_unless(format2 != NULL, NULL);
 221         fail_unless(error == NULL, NULL);
 222         osync_format_env_register_objformat(env, format2);
 223
 224         OSyncFormatConverter *converter = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 225         fail_unless(converter != NULL, NULL);
 226         fail_unless(error == NULL, NULL);
 227
 228         osync_format_env_register_converter(env, converter);
 229         osync_converter_unref(converter);
 230
 231         fail_unless(osync_format_env_find_converter(env, format1, format2) == converter, NULL);
 232
 233         osync_format_env_unref(env);
 234
 235         osync_objformat_unref(format1);
 236         osync_objformat_unref(format2);
 237
 238         destroy_testbed(testbed);
 239 }
 240 END_TEST
 241
 242 START_TEST (conv_env_converter_find_false)
 243 {
 244         char *testbed = setup_testbed(NULL);
 245
 246         OSyncError *error = NULL;
 247         OSyncFormatEnv *env = osync_format_env_new(&error);
 248         fail_unless(env != NULL, NULL);
 249         fail_unless(error == NULL, NULL);
 250
 251         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 252         fail_unless(format1 != NULL, NULL);
 253         fail_unless(error == NULL, NULL);
 254         osync_format_env_register_objformat(env, format1);
 255
 256         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 257         fail_unless(format2 != NULL, NULL);
 258         fail_unless(error == NULL, NULL);
 259         osync_format_env_register_objformat(env, format2);
 260
 261         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
 262         fail_unless(format3 != NULL, NULL);
 263         fail_unless(error == NULL, NULL);
 264         osync_format_env_register_objformat(env, format3);
 265
 266         OSyncFormatConverter *converter = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 267         fail_unless(converter != NULL, NULL);
 268         fail_unless(error == NULL, NULL);
 269
 270         osync_format_env_register_converter(env, converter);
 271         osync_converter_unref(converter);
 272
 273         fail_unless(osync_format_env_find_converter(env, format1, format3) == NULL, NULL);
 274         fail_unless(osync_format_env_find_converter(env, format2, format1) == NULL, NULL);
 275
 276         osync_format_env_unref(env);
 277
 278         osync_objformat_unref(format1);
 279         osync_objformat_unref(format2);
 280         osync_objformat_unref(format3);
 281
 282         destroy_testbed(testbed);
 283 }
 284 END_TEST
 285
 286 osync_bool filter_hook(OSyncData *data, const char *config)
 287 {
 288         return TRUE;
 289 }
 290
 291 START_TEST (conv_env_register_filter)
 292 {
 293         char *testbed = setup_testbed(NULL);
 294
 295         OSyncError *error = NULL;
 296         OSyncFormatEnv *env = osync_format_env_new(&error);
 297         fail_unless(env != NULL, NULL);
 298         fail_unless(error == NULL, NULL);
 299
 300         OSyncCustomFilter *filter = osync_custom_filter_new("format", "objtype", "name", filter_hook, &error);
 301         fail_unless(filter != NULL, NULL);
 302         fail_unless(error == NULL, NULL);
 303
 304         osync_format_env_register_filter(env, filter);
 305
 306         osync_custom_filter_unref(filter);
 307
 308         osync_format_env_unref(env);
 309
 310         destroy_testbed(testbed);
 311 }
 312 END_TEST
 313
 314 START_TEST (conv_env_register_filter_count)
 315 {
 316         char *testbed = setup_testbed(NULL);
 317
 318         OSyncError *error = NULL;
 319         OSyncFormatEnv *env = osync_format_env_new(&error);
 320         fail_unless(env != NULL, NULL);
 321         fail_unless(error == NULL, NULL);
 322
 323         OSyncCustomFilter *filter = osync_custom_filter_new("format", "objtype", "name", filter_hook, &error);
 324         fail_unless(filter != NULL, NULL);
 325         fail_unless(error == NULL, NULL);
 326
 327         fail_unless(osync_format_env_num_filters(env) == 0, NULL);
 328
 329         osync_format_env_register_filter(env, filter);
 330
 331         fail_unless(osync_format_env_num_filters(env) == 1, NULL);
 332         fail_unless(osync_format_env_nth_filter(env, 0) == filter, NULL);
 333
 334         osync_custom_filter_unref(filter);
 335
 336         osync_format_env_unref(env);
 337
 338         destroy_testbed(testbed);
 339 }
 340 END_TEST
 341
 342 #if 0
 343
 344 static osync_bool dummyconvert(void *user_data, char *input, int inpsize, char **output, int *outpsize, osync_bool *free_input, OSyncError **error)
 345 {
 346         *free_input = TRUE;
 347         *output = g_strdup("test");
 348         *outpsize = 5;
 349         return TRUE;
 350 }
 351
 352 static char dummy_data[1] = { 0 };
 353
 354 static OSyncChange *create_change(OSyncObjFormat *fmt, char *data, size_t datasize)
 355 {
 356         OSyncChange *chg = osync_change_new();
 357         osync_change_set_objformat(chg, fmt);
 358         osync_change_set_data(chg, data, datasize, TRUE);
 359         return chg;
 360 }
 361 #endif
 362
 363 static void format_simple_destroy(char *data, unsigned int size, void *user_data)
 364 {
 365         osync_assert(data);
 366         if (size)
 367                 g_free(data);
 368 }
 369
 370
 371 START_TEST (conv_find_path)
 372 {
 373         char *testbed = setup_testbed(NULL);
 374
 375         OSyncError *error = NULL;
 376         OSyncFormatEnv *env = osync_format_env_new(&error);
 377         fail_unless(env != NULL, NULL);
 378         fail_unless(error == NULL, NULL);
 379
 380         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 381         fail_unless(format1 != NULL, NULL);
 382         fail_unless(error == NULL, NULL);
 383         osync_format_env_register_objformat(env, format1);
 384         osync_objformat_set_destroy_func(format1, format_simple_destroy);
 385
 386         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 387         fail_unless(format2 != NULL, NULL);
 388         fail_unless(error == NULL, NULL);
 389         osync_format_env_register_objformat(env, format2);
 390         osync_objformat_set_destroy_func(format2, format_simple_destroy);
 391
 392         OSyncFormatConverter *converter = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 393         fail_unless(converter != NULL, NULL);
 394         fail_unless(error == NULL, NULL);
 395         osync_format_env_register_converter(env, converter);
 396         osync_converter_unref(converter);
 397
 398         OSyncData *data1 = osync_data_new(g_strdup("data"), 5, format1, &error);
 399         fail_unless(data1 != NULL, NULL);
 400         fail_unless(error == NULL, NULL);
 401
 402         OSyncData *data2 = osync_data_new(g_strdup("data"), 5, format2, &error);
 403         fail_unless(data2 != NULL, NULL);
 404         fail_unless(error == NULL, NULL);
 405
 406
 407         OSyncFormatConverterPath *path = osync_format_env_find_path_with_detectors(env, data1, format2, NULL, &error);
 408         fail_unless(path != NULL, NULL);
 409         fail_unless(error == NULL, NULL);
 410
 411         fail_unless(osync_converter_path_num_edges(path) == 1, NULL);
 412         fail_unless(osync_converter_path_nth_edge(path, 0) == converter, NULL);
 413
 414         osync_converter_path_unref(path);
 415
 416         // intended to fail
 417         path = osync_format_env_find_path_with_detectors(env, data2, format1, NULL, &error);
 418         fail_unless(path == NULL, NULL);
 419         fail_unless(error != NULL, NULL);
 420         osync_error_unref(&error);
 421
 422         osync_format_env_unref(env);
 423
 424         osync_data_unref(data1);
 425         osync_data_unref(data2);
 426         osync_objformat_unref(format1);
 427         osync_objformat_unref(format2);
 428
 429         destroy_testbed(testbed);
 430 }
 431 END_TEST
 432
 433 START_TEST (conv_find_path2)
 434 {
 435         char *testbed = setup_testbed(NULL);
 436
 437         OSyncError *error = NULL;
 438         OSyncFormatEnv *env = osync_format_env_new(&error);
 439         fail_unless(env != NULL, NULL);
 440         fail_unless(error == NULL, NULL);
 441
 442         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 443         fail_unless(format1 != NULL, NULL);
 444         fail_unless(error == NULL, NULL);
 445         osync_objformat_set_destroy_func(format1, format_simple_destroy);
 446         osync_format_env_register_objformat(env, format1);
 447
 448         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 449         fail_unless(format2 != NULL, NULL);
 450         fail_unless(error == NULL, NULL);
 451         osync_objformat_set_destroy_func(format2, format_simple_destroy);
 452         osync_format_env_register_objformat(env, format2);
 453
 454         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
 455         fail_unless(format3 != NULL, NULL);
 456         fail_unless(error == NULL, NULL);
 457         osync_objformat_set_destroy_func(format3, format_simple_destroy);
 458         osync_format_env_register_objformat(env, format3);
 459
 460         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 461         fail_unless(converter1 != NULL, NULL);
 462         fail_unless(error == NULL, NULL);
 463         osync_format_env_register_converter(env, converter1);
 464         osync_converter_unref(converter1);
 465
 466         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format3, convert_func, &error);
 467         fail_unless(converter2 != NULL, NULL);
 468         fail_unless(error == NULL, NULL);
 469         osync_format_env_register_converter(env, converter2);
 470         osync_converter_unref(converter2);
 471
 472         OSyncData *data1 = osync_data_new(g_strdup("data"), 5, format1, &error);
 473         fail_unless(data1 != NULL, NULL);
 474         fail_unless(error == NULL, NULL);
 475
 476
 477         OSyncFormatConverterPath *path = osync_format_env_find_path_with_detectors(env, data1, format3, NULL, &error);
 478         fail_unless(path != NULL, NULL);
 479         fail_unless(error == NULL, NULL);
 480
 481         fail_unless(osync_converter_path_num_edges(path) == 2, NULL);
 482         fail_unless(osync_converter_path_nth_edge(path, 0) == converter1, NULL);
 483         fail_unless(osync_converter_path_nth_edge(path, 1) == converter2, NULL);
 484
 485         osync_converter_path_unref(path);
 486
 487         osync_format_env_unref(env);
 488
 489         osync_data_unref(data1);
 490         osync_objformat_unref(format1);
 491         osync_objformat_unref(format2);
 492         osync_objformat_unref(format3);
 493
 494         destroy_testbed(testbed);
 495 }
 496 END_TEST
 497
 498 START_TEST (conv_find_path_false)
 499 {
 500         char *testbed = setup_testbed(NULL);
 501
 502         OSyncError *error = NULL;
 503         OSyncFormatEnv *env = osync_format_env_new(&error);
 504         fail_unless(env != NULL, NULL);
 505         fail_unless(error == NULL, NULL);
 506
 507         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 508         fail_unless(format1 != NULL, NULL);
 509         fail_unless(error == NULL, NULL);
 510         osync_format_env_register_objformat(env, format1);
 511
 512         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 513         fail_unless(format2 != NULL, NULL);
 514         fail_unless(error == NULL, NULL);
 515         osync_format_env_register_objformat(env, format2);
 516
 517         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
 518         fail_unless(format3 != NULL, NULL);
 519         fail_unless(error == NULL, NULL);
 520         osync_format_env_register_objformat(env, format3);
 521
 522         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 523         fail_unless(converter1 != NULL, NULL);
 524         fail_unless(error == NULL, NULL);
 525         osync_format_env_register_converter(env, converter1);
 526         osync_converter_unref(converter1);
 527
 528         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format2, convert_func, &error);
 529         fail_unless(converter2 != NULL, NULL);
 530         fail_unless(error == NULL, NULL);
 531         osync_format_env_register_converter(env, converter2);
 532         osync_converter_unref(converter2);
 533
 534         OSyncData *data1 = osync_data_new("data", 5, format1, &error);
 535         fail_unless(data1 != NULL, NULL);
 536         fail_unless(error == NULL, NULL);
 537
 538         // intended to fail
 539         OSyncFormatConverterPath *path = osync_format_env_find_path_with_detectors(env, data1, format3, NULL, &error);
 540         fail_unless(path == NULL, NULL);
 541         fail_unless(error != NULL, NULL);
 542         osync_error_unref(&error);
 543
 544         osync_format_env_unref(env);
 545
 546         osync_data_unref(data1);
 547         osync_objformat_unref(format1);
 548         osync_objformat_unref(format2);
 549         osync_objformat_unref(format3);
 550
 551         destroy_testbed(testbed);
 552 }
 553 END_TEST
 554
 555 START_TEST (conv_find_multi_path)
 556 {
 557         char *testbed = setup_testbed(NULL);
 558
 559         OSyncError *error = NULL;
 560         OSyncFormatEnv *env = osync_format_env_new(&error);
 561         fail_unless(env != NULL, NULL);
 562         fail_unless(error == NULL, NULL);
 563
 564         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 565         fail_unless(format1 != NULL, NULL);
 566         fail_unless(error == NULL, NULL);
 567         osync_objformat_set_destroy_func(format1, format_simple_destroy);
 568         osync_format_env_register_objformat(env, format1);
 569
 570         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 571         fail_unless(format2 != NULL, NULL);
 572         fail_unless(error == NULL, NULL);
 573         osync_objformat_set_destroy_func(format2, format_simple_destroy);
 574         osync_format_env_register_objformat(env, format2);
 575
 576         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
 577         fail_unless(format3 != NULL, NULL);
 578         fail_unless(error == NULL, NULL);
 579         osync_objformat_set_destroy_func(format3, format_simple_destroy);
 580         osync_format_env_register_objformat(env, format3);
 581
 582         OSyncObjFormat *format4 = osync_objformat_new("format4", "objtype", &error);
 583         fail_unless(format4 != NULL, NULL);
 584         fail_unless(error == NULL, NULL);
 585         osync_objformat_set_destroy_func(format4, format_simple_destroy);
 586         osync_format_env_register_objformat(env, format4);
 587
 588         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 589         fail_unless(converter1 != NULL, NULL);
 590         fail_unless(error == NULL, NULL);
 591         osync_format_env_register_converter(env, converter1);
 592         osync_converter_unref(converter1);
 593
 594         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format4, convert_func, &error);
 595         fail_unless(converter2 != NULL, NULL);
 596         fail_unless(error == NULL, NULL);
 597         osync_format_env_register_converter(env, converter2);
 598         osync_converter_unref(converter2);
 599
 600         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format3, convert_func, &error);
 601         fail_unless(converter3 != NULL, NULL);
 602         fail_unless(error == NULL, NULL);
 603         osync_format_env_register_converter(env, converter3);
 604         osync_converter_unref(converter3);
 605
 606         OSyncFormatConverter *converter4 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format4, convert_func, &error);
 607         fail_unless(converter4 != NULL, NULL);
 608         fail_unless(error == NULL, NULL);
 609         osync_format_env_register_converter(env, converter4);
 610         osync_converter_unref(converter4);
 611
 612         OSyncData *data1 = osync_data_new(g_strdup("data"), 5, format1, &error);
 613         fail_unless(data1 != NULL, NULL);
 614         fail_unless(error == NULL, NULL);
 615
 616         OSyncFormatConverterPath *path = osync_format_env_find_path_with_detectors(env, data1, format4, NULL, &error);
 617         fail_unless(path != NULL, NULL);
 618         fail_unless(error == NULL, NULL);
 619
 620         fail_unless(osync_converter_path_num_edges(path) == 2, NULL);
 621         fail_unless(osync_converter_path_nth_edge(path, 0) == converter1, NULL);
 622         fail_unless(osync_converter_path_nth_edge(path, 1) == converter2, NULL);
 623
 624         osync_converter_path_unref(path);
 625
 626         osync_format_env_unref(env);
 627
 628         osync_data_unref(data1);
 629         osync_objformat_unref(format1);
 630         osync_objformat_unref(format2);
 631         osync_objformat_unref(format3);
 632         osync_objformat_unref(format4);
 633
 634         destroy_testbed(testbed);
 635 }
 636 END_TEST
 637
 638 START_TEST (conv_find_multi_path_with_preferred)
 639 {
 640         char *testbed = setup_testbed(NULL);
 641
 642         OSyncError *error = NULL;
 643         OSyncFormatEnv *env = osync_format_env_new(&error);
 644         fail_unless(env != NULL, NULL);
 645         fail_unless(error == NULL, NULL);
 646
 647         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 648         fail_unless(format1 != NULL, NULL);
 649         fail_unless(error == NULL, NULL);
 650         osync_objformat_set_destroy_func(format1, format_simple_destroy);
 651         osync_format_env_register_objformat(env, format1);
 652
 653         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 654         fail_unless(format2 != NULL, NULL);
 655         fail_unless(error == NULL, NULL);
 656         osync_objformat_set_destroy_func(format2, format_simple_destroy);
 657         osync_format_env_register_objformat(env, format2);
 658
 659         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
 660         fail_unless(format3 != NULL, NULL);
 661         fail_unless(error == NULL, NULL);
 662         osync_objformat_set_destroy_func(format3, format_simple_destroy);
 663         osync_format_env_register_objformat(env, format3);
 664
 665         OSyncObjFormat *format4 = osync_objformat_new("format4", "objtype", &error);
 666         fail_unless(format4 != NULL, NULL);
 667         fail_unless(error == NULL, NULL);
 668         osync_objformat_set_destroy_func(format4, format_simple_destroy);
 669         osync_format_env_register_objformat(env, format4);
 670
 671         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 672         fail_unless(converter1 != NULL, NULL);
 673         fail_unless(error == NULL, NULL);
 674         osync_format_env_register_converter(env, converter1);
 675         osync_converter_unref(converter1);
 676
 677         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format4, convert_func, &error);
 678         fail_unless(converter2 != NULL, NULL);
 679         fail_unless(error == NULL, NULL);
 680         osync_format_env_register_converter(env, converter2);
 681         osync_converter_unref(converter2);
 682
 683         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format3, convert_func, &error);
 684         fail_unless(converter3 != NULL, NULL);
 685         fail_unless(error == NULL, NULL);
 686         osync_format_env_register_converter(env, converter3);
 687         osync_converter_unref(converter3);
 688
 689         OSyncFormatConverter *converter4 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format4, convert_func, &error);
 690         fail_unless(converter4 != NULL, NULL);
 691         fail_unless(error == NULL, NULL);
 692         osync_format_env_register_converter(env, converter4);
 693         osync_converter_unref(converter4);
 694
 695         OSyncData *data1 = osync_data_new(g_strdup("data"), 5, format1, &error);
 696         fail_unless(data1 != NULL, NULL);
 697         fail_unless(error == NULL, NULL);
 698
 699         OSyncFormatConverterPath *path = osync_format_env_find_path_with_detectors(env, data1, format4, "format3", &error);
 700         fail_unless(path != NULL, NULL);
 701         fail_unless(error == NULL, NULL);
 702
 703         fail_unless(osync_converter_path_num_edges(path) == 2, NULL);
 704         fail_unless(osync_converter_path_nth_edge(path, 0) == converter3, NULL);
 705         fail_unless(osync_converter_path_nth_edge(path, 1) == converter4, NULL);
 706
 707         osync_converter_path_unref(path);
 708
 709         osync_format_env_unref(env);
 710
 711         osync_data_unref(data1);
 712         osync_objformat_unref(format1);
 713         osync_objformat_unref(format2);
 714         osync_objformat_unref(format3);
 715         osync_objformat_unref(format4);
 716
 717         destroy_testbed(testbed);
 718 }
 719 END_TEST
 720
 721 START_TEST (conv_find_circular_false)
 722 {
 723         char *testbed = setup_testbed(NULL);
 724
 725         OSyncError *error = NULL;
 726         OSyncFormatEnv *env = osync_format_env_new(&error);
 727         fail_unless(env != NULL, NULL);
 728         fail_unless(error == NULL, NULL);
 729
 730         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 731         fail_unless(format1 != NULL, NULL);
 732         fail_unless(error == NULL, NULL);
 733         osync_format_env_register_objformat(env, format1);
 734
 735         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 736         fail_unless(format2 != NULL, NULL);
 737         fail_unless(error == NULL, NULL);
 738         osync_format_env_register_objformat(env, format2);
 739
 740         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
 741         fail_unless(format3 != NULL, NULL);
 742         fail_unless(error == NULL, NULL);
 743         osync_format_env_register_objformat(env, format3);
 744
 745         OSyncObjFormat *format4 = osync_objformat_new("format4", "objtype", &error);
 746         fail_unless(format4 != NULL, NULL);
 747         fail_unless(error == NULL, NULL);
 748         osync_format_env_register_objformat(env, format4);
 749
 750         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 751         fail_unless(converter1 != NULL, NULL);
 752         fail_unless(error == NULL, NULL);
 753         osync_format_env_register_converter(env, converter1);
 754         osync_converter_unref(converter1);
 755
 756         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format3, convert_func, &error);
 757         fail_unless(converter2 != NULL, NULL);
 758         fail_unless(error == NULL, NULL);
 759         osync_format_env_register_converter(env, converter2);
 760         osync_converter_unref(converter2);
 761
 762         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format1, convert_func, &error);
 763         fail_unless(converter3 != NULL, NULL);
 764         fail_unless(error == NULL, NULL);
 765         osync_format_env_register_converter(env, converter3);
 766         osync_converter_unref(converter3);
 767
 768         OSyncData *data1 = osync_data_new("data", 5, format1, &error);
 769         fail_unless(data1 != NULL, NULL);
 770         fail_unless(error == NULL, NULL);
 771
 772         // intended to fail
 773         OSyncFormatConverterPath *path = osync_format_env_find_path_with_detectors(env, data1, format4, NULL, &error);
 774         fail_unless(path == NULL, NULL);
 775         fail_unless(error != NULL, NULL);
 776         osync_error_unref(&error);
 777
 778         osync_format_env_unref(env);
 779
 780         osync_data_unref(data1);
 781         osync_objformat_unref(format1);
 782         osync_objformat_unref(format2);
 783         osync_objformat_unref(format3);
 784         osync_objformat_unref(format4);
 785
 786         destroy_testbed(testbed);
 787 }
 788 END_TEST
 789
 790 START_TEST (conv_find_complex)
 791 {
 792         char *testbed = setup_testbed(NULL);
 793
 794         OSyncError *error = NULL;
 795         OSyncFormatEnv *env = osync_format_env_new(&error);
 796         fail_unless(env != NULL, NULL);
 797         fail_unless(error == NULL, NULL);
 798
 799         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 800         fail_unless(format1 != NULL, NULL);
 801         fail_unless(error == NULL, NULL);
 802         osync_objformat_set_destroy_func(format1, format_simple_destroy);
 803         osync_format_env_register_objformat(env, format1);
 804
 805         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 806         fail_unless(format2 != NULL, NULL);
 807         fail_unless(error == NULL, NULL);
 808         osync_objformat_set_destroy_func(format2, format_simple_destroy);
 809         osync_format_env_register_objformat(env, format2);
 810
 811         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
 812         fail_unless(format3 != NULL, NULL);
 813         fail_unless(error == NULL, NULL);
 814         osync_objformat_set_destroy_func(format3, format_simple_destroy);
 815         osync_format_env_register_objformat(env, format3);
 816
 817         OSyncObjFormat *format4 = osync_objformat_new("format4", "objtype", &error);
 818         fail_unless(format4 != NULL, NULL);
 819         fail_unless(error == NULL, NULL);
 820         osync_objformat_set_destroy_func(format4, format_simple_destroy);
 821         osync_format_env_register_objformat(env, format4);
 822
 823         OSyncObjFormat *format5 = osync_objformat_new("format5", "objtype", &error);
 824         fail_unless(format5 != NULL, NULL);
 825         fail_unless(error == NULL, NULL);
 826         osync_objformat_set_destroy_func(format5, format_simple_destroy);
 827         osync_format_env_register_objformat(env, format5);
 828
 829         OSyncObjFormat *format6 = osync_objformat_new("format6", "objtype", &error);
 830         fail_unless(format6 != NULL, NULL);
 831         fail_unless(error == NULL, NULL);
 832         osync_objformat_set_destroy_func(format6, format_simple_destroy);
 833         osync_format_env_register_objformat(env, format6);
 834
 835         OSyncObjFormat *format7 = osync_objformat_new("format7", "objtype", &error);
 836         fail_unless(format7 != NULL, NULL);
 837         fail_unless(error == NULL, NULL);
 838         osync_objformat_set_destroy_func(format7, format_simple_destroy);
 839         osync_format_env_register_objformat(env, format7);
 840
 841         OSyncObjFormat *format8 = osync_objformat_new("format8", "objtype", &error);
 842         fail_unless(format8 != NULL, NULL);
 843         fail_unless(error == NULL, NULL);
 844         osync_objformat_set_destroy_func(format8, format_simple_destroy);
 845         osync_format_env_register_objformat(env, format8);
 846
 847         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 848         fail_unless(converter1 != NULL, NULL);
 849         fail_unless(error == NULL, NULL);
 850         osync_format_env_register_converter(env, converter1);
 851         osync_converter_unref(converter1);
 852
 853         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format3, convert_func, &error);
 854         fail_unless(converter2 != NULL, NULL);
 855         fail_unless(error == NULL, NULL);
 856         osync_format_env_register_converter(env, converter2);
 857         osync_converter_unref(converter2);
 858
 859         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format4, convert_func, &error);
 860         fail_unless(converter3 != NULL, NULL);
 861         fail_unless(error == NULL, NULL);
 862         osync_format_env_register_converter(env, converter3);
 863         osync_converter_unref(converter3);
 864
 865         OSyncFormatConverter *converter4 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format5, convert_func, &error);
 866         fail_unless(converter4 != NULL, NULL);
 867         fail_unless(error == NULL, NULL);
 868         osync_format_env_register_converter(env, converter4);
 869         osync_converter_unref(converter4);
 870
 871         OSyncFormatConverter *converter5 = osync_converter_new(OSYNC_CONVERTER_CONV, format4, format7, convert_func, &error);
 872         fail_unless(converter5 != NULL, NULL);
 873         fail_unless(error == NULL, NULL);
 874         osync_format_env_register_converter(env, converter5);
 875         osync_converter_unref(converter5);
 876
 877         OSyncFormatConverter *converter6 = osync_converter_new(OSYNC_CONVERTER_CONV, format5, format7, convert_func, &error);
 878         fail_unless(converter6 != NULL, NULL);
 879         fail_unless(error == NULL, NULL);
 880         osync_format_env_register_converter(env, converter6);
 881         osync_converter_unref(converter6);
 882
 883         OSyncFormatConverter *converter7 = osync_converter_new(OSYNC_CONVERTER_CONV, format7, format8, convert_func, &error);
 884         fail_unless(converter7 != NULL, NULL);
 885         fail_unless(error == NULL, NULL);
 886         osync_format_env_register_converter(env, converter7);
 887         osync_converter_unref(converter7);
 888
 889         OSyncFormatConverter *converter8 = osync_converter_new(OSYNC_CONVERTER_CONV, format8, format6, convert_func, &error);
 890         fail_unless(converter8 != NULL, NULL);
 891         fail_unless(error == NULL, NULL);
 892         osync_format_env_register_converter(env, converter8);
 893         osync_converter_unref(converter8);
 894
 895         OSyncFormatConverter *converter9 = osync_converter_new(OSYNC_CONVERTER_CONV, format5, format6, convert_func, &error);
 896         fail_unless(converter9 != NULL, NULL);
 897         fail_unless(error == NULL, NULL);
 898         osync_format_env_register_converter(env, converter9);
 899         osync_converter_unref(converter9);
 900
 901         OSyncData *data1 = osync_data_new(g_strdup("data"), 5, format1, &error);
 902         fail_unless(data1 != NULL, NULL);
 903         fail_unless(error == NULL, NULL);
 904
 905         OSyncFormatConverterPath *path = osync_format_env_find_path_with_detectors(env, data1, format6, NULL, &error);
 906         fail_unless(path != NULL, NULL);
 907         fail_unless(error == NULL, NULL);
 908
 909         fail_unless(osync_converter_path_num_edges(path) == 3, NULL);
 910         fail_unless(osync_converter_path_nth_edge(path, 0) == converter2, NULL);
 911         fail_unless(osync_converter_path_nth_edge(path, 1) == converter4, NULL);
 912         fail_unless(osync_converter_path_nth_edge(path, 2) == converter9, NULL);
 913
 914         osync_converter_path_unref(path);
 915
 916         osync_format_env_unref(env);
 917
 918         osync_data_unref(data1);
 919         osync_objformat_unref(format1);
 920         osync_objformat_unref(format2);
 921         osync_objformat_unref(format3);
 922         osync_objformat_unref(format4);
 923         osync_objformat_unref(format5);
 924         osync_objformat_unref(format6);
 925         osync_objformat_unref(format7);
 926         osync_objformat_unref(format8);
 927
 928         destroy_testbed(testbed);
 929 }
 930 END_TEST
 931
 932 START_TEST (conv_find_multi_target)
 933 {
 934         char *testbed = setup_testbed(NULL);
 935
 936         OSyncError *error = NULL;
 937         OSyncFormatEnv *env = osync_format_env_new(&error);
 938         fail_unless(env != NULL, NULL);
 939         fail_unless(error == NULL, NULL);
 940
 941         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
 942         fail_unless(format1 != NULL, NULL);
 943         fail_unless(error == NULL, NULL);
 944         osync_format_env_register_objformat(env, format1);
 945
 946         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
 947         fail_unless(format2 != NULL, NULL);
 948         fail_unless(error == NULL, NULL);
 949         osync_format_env_register_objformat(env, format2);
 950
 951         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
 952         fail_unless(format3 != NULL, NULL);
 953         fail_unless(error == NULL, NULL);
 954         osync_format_env_register_objformat(env, format3);
 955
 956         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
 957         fail_unless(converter1 != NULL, NULL);
 958         fail_unless(error == NULL, NULL);
 959         osync_format_env_register_converter(env, converter1);
 960         osync_converter_unref(converter1);
 961
 962         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format3, convert_func, &error);
 963         fail_unless(converter2 != NULL, NULL);
 964         fail_unless(error == NULL, NULL);
 965         osync_format_env_register_converter(env, converter2);
 966         osync_converter_unref(converter2);
 967
 968         OSyncList *targets = NULL;
 969         targets = osync_list_prepend(targets, format2);
 970         targets = osync_list_prepend(targets, format3);
 971
 972         OSyncData *data1 = osync_data_new("data", 5, format1, &error);
 973         fail_unless(data1 != NULL, NULL);
 974         fail_unless(error == NULL, NULL);
 975
 976         OSyncFormatConverterPath *path = osync_format_env_find_path_formats_with_detectors(env, data1, targets, NULL, &error);
 977         fail_unless(path != NULL, NULL);
 978         fail_unless(error == NULL, NULL);
 979
 980         fail_unless(osync_converter_path_num_edges(path) == 1, NULL);
 981         fail_unless(osync_converter_path_nth_edge(path, 0) == converter1, NULL);
 982
 983         osync_converter_path_unref(path);
 984
 985         osync_format_env_unref(env);
 986
 987         osync_data_unref(data1);
 988         osync_objformat_unref(format1);
 989         osync_objformat_unref(format2);
 990         osync_objformat_unref(format3);
 991
 992         destroy_testbed(testbed);
 993 }
 994 END_TEST
 995
 996 START_TEST (conv_find_multi_target2)
 997 {
 998         char *testbed = setup_testbed(NULL);
 999
1000         OSyncError *error = NULL;
1001         OSyncFormatEnv *env = osync_format_env_new(&error);
1002         fail_unless(env != NULL, NULL);
1003         fail_unless(error == NULL, NULL);
1004
1005         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
1006         fail_unless(format1 != NULL, NULL);
1007         fail_unless(error == NULL, NULL);
1008         osync_format_env_register_objformat(env, format1);
1009
1010         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
1011         fail_unless(format2 != NULL, NULL);
1012         fail_unless(error == NULL, NULL);
1013         osync_format_env_register_objformat(env, format2);
1014
1015         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
1016         fail_unless(format3 != NULL, NULL);
1017         fail_unless(error == NULL, NULL);
1018         osync_format_env_register_objformat(env, format3);
1019
1020         OSyncObjFormat *format4 = osync_objformat_new("format4", "objtype", &error);
1021         fail_unless(format4 != NULL, NULL);
1022         fail_unless(error == NULL, NULL);
1023         osync_format_env_register_objformat(env, format4);
1024
1025         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
1026         fail_unless(converter1 != NULL, NULL);
1027         fail_unless(error == NULL, NULL);
1028         osync_format_env_register_converter(env, converter1);
1029         osync_converter_unref(converter1);
1030
1031         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format4, convert_func, &error);
1032         fail_unless(converter2 != NULL, NULL);
1033         fail_unless(error == NULL, NULL);
1034         osync_format_env_register_converter(env, converter2);
1035         osync_converter_unref(converter2);
1036
1037         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format3, convert_func, &error);
1038         fail_unless(converter3 != NULL, NULL);
1039         fail_unless(error == NULL, NULL);
1040         osync_format_env_register_converter(env, converter3);
1041         osync_converter_unref(converter3);
1042
1043         OSyncList *targets = NULL;
1044         targets = osync_list_prepend(targets, format4);
1045         targets = osync_list_prepend(targets, format3);
1046
1047         OSyncData *data1 = osync_data_new("data", 5, format1, &error);
1048         fail_unless(data1 != NULL, NULL);
1049         fail_unless(error == NULL, NULL);
1050
1051         OSyncFormatConverterPath *path = osync_format_env_find_path_formats_with_detectors(env, data1, targets, NULL, &error);
1052         fail_unless(path != NULL, NULL);
1053         fail_unless(error == NULL, NULL);
1054
1055         fail_unless(osync_converter_path_num_edges(path) == 1, NULL);
1056         fail_unless(osync_converter_path_nth_edge(path, 0) == converter3, NULL);
1057
1058         osync_converter_path_unref(path);
1059
1060         osync_format_env_unref(env);
1061
1062         osync_data_unref(data1);
1063         osync_objformat_unref(format1);
1064         osync_objformat_unref(format2);
1065         osync_objformat_unref(format3);
1066         osync_objformat_unref(format4);
1067
1068         destroy_testbed(testbed);
1069 }
1070 END_TEST
1071
1072 START_TEST (conv_find_multi_path_multi_target)
1073 {
1074         char *testbed = setup_testbed(NULL);
1075
1076         OSyncError *error = NULL;
1077         OSyncFormatEnv *env = osync_format_env_new(&error);
1078         fail_unless(env != NULL, NULL);
1079         fail_unless(error == NULL, NULL);
1080
1081         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
1082         fail_unless(format1 != NULL, NULL);
1083         fail_unless(error == NULL, NULL);
1084         osync_objformat_set_destroy_func(format1, format_simple_destroy);
1085         osync_format_env_register_objformat(env, format1);
1086
1087         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
1088         fail_unless(format2 != NULL, NULL);
1089         fail_unless(error == NULL, NULL);
1090         osync_objformat_set_destroy_func(format2, format_simple_destroy);
1091         osync_format_env_register_objformat(env, format2);
1092
1093         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
1094         fail_unless(format3 != NULL, NULL);
1095         fail_unless(error == NULL, NULL);
1096         osync_objformat_set_destroy_func(format3, format_simple_destroy);
1097         osync_format_env_register_objformat(env, format3);
1098
1099         OSyncObjFormat *format4 = osync_objformat_new("format4", "objtype", &error);
1100         fail_unless(format4 != NULL, NULL);
1101         fail_unless(error == NULL, NULL);
1102         osync_objformat_set_destroy_func(format4, format_simple_destroy);
1103         osync_format_env_register_objformat(env, format4);
1104
1105         OSyncObjFormat *format5 = osync_objformat_new("format5", "objtype", &error);
1106         fail_unless(format5 != NULL, NULL);
1107         fail_unless(error == NULL, NULL);
1108         osync_objformat_set_destroy_func(format5, format_simple_destroy);
1109         osync_format_env_register_objformat(env, format5);
1110
1111         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
1112         fail_unless(converter1 != NULL, NULL);
1113         fail_unless(error == NULL, NULL);
1114         osync_format_env_register_converter(env, converter1);
1115         osync_converter_unref(converter1);
1116
1117         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format4, convert_func, &error);
1118         fail_unless(converter2 != NULL, NULL);
1119         fail_unless(error == NULL, NULL);
1120         osync_format_env_register_converter(env, converter2);
1121         osync_converter_unref(converter2);
1122
1123         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format3, convert_func, &error);
1124         fail_unless(converter3 != NULL, NULL);
1125         fail_unless(error == NULL, NULL);
1126         osync_format_env_register_converter(env, converter3);
1127         osync_converter_unref(converter3);
1128
1129         OSyncFormatConverter *converter4 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format4, convert_func, &error);
1130         fail_unless(converter4 != NULL, NULL);
1131         fail_unless(error == NULL, NULL);
1132         osync_format_env_register_converter(env, converter4);
1133         osync_converter_unref(converter4);
1134
1135         OSyncFormatConverter *converter5 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format5, convert_func, &error);
1136         fail_unless(converter5 != NULL, NULL);
1137         fail_unless(error == NULL, NULL);
1138         osync_format_env_register_converter(env, converter5);
1139         osync_converter_unref(converter5);
1140
1141         OSyncList *targets = NULL;
1142         targets = osync_list_prepend(targets, format4);
1143         targets = osync_list_prepend(targets, format5);
1144
1145         OSyncData *data1 = osync_data_new(g_strdup("data"), 5, format1, &error);
1146         fail_unless(data1 != NULL, NULL);
1147         fail_unless(error == NULL, NULL);
1148
1149         OSyncFormatConverterPath *path = osync_format_env_find_path_formats_with_detectors(env, data1, targets, NULL, &error);
1150         fail_unless(path != NULL, NULL);
1151         fail_unless(error == NULL, NULL);
1152
1153         fail_unless(osync_converter_path_num_edges(path) == 2, NULL);
1154         fail_unless(osync_converter_path_nth_edge(path, 0) == converter1, NULL);
1155         fail_unless(osync_converter_path_nth_edge(path, 1) == converter2, NULL);
1156
1157         osync_converter_path_unref(path);
1158
1159         osync_format_env_unref(env);
1160
1161         osync_data_unref(data1);
1162         osync_objformat_unref(format1);
1163         osync_objformat_unref(format2);
1164         osync_objformat_unref(format3);
1165         osync_objformat_unref(format4);
1166         osync_objformat_unref(format5);
1167
1168         destroy_testbed(testbed);
1169 }
1170 END_TEST
1171
1172 START_TEST (conv_find_multi_path_multi_target_with_preferred)
1173 {
1174         char *testbed = setup_testbed(NULL);
1175
1176         OSyncError *error = NULL;
1177         OSyncFormatEnv *env = osync_format_env_new(&error);
1178         fail_unless(env != NULL, NULL);
1179         fail_unless(error == NULL, NULL);
1180
1181         OSyncObjFormat *format1 = osync_objformat_new("format1", "objtype", &error);
1182         fail_unless(format1 != NULL, NULL);
1183         fail_unless(error == NULL, NULL);
1184         osync_objformat_set_destroy_func(format1, format_simple_destroy);
1185         osync_format_env_register_objformat(env, format1);
1186
1187         OSyncObjFormat *format2 = osync_objformat_new("format2", "objtype", &error);
1188         fail_unless(format2 != NULL, NULL);
1189         fail_unless(error == NULL, NULL);
1190         osync_objformat_set_destroy_func(format2, format_simple_destroy);
1191         osync_format_env_register_objformat(env, format2);
1192
1193         OSyncObjFormat *format3 = osync_objformat_new("format3", "objtype", &error);
1194         fail_unless(format3 != NULL, NULL);
1195         fail_unless(error == NULL, NULL);
1196         osync_objformat_set_destroy_func(format3, format_simple_destroy);
1197         osync_format_env_register_objformat(env, format3);
1198
1199         OSyncObjFormat *format4 = osync_objformat_new("format4", "objtype", &error);
1200         fail_unless(format4 != NULL, NULL);
1201         fail_unless(error == NULL, NULL);
1202         osync_objformat_set_destroy_func(format4, format_simple_destroy);
1203         osync_format_env_register_objformat(env, format4);
1204
1205         OSyncObjFormat *format5 = osync_objformat_new("format5", "objtype", &error);
1206         fail_unless(format5 != NULL, NULL);
1207         fail_unless(error == NULL, NULL);
1208         osync_objformat_set_destroy_func(format5, format_simple_destroy);
1209         osync_format_env_register_objformat(env, format5);
1210
1211         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_func, &error);
1212         fail_unless(converter1 != NULL, NULL);
1213         fail_unless(error == NULL, NULL);
1214         osync_format_env_register_converter(env, converter1);
1215         osync_converter_unref(converter1);
1216
1217         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format4, convert_func, &error);
1218         fail_unless(converter2 != NULL, NULL);
1219         fail_unless(error == NULL, NULL);
1220         osync_format_env_register_converter(env, converter2);
1221         osync_converter_unref(converter2);
1222
1223         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format3, convert_func, &error);
1224         fail_unless(converter3 != NULL, NULL);
1225         fail_unless(error == NULL, NULL);
1226         osync_format_env_register_converter(env, converter3);
1227         osync_converter_unref(converter3);
1228
1229         OSyncFormatConverter *converter4 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format4, convert_func, &error);
1230         fail_unless(converter4 != NULL, NULL);
1231         fail_unless(error == NULL, NULL);
1232         osync_format_env_register_converter(env, converter4);
1233         osync_converter_unref(converter4);
1234
1235         OSyncFormatConverter *converter5 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format5, convert_func, &error);
1236         fail_unless(converter5 != NULL, NULL);
1237         fail_unless(error == NULL, NULL);
1238         osync_format_env_register_converter(env, converter5);
1239         osync_converter_unref(converter5);
1240
1241         OSyncList *targets = NULL;
1242         targets = osync_list_prepend(targets, format4);
1243         targets = osync_list_prepend(targets, format5);
1244
1245         OSyncData *data1 = osync_data_new(g_strdup("data"), 5, format1, &error);
1246         fail_unless(data1 != NULL, NULL);
1247         fail_unless(error == NULL, NULL);
1248
1249         OSyncFormatConverterPath *path = osync_format_env_find_path_formats_with_detectors(env, data1, targets, "format5", &error);
1250         fail_unless(path != NULL, NULL);
1251         fail_unless(error == NULL, NULL);
1252
1253         fail_unless(osync_converter_path_num_edges(path) == 2, NULL);
1254         fail_unless(osync_converter_path_nth_edge(path, 0) == converter3, NULL);
1255         fail_unless(osync_converter_path_nth_edge(path, 1) == converter5, NULL);
1256
1257         osync_converter_path_unref(path);
1258
1259         osync_format_env_unref(env);
1260
1261         osync_data_unref(data1);
1262         osync_objformat_unref(format1);
1263         osync_objformat_unref(format2);
1264         osync_objformat_unref(format3);
1265         osync_objformat_unref(format4);
1266         osync_objformat_unref(format5);
1267
1268         destroy_testbed(testbed);
1269 }
1270 END_TEST
1271
1272 static osync_bool convert_addtest(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error)
1273 {
1274         *free_input = TRUE;
1275         *output = g_strdup_printf("%stest", input);
1276         *outpsize = inpsize + 4;
1277         return TRUE;
1278 }
1279
1280 static osync_bool convert_remtest(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error)
1281 {
1282         *free_input = TRUE;
1283         *output = strdup(input);
1284         char *test = g_strrstr(*output, "test");
1285         *outpsize = 0;
1286         if (test) {
1287                 test[0] = 0;
1288                 *outpsize = inpsize - 4;
1289                 return TRUE;
1290         } else {
1291                 output = NULL;
1292                 return FALSE;
1293         }
1294 }
1295
1296 static osync_bool convert_addtest2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error)
1297 {
1298         *output = g_strdup_printf("%stest2", input);
1299         *outpsize = inpsize + 5;
1300         *free_input = TRUE;
1301         return TRUE;
1302 }
1303
1304 static osync_bool convert_remtest2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error)
1305 {
1306         *free_input = TRUE;
1307         *output = strdup(input);
1308         char *test = g_strrstr(*output, "test2");
1309         *outpsize = 0;
1310         if (test) {
1311                 test[0] = 0;
1312                 *outpsize = inpsize - 4;
1313                 return TRUE;
1314         } else {
1315                 output = NULL;
1316                 return FALSE;
1317         }
1318 }
1319
1320 START_TEST (conv_env_convert1)
1321 {
1322         OSyncError *error = NULL;
1323         OSyncFormatEnv *env = osync_format_env_new(&error);
1324         fail_unless(env != NULL, NULL);
1325         fail_unless(error == NULL, NULL);
1326
1327         OSyncObjFormat *format1 = osync_objformat_new("F1", "O1", &error);
1328         fail_unless(format1 != NULL, NULL);
1329         fail_unless(error == NULL, NULL);
1330         osync_format_env_register_objformat(env, format1);
1331         osync_objformat_set_destroy_func(format1, format_simple_destroy);
1332
1333         OSyncObjFormat *format2 = osync_objformat_new("F2", "O1", &error);
1334         fail_unless(format2 != NULL, NULL);
1335         fail_unless(error == NULL, NULL);
1336         osync_format_env_register_objformat(env, format2);
1337         osync_objformat_set_destroy_func(format2, format_simple_destroy);
1338
1339         OSyncObjFormat *format3 = osync_objformat_new("F3", "O1", &error);
1340         fail_unless(format3 != NULL, NULL);
1341         fail_unless(error == NULL, NULL);
1342         osync_format_env_register_objformat(env, format3);
1343         osync_objformat_set_destroy_func(format3, format_simple_destroy);
1344
1345         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_addtest, &error);
1346         fail_unless(converter1 != NULL, NULL);
1347         fail_unless(error == NULL, NULL);
1348         osync_format_env_register_converter(env, converter1);
1349         osync_converter_unref(converter1);
1350
1351         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format3, convert_addtest2, &error);
1352         fail_unless(converter2 != NULL, NULL);
1353         fail_unless(error == NULL, NULL);
1354         osync_format_env_register_converter(env, converter2);
1355         osync_converter_unref(converter2);
1356
1357         mark_point();
1358
1359         OSyncData *data = osync_data_new(g_strdup("data"), 5, format1, &error);
1360         fail_unless(data != NULL, NULL);
1361         fail_unless(error == NULL, NULL);
1362
1363         mark_point();
1364
1365         OSyncFormatConverterPath *path = NULL;
1366         path = osync_format_env_find_path_with_detectors(env, data, format3, NULL, &error);
1367         osync_format_env_convert(env, path, data, &error);
1368         fail_unless(error == NULL, NULL);
1369
1370         char *buf;
1371         unsigned int size;
1372         osync_data_get_data(data, &buf, &size);
1373
1374         fail_unless(buf != NULL, NULL);
1375         fail_unless(!strcmp(buf, "datatesttest2"), NULL);
1376         OSyncObjFormat *format = osync_data_get_objformat(data);
1377         fail_unless(format == format3, NULL);
1378 }
1379 END_TEST
1380
1381 START_TEST (conv_env_convert_back)
1382 {
1383         OSyncError *error = NULL;
1384         OSyncFormatEnv *env = osync_format_env_new(&error);
1385         fail_unless(env != NULL, NULL);
1386         fail_unless(error == NULL, NULL);
1387
1388         OSyncObjFormat *format1 = osync_objformat_new("F1", "O1", &error);
1389         fail_unless(format1 != NULL, NULL);
1390         fail_unless(error == NULL, NULL);
1391         osync_objformat_set_destroy_func(format1, format_simple_destroy);
1392         osync_format_env_register_objformat(env, format1);
1393
1394         OSyncObjFormat *format2 = osync_objformat_new("F2", "O1", &error);
1395         fail_unless(format2 != NULL, NULL);
1396         fail_unless(error == NULL, NULL);
1397         osync_objformat_set_destroy_func(format2, format_simple_destroy);
1398         osync_format_env_register_objformat(env, format2);
1399
1400         OSyncObjFormat *format3 = osync_objformat_new("F3", "O1", &error);
1401         fail_unless(format3 != NULL, NULL);
1402         fail_unless(error == NULL, NULL);
1403         osync_objformat_set_destroy_func(format3, format_simple_destroy);
1404         osync_format_env_register_objformat(env, format3);
1405
1406         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_CONV, format1, format2, convert_addtest, &error);
1407         fail_unless(converter1 != NULL, NULL);
1408         fail_unless(error == NULL, NULL);
1409         osync_format_env_register_converter(env, converter1);
1410         osync_converter_unref(converter1);
1411
1412         OSyncFormatConverter *converter1_back = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format1, convert_remtest, &error);
1413         fail_unless(converter1_back != NULL, NULL);
1414         fail_unless(error == NULL, NULL);
1415         osync_format_env_register_converter(env, converter1_back);
1416         osync_converter_unref(converter1_back);
1417
1418         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format3, convert_addtest2, &error);
1419         fail_unless(converter2 != NULL, NULL);
1420         fail_unless(error == NULL, NULL);
1421         osync_format_env_register_converter(env, converter2);
1422         osync_converter_unref(converter2);
1423
1424         OSyncFormatConverter *converter2_back = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format2, convert_remtest2, &error);
1425         fail_unless(converter2_back != NULL, NULL);
1426         fail_unless(error == NULL, NULL);
1427         osync_format_env_register_converter(env, converter2_back);
1428         osync_converter_unref(converter2_back);
1429
1430         mark_point();
1431
1432         OSyncData *data = osync_data_new(g_strdup("data"), 5, format1, &error);
1433         fail_unless(data != NULL, NULL);
1434         fail_unless(error == NULL, NULL);
1435
1436         mark_point();
1437
1438         OSyncFormatConverterPath *path = NULL;
1439         path = osync_format_env_find_path_with_detectors(env, data, format3, NULL, &error);
1440         osync_format_env_convert(env, path, data, &error);
1441         fail_unless(error == NULL, NULL);
1442
1443         char *buf;
1444         unsigned int size;
1445         osync_data_get_data(data, &buf, &size);
1446
1447         fail_unless(buf != NULL, NULL);
1448         fail_unless(!strcmp(buf, "datatesttest2"), NULL);
1449         OSyncObjFormat *format = osync_data_get_objformat(data);
1450         fail_unless(format == format3, NULL);
1451         fail_unless(path != NULL, NULL);
1452
1453         mark_point();
1454
1455         path = NULL;
1456         path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error);
1457         osync_format_env_convert(env, path, data, &error);
1458         fail_unless(error == NULL, NULL);
1459         fail_unless(path != NULL, NULL);
1460
1461         osync_data_get_data(data, &buf, &size);
1462
1463         fail_unless(buf != NULL, NULL);
1464         fail_unless(!strcmp(buf, "data"), NULL);
1465         format = osync_data_get_objformat(data);
1466         fail_unless(format == format1, NULL);
1467
1468 }
1469 END_TEST
1470
1471 START_TEST (conv_env_convert_desenc)
1472 {
1473         OSyncError *error = NULL;
1474         OSyncFormatEnv *env = osync_format_env_new(&error);
1475         fail_unless(env != NULL, NULL);
1476         fail_unless(error == NULL, NULL);
1477
1478         OSyncObjFormat *format1 = osync_objformat_new("F1", "O1", &error);
1479         fail_unless(format1 != NULL, NULL);
1480         fail_unless(error == NULL, NULL);
1481         osync_objformat_set_destroy_func(format1, format_simple_destroy);
1482         osync_format_env_register_objformat(env, format1);
1483
1484         OSyncObjFormat *format2 = osync_objformat_new("F2", "O1", &error);
1485         fail_unless(format2 != NULL, NULL);
1486         fail_unless(error == NULL, NULL);
1487         osync_objformat_set_destroy_func(format2, format_simple_destroy);
1488         osync_format_env_register_objformat(env, format2);
1489
1490         OSyncObjFormat *format3 = osync_objformat_new("F3", "O1", &error);
1491         fail_unless(format3 != NULL, NULL);
1492         fail_unless(error == NULL, NULL);
1493         osync_objformat_set_destroy_func(format3, format_simple_destroy);
1494         osync_format_env_register_objformat(env, format3);
1495
1496         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_DECAP, format1, format2, convert_addtest, &error);
1497         fail_unless(converter1 != NULL, NULL);
1498         fail_unless(error == NULL, NULL);
1499         osync_format_env_register_converter(env, converter1);
1500         osync_converter_unref(converter1);
1501
1502         OSyncFormatConverter *converter1_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format2, format1, convert_remtest, &error);
1503         fail_unless(converter1_back != NULL, NULL);
1504         fail_unless(error == NULL, NULL);
1505         osync_format_env_register_converter(env, converter1_back);
1506         osync_converter_unref(converter1_back);
1507
1508         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_DECAP, format2, format3, convert_addtest2, &error);
1509         fail_unless(converter2 != NULL, NULL);
1510         fail_unless(error == NULL, NULL);
1511         osync_format_env_register_converter(env, converter2);
1512         osync_converter_unref(converter2);
1513
1514         OSyncFormatConverter *converter2_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format3, format2, convert_remtest2, &error);
1515         fail_unless(converter2_back != NULL, NULL);
1516         fail_unless(error == NULL, NULL);
1517         osync_format_env_register_converter(env, converter2_back);
1518         osync_converter_unref(converter2_back);
1519
1520         mark_point();
1521
1522         OSyncData *data = osync_data_new(g_strdup("data"), 5, format1, &error);
1523         fail_unless(data != NULL, NULL);
1524         fail_unless(error == NULL, NULL);
1525
1526         mark_point();
1527
1528         OSyncFormatConverterPath *path = NULL;
1529         path = osync_format_env_find_path_with_detectors(env, data, format3, NULL, &error);
1530         osync_format_env_convert(env, path, data, &error);
1531         fail_unless(error == NULL, NULL);
1532
1533         char *buf;
1534         unsigned int size;
1535         osync_data_get_data(data, &buf, &size);
1536
1537         fail_unless(buf != NULL, NULL);
1538         fail_unless(!strcmp(buf, "datatesttest2"), NULL);
1539         OSyncObjFormat *format = osync_data_get_objformat(data);
1540         fail_unless(format == format3, NULL);
1541         fail_unless(path != NULL, NULL);
1542
1543         mark_point();
1544
1545         path = NULL;
1546         path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error);
1547         osync_format_env_convert(env, path, data, &error);
1548         fail_unless(error == NULL, NULL);
1549         fail_unless(path != NULL, NULL);
1550
1551         osync_data_get_data(data, &buf, &size);
1552
1553         fail_unless(buf != NULL, NULL);
1554         fail_unless(!strcmp(buf, "data"), NULL);
1555         format = osync_data_get_objformat(data);
1556         fail_unless(format == format1, NULL);
1557 }
1558 END_TEST
1559
1560 static osync_bool detect_true(const char *data, int size, void *userdata)
1561 {
1562         return TRUE;
1563 }
1564
1565 static osync_bool detect_false(const char *data, int size, void *userdata)
1566 {
1567         return FALSE;
1568 }
1569
1570 START_TEST (conv_env_convert_desenc_complex)
1571 {
1572   /* Test if the converter is going on the righ path, when the data detector
1573    * for the format reports a specific lower format
1574    */
1575
1576         OSyncError *error = NULL;
1577         OSyncFormatEnv *env = osync_format_env_new(&error);
1578         fail_unless(env != NULL, NULL);
1579         fail_unless(error == NULL, NULL);
1580
1581         OSyncObjFormat *format1 = osync_objformat_new("F1", "O1", &error);
1582         osync_format_env_register_objformat(env, format1);
1583         osync_objformat_set_destroy_func(format1, format_simple_destroy);
1584
1585         OSyncObjFormat *format2 = osync_objformat_new("F2", "O1", &error);
1586         osync_format_env_register_objformat(env, format2);
1587         osync_objformat_set_destroy_func(format2, format_simple_destroy);
1588
1589         OSyncObjFormat *format3 = osync_objformat_new("F3", "O1", &error);
1590         osync_format_env_register_objformat(env, format3);
1591         osync_objformat_set_destroy_func(format3, format_simple_destroy);
1592
1593         OSyncObjFormat *format4 = osync_objformat_new("F4", "O1", &error);
1594         osync_format_env_register_objformat(env, format4);
1595         osync_objformat_set_destroy_func(format4, format_simple_destroy);
1596
1597         OSyncObjFormat *format5 = osync_objformat_new("F5", "O1", &error);
1598         osync_format_env_register_objformat(env, format5);
1599         osync_objformat_set_destroy_func(format5, format_simple_destroy);
1600
1601         OSyncObjFormat *format6 = osync_objformat_new("F6", "O1", &error);
1602         osync_format_env_register_objformat(env, format6);
1603         osync_objformat_set_destroy_func(format6, format_simple_destroy);
1604
1605         /*** Detectors ***/
1606
1607         OSyncFormatConverter *detector1 = osync_converter_new_detector(format2, format4, detect_true, &error);
1608         fail_unless(detector1 != NULL, NULL);
1609         fail_unless(error == NULL, NULL);
1610         osync_format_env_register_converter(env, detector1);
1611 //      osync_converter_unref(detector1);
1612
1613         OSyncFormatConverter *detector2 = osync_converter_new_detector(format2, format3, detect_false, &error);
1614         fail_unless(detector2 != NULL, NULL);
1615         fail_unless(error == NULL, NULL);
1616         osync_format_env_register_converter(env, detector2);
1617 //      osync_converter_unref(detector2);
1618
1619         /*** Converter ***/
1620
1621         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_DECAP, format1, format2, convert_addtest, &error);
1622         osync_format_env_register_converter(env, converter1);
1623         osync_converter_unref(converter1);
1624
1625         OSyncFormatConverter *converter1_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format2, format1, convert_remtest, &error);
1626         osync_format_env_register_converter(env, converter1_back);
1627         osync_converter_unref(converter1_back);
1628
1629         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_DECAP, format2, format3, convert_addtest2, &error);
1630         osync_format_env_register_converter(env, converter2);
1631         osync_converter_unref(converter2);
1632
1633         OSyncFormatConverter *converter2_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format3, format2, convert_remtest2, &error);
1634         osync_format_env_register_converter(env, converter2_back);
1635         osync_converter_unref(converter2_back);
1636
1637         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_DECAP, format2, format4, convert_addtest2, &error);
1638         osync_format_env_register_converter(env, converter3);
1639         osync_converter_unref(converter3);
1640
1641         OSyncFormatConverter *converter3_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format4, format2, convert_remtest2, &error);
1642         osync_format_env_register_converter(env, converter3_back);
1643         osync_converter_unref(converter3_back);
1644
1645         OSyncFormatConverter *converter4 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format6, convert_addtest2, &error);
1646         osync_format_env_register_converter(env, converter4);
1647         osync_converter_unref(converter4);
1648
1649         OSyncFormatConverter *converter5 = osync_converter_new(OSYNC_CONVERTER_CONV, format4, format5, convert_addtest2, &error);
1650         osync_format_env_register_converter(env, converter5);
1651         osync_converter_unref(converter5);
1652
1653         OSyncFormatConverter *converter6 = osync_converter_new(OSYNC_CONVERTER_CONV, format5, format4, convert_remtest2, &error);
1654         osync_format_env_register_converter(env, converter6);
1655         osync_converter_unref(converter6);
1656
1657         OSyncFormatConverter *converter7 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format5, format6, convert_addtest2, &error);
1658         osync_format_env_register_converter(env, converter7);
1659         osync_converter_unref(converter7);
1660
1661         OSyncFormatConverter *converter7_back = osync_converter_new(OSYNC_CONVERTER_DECAP, format6, format5, convert_remtest2, &error);
1662         osync_format_env_register_converter(env, converter7_back);
1663         osync_converter_unref(converter7_back);
1664
1665         mark_point();
1666
1667         OSyncData *data = osync_data_new(g_strdup("data"), 5, format1, &error);
1668         fail_unless(data != NULL, NULL);
1669         fail_unless(error == NULL, NULL);
1670
1671         mark_point();
1672
1673
1674         OSyncFormatConverterPath *path = NULL;
1675         path = osync_format_env_find_path_with_detectors(env, data, format6, NULL, &error);
1676         fail_unless(path != NULL, NULL);
1677
1678         osync_format_env_convert(env, path, data, &error);
1679         fail_unless(error == NULL, NULL);
1680
1681         char *buf;
1682         unsigned int size;
1683         osync_data_get_data(data, &buf, &size);
1684
1685         fail_unless(buf != NULL, NULL);
1686         fail_unless(!strcmp(buf, "datatesttest2test2test2"), NULL);
1687         OSyncObjFormat *format = osync_data_get_objformat(data);
1688         fail_unless(format == format6, NULL);
1689
1690         mark_point();
1691         path = NULL;
1692         path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error);
1693         fail_unless(path != NULL, NULL);
1694
1695         osync_format_env_convert(env, path, data, &error);
1696         fail_unless(error == NULL, NULL);
1697
1698         osync_data_get_data(data, &buf, &size);
1699
1700         fail_unless(buf != NULL, NULL);
1701         fail_unless(!strcmp(buf, "data"), NULL);
1702         format = osync_data_get_objformat(data);
1703         fail_unless(format == format1, NULL);
1704 }
1705 END_TEST
1706
1707 START_TEST (conv_env_detect_and_convert)
1708 {
1709   /* The data will be detected as F3, so the shortest path should
1710    * not be taken because the path searching function should see that
1711    * the encapsulated data * is a F3 object, not a F4 object
1712    */
1713         OSyncError *error = NULL;
1714         OSyncFormatEnv *env = osync_format_env_new(&error);
1715         fail_unless(env != NULL, NULL);
1716         fail_unless(error == NULL, NULL);
1717
1718         OSyncObjFormat *format1 = osync_objformat_new("F1", "O1", &error);
1719         osync_format_env_register_objformat(env, format1);
1720         osync_objformat_set_destroy_func(format1, format_simple_destroy);
1721
1722         OSyncObjFormat *format2 = osync_objformat_new("F2", "O1", &error);
1723         osync_format_env_register_objformat(env, format2);
1724         osync_objformat_set_destroy_func(format2, format_simple_destroy);
1725
1726         OSyncObjFormat *format3 = osync_objformat_new("F3", "O1", &error);
1727         osync_format_env_register_objformat(env, format3);
1728         osync_objformat_set_destroy_func(format3, format_simple_destroy);
1729
1730         OSyncObjFormat *format4 = osync_objformat_new("F4", "O1", &error);
1731         osync_format_env_register_objformat(env, format4);
1732         osync_objformat_set_destroy_func(format4, format_simple_destroy);
1733
1734         /*** Detectors ***/
1735
1736         OSyncFormatConverter *detector1 = osync_converter_new_detector(format1, format2, detect_true, &error);
1737         fail_unless(detector1 != NULL, NULL);
1738         fail_unless(error == NULL, NULL);
1739         osync_format_env_register_converter(env, detector1);
1740 //      osync_converter_unref(detector1);
1741
1742         /* Detect F3, not F4 */
1743
1744         OSyncFormatConverter *detector2 = osync_converter_new_detector(format2, format3, detect_true, &error);
1745         fail_unless(detector2 != NULL, NULL);
1746         fail_unless(error == NULL, NULL);
1747         osync_format_env_register_converter(env, detector2);
1748 //      osync_converter_unref(detector2);
1749
1750         OSyncFormatConverter *detector3 = osync_converter_new_detector(format2, format4, detect_false, &error);
1751         fail_unless(detector3 != NULL, NULL);
1752         fail_unless(error == NULL, NULL);
1753         osync_format_env_register_converter(env, detector3);
1754 //      osync_converter_unref(detector3);
1755
1756         /*** Converter ***/
1757
1758         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_DECAP, format1, format2, convert_addtest, &error);
1759         osync_format_env_register_converter(env, converter1);
1760         osync_converter_unref(converter1);
1761
1762         OSyncFormatConverter *converter1_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format2, format1, convert_remtest, &error);
1763         osync_format_env_register_converter(env, converter1_back);
1764         osync_converter_unref(converter1_back);
1765
1766         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_DECAP, format2, format3, convert_addtest2, &error);
1767         osync_format_env_register_converter(env, converter2);
1768         osync_converter_unref(converter2);
1769
1770         OSyncFormatConverter *converter2_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format3, format2, convert_remtest2, &error);
1771         osync_format_env_register_converter(env, converter2_back);
1772         osync_converter_unref(converter2_back);
1773
1774         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_DECAP, format2, format4, convert_addtest2, &error);
1775         osync_format_env_register_converter(env, converter3);
1776         osync_converter_unref(converter3);
1777
1778         OSyncFormatConverter *converter3_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format4, format2, convert_remtest2, &error);
1779         osync_format_env_register_converter(env, converter3_back);
1780         osync_converter_unref(converter3_back);
1781
1782         OSyncFormatConverter *converter4 = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format4, convert_addtest2, &error);
1783         osync_format_env_register_converter(env, converter4);
1784         osync_converter_unref(converter4);
1785
1786         OSyncFormatConverter *converter5 = osync_converter_new(OSYNC_CONVERTER_CONV, format4, format3, convert_remtest2, &error);
1787         osync_format_env_register_converter(env, converter5);
1788         osync_converter_unref(converter5);
1789
1790
1791         mark_point();
1792
1793         OSyncData *data = osync_data_new(g_strdup("data"), 5, format1, &error);
1794         fail_unless(data != NULL, NULL);
1795         fail_unless(error == NULL, NULL);
1796
1797         mark_point();
1798
1799         OSyncFormatConverterPath *path = NULL;
1800         path = osync_format_env_find_path_with_detectors(env, data, format4, NULL, &error);
1801         fail_unless(path != NULL, NULL);
1802
1803         osync_format_env_convert(env, path, data, &error);
1804         fail_unless(error == NULL, NULL);
1805
1806         char *buf;
1807         unsigned int size;
1808         osync_data_get_data(data, &buf, &size);
1809
1810         fail_unless(buf != NULL, NULL);
1811         fail_unless(!strcmp(buf, "datatesttest2test2"), NULL);
1812         OSyncObjFormat *format = osync_data_get_objformat(data);
1813         fail_unless(format == format4, NULL);
1814
1815         mark_point();
1816
1817         path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error);
1818         fail_unless(path != NULL, NULL);
1819
1820         osync_format_env_convert(env, path, data, &error);
1821         fail_unless(error == NULL, NULL);
1822
1823         osync_data_get_data(data, &buf, &size);
1824
1825         fail_unless(buf != NULL, NULL);
1826         fail_unless(!strcmp(buf, "datatest"), NULL);
1827         format = osync_data_get_objformat(data);
1828         fail_unless(format == format1, NULL);
1829 }
1830 END_TEST
1831
1832 START_TEST(conv_prefer_not_desencap)
1833 {
1834   /* Test if the converter is getting the path that have no
1835    * lossy detectors
1836    *
1837    * F1 -- F2 -- F3 -- F5
1838    *   \              /
1839    *     --- F4 -----
1840    *
1841    * All converters are not lossy, except F1->F4.
1842    * The result path should be: F1 -> F2 -> F3 -> F5
1843    */
1844         OSyncError *error = NULL;
1845         OSyncFormatEnv *env = osync_format_env_new(&error);
1846         fail_unless(env != NULL, NULL);
1847         fail_unless(error == NULL, NULL);
1848
1849         OSyncObjFormat *format1 = osync_objformat_new("F1", "O1", &error);
1850         osync_format_env_register_objformat(env, format1);
1851         osync_objformat_set_destroy_func(format1, format_simple_destroy);
1852
1853         OSyncObjFormat *format2 = osync_objformat_new("F2", "O1", &error);
1854         osync_format_env_register_objformat(env, format2);
1855         osync_objformat_set_destroy_func(format2, format_simple_destroy);
1856
1857         OSyncObjFormat *format3 = osync_objformat_new("F3", "O1", &error);
1858         osync_format_env_register_objformat(env, format3);
1859         osync_objformat_set_destroy_func(format3, format_simple_destroy);
1860
1861         OSyncObjFormat *format4 = osync_objformat_new("F4", "O1", &error);
1862         osync_format_env_register_objformat(env, format4);
1863         osync_objformat_set_destroy_func(format4, format_simple_destroy);
1864
1865         OSyncObjFormat *format5 = osync_objformat_new("F5", "O1", &error);
1866         osync_format_env_register_objformat(env, format5);
1867         osync_objformat_set_destroy_func(format5, format_simple_destroy);
1868
1869         /*** Detectors ***/
1870
1871         OSyncFormatConverter *detector1 = osync_converter_new_detector(format1, format2, detect_true, &error);
1872         fail_unless(detector1 != NULL, NULL);
1873         fail_unless(error == NULL, NULL);
1874         osync_format_env_register_converter(env, detector1);
1875 //      osync_converter_unref(detector1);
1876
1877         /* Detect F3, not F4 */
1878
1879         OSyncFormatConverter *detector2 = osync_converter_new_detector(format2, format3, detect_true, &error);
1880         fail_unless(detector2 != NULL, NULL);
1881         fail_unless(error == NULL, NULL);
1882         osync_format_env_register_converter(env, detector2);
1883 //      osync_converter_unref(detector2);
1884
1885         OSyncFormatConverter *detector3 = osync_converter_new_detector(format2, format4, detect_false, &error);
1886         fail_unless(detector3 != NULL, NULL);
1887         fail_unless(error == NULL, NULL);
1888         osync_format_env_register_converter(env, detector3);
1889 //      osync_converter_unref(detector3);
1890
1891         /*** Converter ***/
1892
1893         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format1, format2, convert_addtest, &error);
1894         osync_format_env_register_converter(env, converter1);
1895         osync_converter_unref(converter1);
1896
1897         OSyncFormatConverter *converter1_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format2, format3, convert_addtest, &error);
1898         osync_format_env_register_converter(env, converter1_back);
1899         osync_converter_unref(converter1_back);
1900
1901         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format3, format5, convert_addtest, &error);
1902         osync_format_env_register_converter(env, converter2);
1903         osync_converter_unref(converter2);
1904
1905         OSyncFormatConverter *converter2_back = osync_converter_new(OSYNC_CONVERTER_DECAP, format1, format4, convert_addtest2, &error);
1906         osync_format_env_register_converter(env, converter2_back);
1907         osync_converter_unref(converter2_back);
1908
1909         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format4, format5, convert_addtest2, &error);
1910         osync_format_env_register_converter(env, converter3);
1911         osync_converter_unref(converter3);
1912
1913         mark_point();
1914
1915         OSyncData *data = osync_data_new(g_strdup("data"), 5, format1, &error);
1916         fail_unless(data != NULL, NULL);
1917         fail_unless(error == NULL, NULL);
1918
1919         mark_point();
1920
1921         OSyncFormatConverterPath *path = NULL;
1922         path = osync_format_env_find_path_with_detectors(env, data, format5, NULL, &error);
1923         fail_unless(path != NULL, NULL);
1924
1925         osync_format_env_convert(env, path, data, &error);
1926         fail_unless(error == NULL, NULL);
1927
1928         mark_point();
1929
1930         char *buf;
1931         unsigned int size;
1932         osync_data_get_data(data, &buf, &size);
1933
1934         fail_unless(buf != NULL, NULL);
1935         fail_unless(!strcmp(buf, "datatesttesttest"), NULL);
1936         OSyncObjFormat *format = osync_data_get_objformat(data);
1937         fail_unless(format == format5, NULL);
1938 }
1939 END_TEST
1940
1941 START_TEST(conv_prefer_same_objtype)
1942 {
1943   /* Test if the converter is getting the path
1944    * that doesn't change the objtype, even
1945    * if it is longer.
1946    *
1947    * Objtypes: F and G
1948    *
1949    * F1 -- F2 -- F3 -- F5 -- F6
1950    *   \
1951    *     --- G1
1952    *
1953    * The target list will be [ F6, G1 ].
1954    *
1955    * The result should be F6.
1956    */
1957         OSyncError *error = NULL;
1958         OSyncFormatEnv *env = osync_format_env_new(&error);
1959         fail_unless(env != NULL, NULL);
1960         fail_unless(error == NULL, NULL);
1961
1962         OSyncObjFormat *format1 = osync_objformat_new("F1", "F", &error);
1963         osync_format_env_register_objformat(env, format1);
1964         osync_objformat_set_destroy_func(format1, format_simple_destroy);
1965
1966         OSyncObjFormat *format2 = osync_objformat_new("F2", "F", &error);
1967         osync_format_env_register_objformat(env, format2);
1968         osync_objformat_set_destroy_func(format2, format_simple_destroy);
1969
1970         OSyncObjFormat *format3 = osync_objformat_new("F3", "F", &error);
1971         osync_format_env_register_objformat(env, format3);
1972         osync_objformat_set_destroy_func(format3, format_simple_destroy);
1973
1974         OSyncObjFormat *format4 = osync_objformat_new("F4", "F", &error);
1975         osync_format_env_register_objformat(env, format4);
1976         osync_objformat_set_destroy_func(format4, format_simple_destroy);
1977
1978         OSyncObjFormat *format5 = osync_objformat_new("F5", "F", &error);
1979         osync_format_env_register_objformat(env, format5);
1980         osync_objformat_set_destroy_func(format5, format_simple_destroy);
1981
1982         OSyncObjFormat *format6 = osync_objformat_new("F6", "F", &error);
1983         osync_format_env_register_objformat(env, format6);
1984         osync_objformat_set_destroy_func(format6, format_simple_destroy);
1985
1986         OSyncObjFormat *format_g1 = osync_objformat_new("G1", "G", &error);
1987         osync_format_env_register_objformat(env, format_g1);
1988         osync_objformat_set_destroy_func(format_g1, format_simple_destroy);
1989
1990         /*** Converter ***/
1991
1992         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format1, format2, convert_addtest, &error);
1993         osync_format_env_register_converter(env, converter1);
1994         osync_converter_unref(converter1);
1995
1996         OSyncFormatConverter *converter1_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format2, format3, convert_addtest, &error);
1997         osync_format_env_register_converter(env, converter1_back);
1998         osync_converter_unref(converter1_back);
1999
2000         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format3, format4, convert_addtest, &error);
2001         osync_format_env_register_converter(env, converter2);
2002         osync_converter_unref(converter2);
2003
2004         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format4, format5, convert_addtest, &error);
2005         osync_format_env_register_converter(env, converter3);
2006         osync_converter_unref(converter3);
2007
2008         OSyncFormatConverter *converter4 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format5, format6, convert_addtest, &error);
2009         osync_format_env_register_converter(env, converter4);
2010         osync_converter_unref(converter4);
2011
2012         OSyncFormatConverter *converter5 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format1, format_g1, convert_addtest2, &error);
2013         osync_format_env_register_converter(env, converter5);
2014         osync_converter_unref(converter5);
2015
2016         mark_point();
2017
2018         OSyncData *data = osync_data_new(g_strdup("data"), 5, format1, &error);
2019         fail_unless(data != NULL, NULL);
2020         fail_unless(error == NULL, NULL);
2021
2022         mark_point();
2023
2024         OSyncList* fmtlist = NULL;
2025         fmtlist = osync_list_prepend(fmtlist, format_g1);
2026         fmtlist = osync_list_prepend(fmtlist, format6);
2027
2028         OSyncFormatConverterPath *path = NULL;
2029         path = osync_format_env_find_path_formats_with_detectors(env, data, fmtlist, NULL, &error);
2030         fail_unless(path != NULL, NULL);
2031
2032         osync_format_env_convert(env, path, data, &error);
2033         fail_unless(error == NULL, NULL);
2034
2035         mark_point();
2036
2037         char *buf;
2038         unsigned int size;
2039         osync_data_get_data(data, &buf, &size);
2040
2041         fail_unless(buf != NULL, NULL);
2042         fail_unless(!strcmp(buf, "datatesttesttesttesttest"), NULL);
2043         OSyncObjFormat *format = osync_data_get_objformat(data);
2044         fail_unless(format == format6, NULL);
2045 }
2046 END_TEST
2047
2048 START_TEST(conv_prefer_not_lossy_objtype_change)
2049 {
2050   /* Test if the converter is getting the path
2051    * that have no lossy converters, even if
2052    * the objtype is being changed.
2053    *
2054    * Objtypes: F and G
2055    *
2056    * F1 -- F2 -- F3 -- F5 -- F6
2057    *   \
2058    *     --- G1
2059    *
2060    * The target list will be [ F6, G1 ].
2061    *
2062    * The converter F2 -> F3 is lossy.
2063    *
2064    * The result should be G1.
2065    */
2066         OSyncError *error = NULL;
2067         OSyncFormatEnv *env = osync_format_env_new(&error);
2068         fail_unless(env != NULL, NULL);
2069         fail_unless(error == NULL, NULL);
2070
2071         OSyncObjFormat *format1 = osync_objformat_new("F1", "F", &error);
2072         osync_format_env_register_objformat(env, format1);
2073         osync_objformat_set_destroy_func(format1, format_simple_destroy);
2074
2075         OSyncObjFormat *format2 = osync_objformat_new("F2", "F", &error);
2076         osync_format_env_register_objformat(env, format2);
2077         osync_objformat_set_destroy_func(format2, format_simple_destroy);
2078
2079         OSyncObjFormat *format3 = osync_objformat_new("F3", "F", &error);
2080         osync_format_env_register_objformat(env, format3);
2081         osync_objformat_set_destroy_func(format3, format_simple_destroy);
2082
2083         OSyncObjFormat *format4 = osync_objformat_new("F4", "F", &error);
2084         osync_format_env_register_objformat(env, format4);
2085         osync_objformat_set_destroy_func(format4, format_simple_destroy);
2086
2087         OSyncObjFormat *format5 = osync_objformat_new("F5", "F", &error);
2088         osync_format_env_register_objformat(env, format5);
2089         osync_objformat_set_destroy_func(format5, format_simple_destroy);
2090
2091         OSyncObjFormat *format6 = osync_objformat_new("F6", "F", &error);
2092         osync_format_env_register_objformat(env, format6);
2093         osync_objformat_set_destroy_func(format6, format_simple_destroy);
2094
2095         OSyncObjFormat *format_g1 = osync_objformat_new("G1", "G", &error);
2096         osync_format_env_register_objformat(env, format_g1);
2097         osync_objformat_set_destroy_func(format_g1, format_simple_destroy);
2098
2099         /*** Converter ***/
2100
2101         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format1, format2, convert_addtest, &error);
2102         osync_format_env_register_converter(env, converter1);
2103         osync_converter_unref(converter1);
2104
2105         OSyncFormatConverter *converter1_back = osync_converter_new(OSYNC_CONVERTER_DECAP, format2, format3, convert_addtest, &error); /* Lossy */
2106         osync_format_env_register_converter(env, converter1_back);
2107         osync_converter_unref(converter1_back);
2108
2109         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format3, format4, convert_addtest, &error);
2110         osync_format_env_register_converter(env, converter2);
2111         osync_converter_unref(converter2);
2112
2113         OSyncFormatConverter *converter3 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format4, format5, convert_addtest, &error);
2114         osync_format_env_register_converter(env, converter3);
2115         osync_converter_unref(converter3);
2116
2117         OSyncFormatConverter *converter4 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format5, format6, convert_addtest, &error);
2118         osync_format_env_register_converter(env, converter4);
2119         osync_converter_unref(converter4);
2120
2121         OSyncFormatConverter *converter5 = osync_converter_new(OSYNC_CONVERTER_ENCAP, format1, format_g1, convert_addtest2, &error);
2122         osync_format_env_register_converter(env, converter5);
2123         osync_converter_unref(converter5);
2124
2125         mark_point();
2126
2127         OSyncData *data = osync_data_new(g_strdup("data"), 5, format1, &error);
2128         fail_unless(data != NULL, NULL);
2129         fail_unless(error == NULL, NULL);
2130
2131         mark_point();
2132
2133         OSyncList* fmtlist = NULL;
2134         fmtlist = osync_list_prepend(fmtlist, format_g1);
2135         fmtlist = osync_list_prepend(fmtlist, format6);
2136
2137         OSyncFormatConverterPath *path = NULL;
2138         path = osync_format_env_find_path_formats_with_detectors(env, data, fmtlist, NULL, &error);
2139         fail_unless(path != NULL, NULL);
2140
2141         osync_format_env_convert(env, path, data, &error);
2142         fail_unless(error == NULL, NULL);
2143
2144         mark_point();
2145
2146         char *buf;
2147         unsigned int size;
2148         osync_data_get_data(data, &buf, &size);
2149
2150         fail_unless(buf != NULL, NULL);
2151         fail_unless(!strcmp(buf, "datatest2"), NULL);
2152         OSyncObjFormat *format = osync_data_get_objformat(data);
2153         fail_unless(format == format_g1, NULL);
2154 }
2155 END_TEST
2156
2157 START_TEST (conv_env_detect_false)
2158 {
2159
2160         OSyncError *error = NULL;
2161         OSyncFormatEnv *env = osync_format_env_new(&error);
2162         fail_unless(env != NULL, NULL);
2163         fail_unless(error == NULL, NULL);
2164
2165         OSyncObjFormat *format1 = osync_objformat_new("F1", "O1", &error);
2166         osync_format_env_register_objformat(env, format1);
2167         osync_objformat_set_destroy_func(format1, format_simple_destroy);
2168
2169         OSyncObjFormat *format2 = osync_objformat_new("F2", "O1", &error);
2170         osync_format_env_register_objformat(env, format2);
2171         osync_objformat_set_destroy_func(format2, format_simple_destroy);
2172
2173         OSyncObjFormat *format3 = osync_objformat_new("F3", "O1", &error);
2174         osync_format_env_register_objformat(env, format3);
2175         osync_objformat_set_destroy_func(format3, format_simple_destroy);
2176
2177         /*** Detectors ***/
2178
2179         OSyncFormatConverter *detector1 = osync_converter_new_detector(format1, format2, detect_true, &error);
2180         fail_unless(detector1 != NULL, NULL);
2181         fail_unless(error == NULL, NULL);
2182         osync_format_env_register_converter(env, detector1);
2183 //      osync_converter_unref(detector1);
2184
2185         OSyncFormatConverter *detector2 = osync_converter_new_detector(format2, format3, detect_false, &error);
2186         fail_unless(detector2 != NULL, NULL);
2187         fail_unless(error == NULL, NULL);
2188         osync_format_env_register_converter(env, detector2);
2189 //      osync_converter_unref(detector2);
2190
2191         /*** Converter ***/
2192
2193         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_DECAP, format1, format2, convert_addtest, &error);
2194         osync_format_env_register_converter(env, converter1);
2195         osync_converter_unref(converter1);
2196
2197         OSyncFormatConverter *converter1_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format2, format1, convert_remtest, &error);
2198         osync_format_env_register_converter(env, converter1_back);
2199         osync_converter_unref(converter1_back);
2200
2201         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_DECAP, format2, format3, convert_addtest2, &error);
2202         osync_format_env_register_converter(env, converter2);
2203         osync_converter_unref(converter2);
2204
2205         OSyncFormatConverter *converter2_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format3, format2, convert_remtest2, &error);
2206         osync_format_env_register_converter(env, converter2_back);
2207         osync_converter_unref(converter2_back);
2208
2209         mark_point();
2210
2211         OSyncData *data = osync_data_new(g_strdup("data"), 5, format1, &error);
2212         fail_unless(data != NULL, NULL);
2213         fail_unless(error == NULL, NULL);
2214
2215         mark_point();
2216
2217         OSyncFormatConverterPath *path = NULL;
2218         path = osync_format_env_find_path_with_detectors(env, data, format3, NULL, &error);
2219         fail_unless(path == NULL, NULL);
2220         /* FIXME: clarify - this is really intended to fail?! If so deref error. */
2221         osync_error_unref(&error);
2222
2223         //fail_unless(!osync_format_env_convert(env, path, data, &error), NULL); // path is supposed to be null and this function has an assert on path
2224 }
2225 END_TEST
2226
2227 static osync_bool detect_plain_as_f2(const char *data, int size, void *userdata)
2228 {
2229         return TRUE;
2230 }
2231
2232 START_TEST (conv_env_decap_and_detect)
2233 {
2234         OSyncError *error = NULL;
2235         OSyncFormatEnv *env = osync_format_env_new(&error);
2236         fail_unless(env != NULL, NULL);
2237         fail_unless(error == NULL, NULL);
2238
2239         OSyncObjFormat *format1 = osync_objformat_new("F1", "O1", &error);
2240         osync_format_env_register_objformat(env, format1);
2241         osync_objformat_set_destroy_func(format1, format_simple_destroy);
2242
2243         OSyncObjFormat *format2 = osync_objformat_new("F2", "O1", &error);
2244         osync_format_env_register_objformat(env, format2);
2245         osync_objformat_set_destroy_func(format2, format_simple_destroy);
2246
2247         OSyncObjFormat *format3 = osync_objformat_new("F3", "O1", &error);
2248         osync_format_env_register_objformat(env, format3);
2249         osync_objformat_set_destroy_func(format3, format_simple_destroy);
2250
2251         OSyncObjFormat *format_plain = osync_objformat_new("plain", "O1", &error);
2252         osync_format_env_register_objformat(env, format_plain);
2253         osync_objformat_set_destroy_func(format_plain, format_simple_destroy);
2254
2255         /*** Detectors ***/
2256
2257         OSyncFormatConverter *detector1 = osync_converter_new_detector(format_plain, format2, detect_plain_as_f2, &error);
2258         fail_unless(detector1 != NULL, NULL);
2259         fail_unless(error == NULL, NULL);
2260         osync_format_env_register_converter(env, detector1);
2261 //      osync_converter_unref(detector1);
2262
2263         /*** Converter ***/
2264
2265         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_DECAP, format1, format_plain, convert_addtest, &error);
2266         osync_format_env_register_converter(env, converter1);
2267         osync_converter_unref(converter1);
2268
2269         OSyncFormatConverter *converter1_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format_plain, format1, convert_remtest, &error);
2270         osync_format_env_register_converter(env, converter1_back);
2271         osync_converter_unref(converter1_back);
2272
2273         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format3, convert_addtest, &error);
2274         osync_format_env_register_converter(env, converter2);
2275         osync_converter_unref(converter2);
2276
2277         OSyncFormatConverter *converter2_back = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format2, convert_remtest, &error);
2278         osync_format_env_register_converter(env, converter2_back);
2279         osync_converter_unref(converter2_back);
2280
2281         mark_point();
2282
2283         OSyncData *data = osync_data_new(g_strdup("data"), 5, format1, &error);
2284         fail_unless(data != NULL, NULL);
2285         fail_unless(error == NULL, NULL);
2286
2287         mark_point();
2288
2289         OSyncFormatConverterPath *path = NULL;
2290         path = osync_format_env_find_path_with_detectors(env, data, format3, NULL, &error);
2291         fail_unless(path != NULL, NULL);
2292
2293         char *buf;
2294         unsigned int size;
2295
2296         mark_point();
2297
2298         osync_format_env_convert(env, path, data, &error);
2299         fail_unless(error == NULL, NULL);
2300
2301         osync_data_get_data(data, &buf, &size);
2302
2303         fail_unless(buf != NULL, NULL);
2304         fail_unless(!strcmp(buf, "datatesttest"), NULL);
2305         OSyncObjFormat *format = osync_data_get_objformat(data);
2306         fail_unless(format == format3, NULL);
2307
2308         mark_point();
2309
2310         path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error);
2311         fail_unless(path != NULL, NULL);
2312
2313         osync_format_env_convert(env, path, data, &error);
2314         fail_unless(error == NULL, NULL);
2315
2316         mark_point();
2317
2318         osync_data_get_data(data, &buf, &size);
2319
2320         fail_unless(buf != NULL, NULL);
2321         fail_unless(!strcmp(buf, "data"), NULL);
2322         format = osync_data_get_objformat(data);
2323         fail_unless(format == format1, NULL);
2324 }
2325 END_TEST
2326
2327 static osync_bool detect_f2(const char *data, int size, void *userdata)
2328 {
2329         if (!strcmp(data, "F2"))
2330                 return TRUE;
2331         return FALSE;
2332 }
2333
2334 static osync_bool convert_f1_to_f2(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error)
2335 {
2336         fail_unless(!strcmp(input, "F1"), NULL);
2337
2338         *free_input = TRUE;
2339         *output = g_strdup("F2");
2340         *outpsize = 3;
2341         return TRUE;
2342 }
2343
2344 static osync_bool convert_f2_to_f1(char *input, unsigned int inpsize, char **output, unsigned int *outpsize, osync_bool *free_input, const char *config, void *userdata, OSyncError **error)
2345 {
2346         fail_unless(!strcmp(input, "F2"), NULL);
2347
2348         *free_input = TRUE;
2349         *output = g_strdup("F1");
2350         *outpsize = 3;
2351         return TRUE;
2352 }
2353
2354 START_TEST (conv_env_decap_and_detect2)
2355 {
2356         /*This is a more complicated version. Here we specify some data
2357          * for the change that needs to be converted and which only gets detected
2358          * if it really got converted by the decap */
2359         OSyncError *error = NULL;
2360         OSyncFormatEnv *env = osync_format_env_new(&error);
2361         fail_unless(env != NULL, NULL);
2362         fail_unless(error == NULL, NULL);
2363
2364         OSyncObjFormat *format1 = osync_objformat_new("F1", "O1", &error);
2365         osync_format_env_register_objformat(env, format1);
2366         osync_objformat_set_destroy_func(format1, format_simple_destroy);
2367
2368         OSyncObjFormat *format2 = osync_objformat_new("F2", "O1", &error);
2369         osync_format_env_register_objformat(env, format2);
2370         osync_objformat_set_destroy_func(format2, format_simple_destroy);
2371
2372         OSyncObjFormat *format3 = osync_objformat_new("F3", "O1", &error);
2373         osync_format_env_register_objformat(env, format3);
2374         osync_objformat_set_destroy_func(format3, format_simple_destroy);
2375
2376         OSyncObjFormat *format_plain = osync_objformat_new("plain", "O1", &error);
2377         osync_format_env_register_objformat(env, format_plain);
2378         osync_objformat_set_destroy_func(format_plain, format_simple_destroy);
2379
2380         /*** Detectors ***/
2381
2382         OSyncFormatConverter *detector1 = osync_converter_new_detector(format_plain, format2, detect_f2, &error);
2383         fail_unless(detector1 != NULL, NULL);
2384         fail_unless(error == NULL, NULL);
2385         osync_format_env_register_converter(env, detector1);
2386 //      osync_converter_unref(detector1);
2387
2388         /*** Converter ***/
2389
2390         OSyncFormatConverter *converter1 = osync_converter_new(OSYNC_CONVERTER_DECAP, format1, format_plain, convert_f1_to_f2, &error);
2391         osync_format_env_register_converter(env, converter1);
2392         osync_converter_unref(converter1);
2393
2394         OSyncFormatConverter *converter1_back = osync_converter_new(OSYNC_CONVERTER_ENCAP, format_plain, format1, convert_f2_to_f1, &error);
2395         osync_format_env_register_converter(env, converter1_back);
2396         osync_converter_unref(converter1_back);
2397
2398         OSyncFormatConverter *converter2 = osync_converter_new(OSYNC_CONVERTER_CONV, format2, format3, convert_addtest, &error);
2399         osync_format_env_register_converter(env, converter2);
2400         osync_converter_unref(converter2);
2401
2402         OSyncFormatConverter *converter2_back = osync_converter_new(OSYNC_CONVERTER_CONV, format3, format2, convert_remtest, &error);
2403         osync_format_env_register_converter(env, converter2_back);
2404         osync_converter_unref(converter2_back);
2405
2406         mark_point();
2407
2408         OSyncData *data = osync_data_new(g_strdup("F1"), 3, format1, &error);
2409         fail_unless(data != NULL, NULL);
2410         fail_unless(error == NULL, NULL);
2411
2412         mark_point();
2413
2414         OSyncFormatConverterPath *path = NULL;
2415         path = osync_format_env_find_path_with_detectors(env, data, format3, NULL, &error);
2416         fail_unless(path != NULL, NULL);
2417
2418         char *buf;
2419         unsigned int size;
2420
2421         mark_point();
2422
2423         osync_format_env_convert(env, path, data, &error);
2424         fail_unless(error == NULL, NULL);
2425
2426         osync_data_get_data(data, &buf, &size);
2427
2428         fail_unless(buf != NULL, NULL);
2429         fail_unless(!strcmp(buf, "F2test"), NULL);
2430         OSyncObjFormat *format = osync_data_get_objformat(data);
2431         fail_unless(format == format3, NULL);
2432
2433         mark_point();
2434
2435         path = osync_format_env_find_path_with_detectors(env, data, format1, NULL, &error);
2436         fail_unless(path != NULL, NULL);
2437
2438         osync_format_env_convert(env, path, data, &error);
2439         fail_unless(error == NULL, NULL);
2440
2441         mark_point();
2442
2443         osync_data_get_data(data, &buf, &size);
2444
2445         fail_unless(buf != NULL, NULL);
2446         fail_unless(!strcmp(buf, "F1"), NULL);
2447         format = osync_data_get_objformat(data);
2448         fail_unless(format == format1, NULL);
2449 }
2450 END_TEST
2451
2452
2453         // Gone?
2454         //create_case(s, "conv_env_osp_circular_false", conv_env_osp_circular_false);
2455         //create_case(s, "conv_env_osp_complex", conv_env_osp_complex);
2456
2457
2458         /*
2459          * osync_bool osync_format_env_load_plugins(OSyncFormatEnv *env, const char *path, OSyncError **error);
2460
2461 OSyncObjFormat *osync_format_env_detect_objformat(OSyncFormatEnv *env, OSyncData *data);
2462 OSyncObjFormat *osync_format_env_detect_objformat_full(OSyncFormatEnv *env, OSyncData *input, OSyncError **error);
2463
2464 osync_bool osync_format_env_convert(OSyncFormatEnv *env, OSyncFormatConverterPath *path, OSyncData *data, OSyncError **error);
2465
2466 OSyncFormatConverterPath *osync_format_env_find_path(OSyncFormatEnv *env, OSyncObjFormat *sourceformat, OSyncObjFormat *targetformat, OSyncError **error);
2467 OSyncFormatConverterPath *osync_format_env_find_path_formats(OSyncFormatEnv *env, OSyncObjFormat *sourceformat, OSyncObjFormat **targets, OSyncError **error);
2468          *
2469          */
2470
2471
2472 OSYNC_TESTCASE_START("format-env")
2473 OSYNC_TESTCASE_ADD(conv_env_create)
2474
2475 OSYNC_TESTCASE_ADD(conv_env_register_objformat)
2476 OSYNC_TESTCASE_ADD(conv_env_register_objformat_count)
2477 OSYNC_TESTCASE_ADD(conv_env_objformat_find)
2478 OSYNC_TESTCASE_ADD(conv_env_objformat_find_false)
2479
2480 OSYNC_TESTCASE_ADD(conv_env_register_converter)
2481 OSYNC_TESTCASE_ADD(conv_env_register_converter_count)
2482 OSYNC_TESTCASE_ADD(conv_env_converter_find)
2483 OSYNC_TESTCASE_ADD(conv_env_converter_find_false)
2484
2485 OSYNC_TESTCASE_ADD(conv_env_register_filter)
2486 OSYNC_TESTCASE_ADD(conv_env_register_filter_count)
2487
2488 OSYNC_TESTCASE_ADD(conv_find_path)
2489 OSYNC_TESTCASE_ADD(conv_find_path2)
2490 OSYNC_TESTCASE_ADD(conv_find_path_false)
2491 OSYNC_TESTCASE_ADD(conv_find_multi_path)
2492 OSYNC_TESTCASE_ADD(conv_find_multi_path_with_preferred)
2493 OSYNC_TESTCASE_ADD(conv_find_circular_false)
2494 OSYNC_TESTCASE_ADD(conv_find_complex)
2495
2496 OSYNC_TESTCASE_ADD(conv_find_multi_target)
2497 OSYNC_TESTCASE_ADD(conv_find_multi_target2)
2498 OSYNC_TESTCASE_ADD(conv_find_multi_path_multi_target)
2499 OSYNC_TESTCASE_ADD(conv_find_multi_path_multi_target_with_preferred)
2500
2501 OSYNC_TESTCASE_ADD(conv_env_convert1)
2502 OSYNC_TESTCASE_ADD(conv_env_convert_back)
2503 OSYNC_TESTCASE_ADD(conv_env_convert_desenc)
2504
2505 OSYNC_TESTCASE_ADD(conv_env_convert_desenc_complex)
2506 OSYNC_TESTCASE_ADD(conv_env_detect_and_convert)
2507 OSYNC_TESTCASE_ADD(conv_prefer_not_desencap)
2508 OSYNC_TESTCASE_ADD(conv_prefer_same_objtype)
2509 OSYNC_TESTCASE_ADD(conv_prefer_not_lossy_objtype_change)
2510 OSYNC_TESTCASE_ADD(conv_env_detect_false)
2511 OSYNC_TESTCASE_ADD(conv_env_decap_and_detect)
2512 OSYNC_TESTCASE_ADD(conv_env_decap_and_detect2)
2513 OSYNC_TESTCASE_END
2514