tests/ipc-tests/check_ipc.c

   1 #include "support.h"
   2 #ifndef _WIN32
   3 #include <sys/wait.h>
   4 #endif
   5
   6 #include <opensync/opensync-ipc.h>
   7 #include "opensync/ipc/opensync_message_internals.h"
   8 #include "opensync/ipc/opensync_queue_internals.h"
   9
  10 START_TEST (ipc_new)
  11 {
  12         char *testbed = setup_testbed(NULL);
  13         osync_testing_file_remove("/tmp/testpipe");
  14
  15         OSyncError *error = NULL;
  16         OSyncQueue *queue1 = osync_queue_new("/tmp/testpipe", &error);
  17         fail_unless(queue1 != NULL, NULL);
  18         fail_unless(error == NULL, NULL);
  19
  20         osync_queue_unref(queue1);
  21
  22         destroy_testbed(testbed);
  23 }
  24 END_TEST
  25
  26 START_TEST (ipc_ref)
  27 {
  28         char *testbed = setup_testbed(NULL);
  29         osync_testing_file_remove("/tmp/testpipe");
  30
  31         OSyncError *error = NULL;
  32         OSyncQueue *queue1 = osync_queue_new("/tmp/testpipe", &error);
  33         fail_unless(queue1 != NULL, NULL);
  34         fail_unless(error == NULL, NULL);
  35
  36         queue1 = osync_queue_ref(queue1);
  37         fail_unless(queue1 != NULL, NULL);
  38
  39         osync_queue_unref(queue1);
  40         osync_queue_unref(queue1);
  41
  42         destroy_testbed(testbed);
  43 }
  44 END_TEST
  45
  46 START_TEST (ipc_create)
  47 {
  48         char *testbed = setup_testbed(NULL);
  49         osync_testing_file_remove("/tmp/testpipe");
  50
  51         OSyncError *error = NULL;
  52         OSyncQueue *queue1 = osync_queue_new("/tmp/testpipe", &error);
  53         fail_unless(queue1 != NULL, NULL);
  54         fail_unless(error == NULL, NULL);
  55
  56         fail_unless(osync_queue_create(queue1, &error), NULL);
  57         fail_unless(error == NULL, NULL);
  58
  59         fail_unless(osync_testing_file_exists("/tmp/testpipe") == TRUE, NULL);
  60
  61         fail_unless(osync_queue_remove(queue1, &error), NULL);
  62         fail_unless(error == NULL, NULL);
  63
  64         fail_unless(osync_testing_file_exists("/tmp/testpipe") == FALSE, NULL);
  65
  66         osync_queue_unref(queue1);
  67
  68         destroy_testbed(testbed);
  69 }
  70 END_TEST
  71
  72 START_TEST (ipc_connect)
  73 {
  74         char *testbed = setup_testbed(NULL);
  75         osync_testing_file_remove("/tmp/testpipe");
  76
  77         OSyncError *error = NULL;
  78         OSyncQueue *queue = osync_queue_new("/tmp/testpipe", &error);
  79
  80         osync_queue_create(queue, &error);
  81         fail_unless(error == NULL, NULL);
  82
  83         pid_t cpid = fork();
  84         if (cpid == 0) { //Child
  85                 osync_assert(osync_queue_connect(queue, OSYNC_QUEUE_RECEIVER, &error));
  86                 osync_assert(error == NULL);
  87
  88                 if (osync_queue_disconnect(queue, &error) != TRUE || error != NULL)
  89                         exit(1);
  90
  91                 osync_queue_unref(queue);
  92
  93                 g_free(testbed);
  94                 exit(0);
  95         } else {
  96                 fail_unless(osync_queue_connect(queue, OSYNC_QUEUE_SENDER, &error), NULL);
  97                 fail_unless(error == NULL, NULL);
  98
  99                 osync_queue_disconnect(queue, &error);
 100                 fail_unless(error == NULL, NULL);
 101
 102                 int status = 0;
 103                 wait(&status);
 104                 fail_unless(WEXITSTATUS(status) == 0, NULL);
 105
 106         }
 107
 108         fail_unless(osync_testing_file_exists("/tmp/testpipe") == TRUE, NULL);
 109
 110         fail_unless(osync_queue_remove(queue, &error), NULL);
 111         fail_unless(error == NULL, NULL);
 112
 113         fail_unless(osync_testing_file_exists("/tmp/testpipe") == FALSE, NULL);
 114
 115         osync_queue_unref(queue);
 116
 117         destroy_testbed(testbed);
 118 }
 119 END_TEST
 120
 121 START_TEST (ipc_payload)
 122 {
 123         char *testbed = setup_testbed(NULL);
 124         osync_testing_file_remove("/tmp/testpipe-server");
 125         osync_testing_file_remove("/tmp/testpipe-client");
 126
 127         OSyncError *error = NULL;
 128         OSyncQueue *server_queue = osync_queue_new("/tmp/testpipe-server", &error);
 129         OSyncQueue *client_queue = osync_queue_new("/tmp/testpipe-client", &error);
 130         OSyncMessage *message = NULL;
 131
 132         osync_queue_create(server_queue, &error);
 133         fail_unless(error == NULL, NULL);
 134
 135         osync_queue_create(client_queue, &error);
 136         fail_unless(error == NULL, NULL);
 137         char *data = "this is another test string";
 138
 139         pid_t cpid = fork();
 140         if (cpid == 0) { //Child
 141                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
 142                 osync_assert(error == NULL);
 143
 144                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
 145                 osync_assert(error == NULL);
 146
 147                 message = osync_queue_get_message(client_queue);
 148
 149                 if (osync_message_get_command(message) != OSYNC_MESSAGE_INITIALIZE) {
 150                         exit (1);
 151                 }
 152
 153                 int int1;
 154                 long long int longint1;
 155                 char *string;
 156                 void *databuf;
 157
 158                 osync_message_read_int(message, &int1);
 159                 osync_message_read_const_string(message, &string);
 160                 osync_message_read_long_long_int(message, &longint1);
 161                 osync_message_read_const_data(message, &databuf, strlen(data) + 1);
 162
 163                 osync_assert(int1 == 4000000);
 164                 osync_assert(!strcmp(string, "this is a test string"));
 165                 osync_assert(longint1 == 400000000);
 166                 osync_assert(!strcmp(databuf, "this is another test string"));
 167
 168                 OSyncMessage *reply = osync_message_new_reply(message, &error);
 169
 170                 osync_message_unref(message);
 171
 172                 if (osync_queue_disconnect(client_queue, &error) != TRUE || error != NULL)
 173                         exit(1);
 174                 osync_queue_unref(client_queue);
 175
 176                 osync_queue_send_message(server_queue, NULL, reply, &error);
 177                 osync_message_unref(reply);
 178
 179                 message = osync_queue_get_message(server_queue);
 180
 181                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
 182                         exit (1);
 183                 }
 184
 185                 osync_message_unref(message);
 186
 187                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
 188                         exit(1);
 189                 osync_queue_unref(server_queue);
 190
 191                 g_free(testbed);
 192
 193                 exit(0);
 194         } else {
 195                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
 196                 fail_unless(error == NULL, NULL);
 197
 198                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
 199                 fail_unless(error == NULL, NULL);
 200
 201                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
 202                 fail_unless(message != NULL, NULL);
 203                 fail_unless(!osync_error_is_set(&error), NULL);
 204
 205                 osync_message_write_int(message, 4000000);
 206                 osync_message_write_string(message, "this is a test string");
 207                 osync_message_write_long_long_int(message, 400000000);
 208                 osync_message_write_data(message, data, strlen(data) + 1);
 209
 210                 fail_unless(osync_queue_send_message(client_queue, NULL, message, &error), NULL);
 211                 fail_unless(!osync_error_is_set(&error), NULL);
 212
 213                 osync_message_unref(message);
 214
 215                 while (!(message = osync_queue_get_message(server_queue))) {
 216                         g_usleep(100000);
 217                 }
 218
 219                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_REPLY);
 220
 221                 osync_message_unref(message);
 222
 223                 osync_queue_disconnect(server_queue, &error);
 224                 fail_unless(error == NULL, NULL);
 225
 226                 while (!(message = osync_queue_get_message(client_queue))) {
 227                         g_usleep(10000);
 228                 }
 229
 230                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
 231                         exit (1);
 232                 }
 233
 234                 osync_message_unref(message);
 235
 236                 osync_queue_disconnect(client_queue, &error);
 237                 fail_unless(error == NULL, NULL);
 238
 239                 int status = 0;
 240                 wait(&status);
 241                 fail_unless(WEXITSTATUS(status) == 0, NULL);
 242         }
 243
 244         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
 245
 246         fail_unless(osync_queue_remove(client_queue, &error), NULL);
 247         fail_unless(osync_queue_remove(server_queue, &error), NULL);
 248         fail_unless(!osync_error_is_set(&error), NULL);
 249
 250         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
 251
 252         osync_queue_unref(client_queue);
 253         osync_queue_unref(server_queue);
 254
 255         destroy_testbed(testbed);
 256 }
 257 END_TEST
 258
 259 START_TEST (ipc_payload_wait)
 260 {
 261         char *testbed = setup_testbed(NULL);
 262         osync_testing_file_remove("/tmp/testpipe-server");
 263         osync_testing_file_remove("/tmp/testpipe-client");
 264
 265         OSyncError *error = NULL;
 266         OSyncQueue *server_queue = osync_queue_new("/tmp/testpipe-server", &error);
 267         OSyncQueue *client_queue = osync_queue_new("/tmp/testpipe-client", &error);
 268         OSyncMessage *message = NULL;
 269
 270         osync_queue_create(server_queue, &error);
 271         fail_unless(error == NULL, NULL);
 272
 273         osync_queue_create(client_queue, &error);
 274         fail_unless(error == NULL, NULL);
 275         char *data = "this is another test string";
 276
 277         pid_t cpid = fork();
 278         if (cpid == 0) { //Child
 279                 g_usleep(1*G_USEC_PER_SEC);
 280                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
 281                 osync_assert(error == NULL);
 282
 283                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
 284                 osync_assert(error == NULL);
 285
 286                 while (!(message = osync_queue_get_message(client_queue))) {
 287                         g_usleep(10000);
 288                 }
 289
 290                 if (osync_message_get_command(message) != OSYNC_MESSAGE_INITIALIZE) {
 291                         exit (1);
 292                 }
 293
 294                 int int1;
 295                 long long int longint1;
 296                 char *string;
 297                 char databuf[strlen(data) + 1];
 298
 299                 osync_message_read_int(message, &int1);
 300                 osync_message_read_string(message, &string);
 301                 osync_message_read_long_long_int(message, &longint1);
 302                 osync_message_read_data(message, databuf, strlen(data) + 1);
 303
 304                 osync_assert(int1 == 4000000);
 305                 osync_assert(!strcmp(string, "this is a test string"));
 306                 osync_assert(longint1 == 400000000);
 307                 osync_assert(!strcmp(databuf, "this is another test string"));
 308
 309                 g_usleep(1*G_USEC_PER_SEC);
 310
 311                 OSyncMessage *reply = osync_message_new_reply(message, &error);
 312
 313                 osync_message_unref(message);
 314
 315                 osync_queue_send_message(server_queue, NULL, reply, &error);
 316
 317                 osync_message_unref(reply);
 318
 319                 g_usleep(1*G_USEC_PER_SEC);
 320
 321                 if (osync_queue_disconnect(client_queue, &error) != TRUE || error != NULL)
 322                         exit(1);
 323                 osync_queue_unref(client_queue);
 324
 325                 while (!(message = osync_queue_get_message(server_queue))) {
 326                         g_usleep(10000);
 327                 }
 328
 329                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
 330                         exit (1);
 331                 }
 332
 333                 osync_message_unref(message);
 334                 g_usleep(1*G_USEC_PER_SEC);
 335
 336                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
 337                         exit(1);
 338                 osync_queue_unref(server_queue);
 339
 340                 g_free(testbed);
 341
 342                 exit(0);
 343         } else {
 344                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
 345                 fail_unless(error == NULL, NULL);
 346
 347                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
 348                 fail_unless(error == NULL, NULL);
 349
 350                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
 351                 fail_unless(message != NULL, NULL);
 352                 fail_unless(!osync_error_is_set(&error), NULL);
 353
 354                 osync_message_write_int(message, 4000000);
 355                 osync_message_write_string(message, "this is a test string");
 356                 osync_message_write_long_long_int(message, 400000000);
 357                 osync_message_write_data(message, data, strlen(data) + 1);
 358
 359                 fail_unless(osync_queue_send_message(client_queue, NULL, message, &error), NULL);
 360                 fail_unless(!osync_error_is_set(&error), NULL);
 361
 362                 osync_message_unref(message);
 363
 364                 while (!(message = osync_queue_get_message(server_queue))) {
 365                         g_usleep(100000);
 366                 }
 367
 368                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_REPLY);
 369
 370                 osync_message_unref(message);
 371
 372                 osync_queue_disconnect(server_queue, &error);
 373                 fail_unless(error == NULL, NULL);
 374
 375                 while (!(message = osync_queue_get_message(client_queue))) {
 376                         g_usleep(10000);
 377                 }
 378
 379                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
 380                         exit (1);
 381                 }
 382                 osync_message_unref(message);
 383
 384                 osync_queue_disconnect(client_queue, &error);
 385                 fail_unless(error == NULL, NULL);
 386
 387                 int status = 0;
 388                 wait(&status);
 389                 fail_unless(WEXITSTATUS(status) == 0, NULL);
 390         }
 391
 392         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
 393
 394         fail_unless(osync_queue_remove(client_queue, &error), NULL);
 395         fail_unless(osync_queue_remove(server_queue, &error), NULL);
 396         fail_unless(!osync_error_is_set(&error), NULL);
 397
 398         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
 399
 400         osync_queue_unref(client_queue);
 401         osync_queue_unref(server_queue);
 402
 403         destroy_testbed(testbed);
 404 }
 405 END_TEST
 406
 407 START_TEST (ipc_payload_stress)
 408 {
 409         char *testbed = setup_testbed(NULL);
 410         osync_testing_file_remove("/tmp/testpipe-server");
 411         osync_testing_file_remove("/tmp/testpipe-client");
 412
 413         int num_mess = 1000;
 414         int size = 100;
 415
 416         char *data = malloc(size);
 417         memset(data, 42, size);
 418
 419         OSyncError *error = NULL;
 420         OSyncQueue *server_queue = osync_queue_new("/tmp/testpipe-server", &error);
 421         OSyncQueue *client_queue = osync_queue_new("/tmp/testpipe-client", &error);
 422         OSyncMessage *message = NULL;
 423
 424         osync_queue_create(server_queue, &error);
 425         fail_unless(error == NULL, NULL);
 426
 427         osync_queue_create(client_queue, &error);
 428         fail_unless(error == NULL, NULL);
 429
 430         pid_t cpid = fork();
 431         if (cpid == 0) { //Child
 432                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
 433                 osync_assert(error == NULL);
 434
 435                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
 436                 osync_assert(error == NULL);
 437
 438                 while (num_mess > 0) {
 439                         osync_trace(TRACE_INTERNAL, "Waiting for message");
 440                         message = osync_queue_get_message(client_queue);
 441
 442                         if (osync_message_get_command(message) != OSYNC_MESSAGE_INITIALIZE) {
 443                                 exit (1);
 444                         }
 445
 446                         osync_trace(TRACE_INTERNAL, "Parsing message");
 447                         char databuf[size];
 448
 449                         osync_message_read_data(message, databuf, size);
 450
 451                         osync_assert(!memcmp(databuf, data, size));
 452
 453                         osync_trace(TRACE_INTERNAL, "Creating new reply");
 454                         OSyncMessage *reply = osync_message_new_reply(message, &error);
 455
 456                         osync_message_unref(message);
 457
 458                         osync_trace(TRACE_INTERNAL, "Sending reply");
 459                         osync_queue_send_message(server_queue, NULL, reply, &error);
 460
 461                         osync_message_unref(reply);
 462
 463                         num_mess--;
 464                 }
 465
 466                 if (osync_queue_disconnect(client_queue, &error) != TRUE || error != NULL)
 467                         exit(1);
 468                 osync_queue_unref(client_queue);
 469
 470                 message = osync_queue_get_message(server_queue);
 471
 472                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
 473                         exit (1);
 474                 }
 475
 476                 osync_message_unref(message);
 477
 478                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
 479                         exit(1);
 480                 osync_queue_unref(server_queue);
 481
 482                 g_free(data);
 483                 g_free(testbed);
 484
 485                 exit(0);
 486         } else {
 487                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
 488                 fail_unless(error == NULL, NULL);
 489
 490                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
 491                 fail_unless(error == NULL, NULL);
 492
 493                 while (num_mess > 0) {
 494                         osync_trace(TRACE_INTERNAL, "Creating new message");
 495                         message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
 496                         fail_unless(message != NULL, NULL);
 497                         fail_unless(!osync_error_is_set(&error), NULL);
 498
 499                         osync_message_write_data(message, data, size);
 500
 501                         osync_trace(TRACE_INTERNAL, "Sending message");
 502                         fail_unless(osync_queue_send_message(client_queue, NULL, message, &error), NULL);
 503                         fail_unless(!osync_error_is_set(&error), NULL);
 504
 505                         osync_message_unref(message);
 506
 507                         osync_trace(TRACE_INTERNAL, "Waiting for message");
 508                         message = osync_queue_get_message(server_queue);
 509
 510                         fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_REPLY);
 511
 512                         osync_message_unref(message);
 513
 514                         num_mess--;
 515                 }
 516
 517                 osync_queue_disconnect(server_queue, &error);
 518                 fail_unless(error == NULL, NULL);
 519
 520                 message = osync_queue_get_message(client_queue);
 521
 522                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
 523                         exit (1);
 524                 }
 525
 526                 osync_message_unref(message);
 527
 528                 osync_queue_disconnect(client_queue, &error);
 529                 fail_unless(error == NULL, NULL);
 530
 531                 int status = 0;
 532                 wait(&status);
 533                 fail_unless(WEXITSTATUS(status) == 0, NULL);
 534         }
 535
 536         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
 537
 538         fail_unless(osync_queue_remove(client_queue, &error), NULL);
 539         fail_unless(osync_queue_remove(server_queue, &error), NULL);
 540         fail_unless(!osync_error_is_set(&error), NULL);
 541
 542         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
 543
 544         osync_queue_unref(client_queue);
 545         osync_queue_unref(server_queue);
 546
 547         g_free(data);
 548         destroy_testbed(testbed);
 549 }
 550 END_TEST
 551
 552 START_TEST (ipc_payload_stress2)
 553 {
 554         char *testbed = setup_testbed(NULL);
 555         osync_testing_file_remove("/tmp/testpipe-server");
 556         osync_testing_file_remove("/tmp/testpipe-client");
 557         int i = 0;
 558
 559         int num_mess = 1000;
 560         int size = 100;
 561
 562         char *data = malloc(size);
 563         memset(data, 42, size);
 564
 565         OSyncError *error = NULL;
 566         OSyncQueue *server_queue = osync_queue_new("/tmp/testpipe-server", &error);
 567         OSyncQueue *client_queue = osync_queue_new("/tmp/testpipe-client", &error);
 568         OSyncMessage *message = NULL;
 569
 570         osync_queue_create(server_queue, &error);
 571         fail_unless(error == NULL, NULL);
 572
 573         osync_queue_create(client_queue, &error);
 574         fail_unless(error == NULL, NULL);
 575
 576         pid_t cpid = fork();
 577         if (cpid == 0) { //Child
 578                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
 579                 osync_assert(error == NULL);
 580
 581                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
 582                 osync_assert(error == NULL);
 583
 584                 for (i = 0; i < num_mess; i++) {
 585                         message = osync_queue_get_message(client_queue);
 586
 587                         if (osync_message_get_command(message) != OSYNC_MESSAGE_INITIALIZE) {
 588                                 exit (1);
 589                         }
 590
 591                         char databuf[size];
 592
 593                         osync_message_read_data(message, databuf, size);
 594
 595                         osync_assert(!memcmp(databuf, data, size));
 596
 597                         osync_message_unref(message);
 598                 }
 599
 600                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
 601
 602                 for (i = 0; i < num_mess; i++) {
 603                         OSyncMessage *reply = osync_message_new_reply(message, &error);
 604
 605                         osync_queue_send_message(server_queue, NULL, reply, &error);
 606
 607                         osync_message_unref(reply);
 608                 }
 609
 610                 osync_message_unref(message);
 611
 612                 if (osync_queue_disconnect(client_queue, &error) != TRUE || error != NULL)
 613                         exit(1);
 614                 osync_queue_unref(client_queue);
 615
 616                 message = osync_queue_get_message(server_queue);
 617
 618                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
 619                         exit (1);
 620                 }
 621
 622                 osync_message_unref(message);
 623
 624                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
 625                         exit(1);
 626                 osync_queue_unref(server_queue);
 627
 628                 g_free(data);
 629                 g_free(testbed);
 630
 631                 exit(0);
 632         } else {
 633                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
 634                 fail_unless(error == NULL, NULL);
 635
 636                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
 637                 fail_unless(error == NULL, NULL);
 638
 639                 for (i = 0; i < num_mess; i++) {
 640                         message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
 641                         fail_unless(message != NULL, NULL);
 642                         fail_unless(!osync_error_is_set(&error), NULL);
 643
 644                         osync_message_write_data(message, data, size);
 645
 646                         fail_unless(osync_queue_send_message(client_queue, NULL, message, &error), NULL);
 647                         fail_unless(!osync_error_is_set(&error), NULL);
 648
 649                         osync_message_unref(message);
 650                 }
 651
 652                 for (i = 0; i < num_mess; i++) {
 653                         message = osync_queue_get_message(server_queue);
 654
 655                         fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_REPLY);
 656
 657                         osync_message_unref(message);
 658                 }
 659
 660                 osync_queue_disconnect(server_queue, &error);
 661                 fail_unless(error == NULL, NULL);
 662
 663                 message = osync_queue_get_message(client_queue);
 664
 665                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
 666                         exit (1);
 667                 }
 668
 669                 osync_message_unref(message);
 670
 671                 osync_queue_disconnect(client_queue, &error);
 672                 fail_unless(error == NULL, NULL);
 673
 674                 int status = 0;
 675                 wait(&status);
 676                 fail_unless(WEXITSTATUS(status) == 0, NULL);
 677         }
 678
 679         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
 680
 681         fail_unless(osync_queue_remove(client_queue, &error), NULL);
 682         fail_unless(osync_queue_remove(server_queue, &error), NULL);
 683         fail_unless(!osync_error_is_set(&error), NULL);
 684
 685         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
 686
 687         osync_queue_unref(client_queue);
 688         osync_queue_unref(server_queue);
 689
 690         g_free(data);
 691         destroy_testbed(testbed);
 692 }
 693 END_TEST
 694
 695 START_TEST (ipc_large_payload)
 696 {
 697         char *testbed = setup_testbed(NULL);
 698         osync_testing_file_remove("/tmp/testpipe-server");
 699         osync_testing_file_remove("/tmp/testpipe-client");
 700         int i = 0;
 701
 702         int num_mess = 10;
 703         int size = 1024 * 1024 * 20; //20mbyte
 704
 705         char *data = malloc(size);
 706         memset(data, 42, size);
 707
 708         OSyncError *error = NULL;
 709         OSyncQueue *server_queue = osync_queue_new("/tmp/testpipe-server", &error);
 710         OSyncQueue *client_queue = osync_queue_new("/tmp/testpipe-client", &error);
 711         OSyncMessage *message = NULL;
 712
 713         osync_queue_create(server_queue, &error);
 714         fail_unless(error == NULL, NULL);
 715
 716         osync_queue_create(client_queue, &error);
 717         fail_unless(error == NULL, NULL);
 718
 719         pid_t cpid = fork();
 720         if (cpid == 0) { //Child
 721                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
 722                 osync_assert(error == NULL);
 723
 724                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
 725                 osync_assert(error == NULL);
 726
 727                 for (i = 0; i < num_mess; i++) {
 728                         message = osync_queue_get_message(client_queue);
 729
 730                         if (osync_message_get_command(message) != OSYNC_MESSAGE_INITIALIZE) {
 731                                 exit (1);
 732                         }
 733
 734                         void *databuf = NULL;
 735                         osync_message_read_const_data(message, &databuf, size);
 736
 737                         if (memcmp(databuf, data, size))
 738                                 exit(1);
 739
 740                         OSyncMessage *reply = osync_message_new_reply(message, &error);
 741
 742                         osync_message_unref(message);
 743
 744                         osync_queue_send_message(server_queue, NULL, reply, &error);
 745
 746                         osync_message_unref(reply);
 747                 }
 748
 749                 if (osync_queue_disconnect(client_queue, &error) != TRUE || error != NULL)
 750                         exit(1);
 751                 osync_queue_unref(client_queue);
 752
 753                 message = osync_queue_get_message(server_queue);
 754
 755                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
 756                         exit (1);
 757                 }
 758
 759                 osync_message_unref(message);
 760
 761                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
 762                         exit(1);
 763                 osync_queue_unref(server_queue);
 764
 765                 g_free(data);
 766
 767                 g_free(testbed);
 768
 769                 exit(0);
 770         } else {
 771                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
 772                 fail_unless(error == NULL, NULL);
 773
 774                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
 775                 fail_unless(error == NULL, NULL);
 776
 777                 for (i = 0; i < num_mess; i++) {
 778                         message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
 779                         fail_unless(message != NULL, NULL);
 780                         fail_unless(!osync_error_is_set(&error), NULL);
 781
 782                         osync_message_write_data(message, data, size);
 783
 784                         fail_unless(osync_queue_send_message(client_queue, NULL, message, &error), NULL);
 785                         fail_unless(!osync_error_is_set(&error), NULL);
 786
 787                         osync_message_unref(message);
 788
 789                         message = osync_queue_get_message(server_queue);
 790
 791                         fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_REPLY);
 792
 793                         osync_message_unref(message);
 794                 }
 795
 796                 osync_queue_disconnect(server_queue, &error);
 797                 fail_unless(error == NULL, NULL);
 798
 799                 message = osync_queue_get_message(client_queue);
 800
 801                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
 802                         exit (1);
 803                 }
 804
 805                 osync_message_unref(message);
 806
 807                 osync_queue_disconnect(client_queue, &error);
 808                 fail_unless(error == NULL, NULL);
 809
 810                 int status = 0;
 811                 wait(&status);
 812                 fail_unless(WEXITSTATUS(status) == 0, NULL);
 813         }
 814
 815         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
 816
 817         fail_unless(osync_queue_remove(client_queue, &error), NULL);
 818         fail_unless(osync_queue_remove(server_queue, &error), NULL);
 819         fail_unless(!osync_error_is_set(&error), NULL);
 820
 821         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
 822
 823         osync_queue_unref(client_queue);
 824         osync_queue_unref(server_queue);
 825
 826         g_free(data);
 827         destroy_testbed(testbed);
 828 }
 829 END_TEST
 830
 831 START_TEST (ipc_error_no_pipe)
 832 {
 833         char *testbed = setup_testbed(NULL);
 834         osync_testing_file_remove("/tmp/testpipe");
 835
 836         OSyncError *error = NULL;
 837         OSyncQueue *queue1 = osync_queue_new("/tmp/testpipe", &error);
 838         fail_unless(queue1 != NULL, NULL);
 839         fail_unless(error == NULL, NULL);
 840
 841         fail_unless(!osync_queue_connect(queue1, OSYNC_QUEUE_RECEIVER, &error), NULL);
 842         fail_unless(error != NULL, NULL);
 843         osync_error_unref(&error);
 844
 845         osync_queue_unref(queue1);
 846
 847         destroy_testbed(testbed);
 848 }
 849 END_TEST
 850
 851 START_TEST (ipc_error_perm)
 852 {
 853         char *testbed = setup_testbed(NULL);
 854         osync_testing_file_remove("/tmp/testpipe");
 855
 856         OSyncError *error = NULL;
 857         OSyncQueue *queue = osync_queue_new("/tmp/testpipe", &error);
 858
 859         osync_queue_create(queue, &error);
 860         fail_unless(error == NULL, NULL);
 861
 862         if (osync_testing_file_chmod("/tmp/testpipe", 000))
 863                 abort();
 864
 865         fail_unless(!osync_queue_connect(queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
 866         fail_unless(error != NULL, NULL);
 867         osync_error_unref(&error);
 868
 869         fail_unless(osync_testing_file_exists("/tmp/testpipe") == TRUE, NULL);
 870
 871         fail_unless(osync_queue_remove(queue, &error), NULL);
 872         fail_unless(error == NULL, NULL);
 873
 874         fail_unless(osync_testing_file_exists("/tmp/testpipe") == FALSE, NULL);
 875
 876         osync_queue_unref(queue);
 877
 878         destroy_testbed(testbed);
 879 }
 880 END_TEST
 881
 882 START_TEST (ipc_error_rem)
 883 {
 884         char *testbed = setup_testbed(NULL);
 885         osync_testing_file_remove("/tmp/testpipe");
 886
 887         OSyncError *error = NULL;
 888         OSyncQueue *server_queue = osync_queue_new("/tmp/testpipe", &error);
 889         OSyncMessage *message = NULL;
 890
 891         osync_queue_create(server_queue, &error);
 892         fail_unless(error == NULL, NULL);
 893
 894         pid_t cpid = fork();
 895         if (cpid == 0) { //Child
 896                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error));
 897                 osync_assert(error == NULL);
 898
 899                 g_free(testbed);
 900                 exit(0);
 901         } else {
 902                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error), NULL);
 903                 fail_unless(error == NULL, NULL);
 904
 905                 message = osync_queue_get_message(server_queue);
 906                 osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
 907                 osync_message_unref(message);
 908
 909                 osync_queue_disconnect(server_queue, &error);
 910                 fail_unless(error == NULL, NULL);
 911
 912                 int status = 0;
 913                 wait(&status);
 914                 fail_unless(WEXITSTATUS(status) == 0, NULL);
 915         }
 916
 917         fail_unless(osync_testing_file_exists("/tmp/testpipe") == TRUE, NULL);
 918
 919         fail_unless(osync_queue_remove(server_queue, &error), NULL);
 920         fail_unless(!osync_error_is_set(&error), NULL);
 921
 922         fail_unless(osync_testing_file_exists("/tmp/testpipe") == FALSE, NULL);
 923
 924         osync_queue_unref(server_queue);
 925
 926         destroy_testbed(testbed);
 927 }
 928 END_TEST
 929
 930 START_TEST (ipc_error_rem2)
 931 {
 932         char *testbed = setup_testbed(NULL);
 933         osync_testing_file_remove("/tmp/testpipe");
 934
 935         OSyncError *error = NULL;
 936         OSyncQueue *server_queue = osync_queue_new("/tmp/testpipe", &error);
 937         OSyncMessage *message = NULL;
 938
 939         osync_queue_create(server_queue, &error);
 940         fail_unless(error == NULL, NULL);
 941
 942         pid_t cpid = fork();
 943         if (cpid == 0) { //Child
 944                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
 945                 osync_assert(error == NULL);
 946
 947                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
 948                 osync_assert(message != NULL);
 949                 osync_assert(!osync_error_is_set(&error));
 950
 951                 osync_message_write_int(message, 4000000);
 952                 osync_message_write_string(message, "this is a test string");
 953                 osync_message_write_long_long_int(message, 400000000);
 954
 955                 osync_assert(osync_queue_send_message(server_queue, NULL, message, &error));
 956                 osync_assert(!osync_error_is_set(&error));
 957
 958                 osync_message_unref(message);
 959
 960                 g_usleep(2*G_USEC_PER_SEC);
 961
 962                 osync_queue_disconnect(server_queue, &error);
 963                 osync_assert(error == NULL);
 964
 965                 osync_queue_unref(server_queue);
 966
 967                 g_free(testbed);
 968                 exit(0);
 969         } else {
 970                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
 971                 fail_unless(error == NULL, NULL);
 972
 973                 message = osync_queue_get_message(server_queue);
 974
 975                 /* 2005-05-23 dgollub
 976                    This unit tests seems to be kind of broken! What is is supposed to test?
 977                    No errors appears.... change osync_assert to "OSYNC_MESSAGE_INITALIZE".
 978                    TODO: Armin, whats wrong with this testcase? What means ipc_error_rem2? rem? read error message?
 979
 980                 */
 981 //              osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_ERROR);
 982                 osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
 983
 984                 osync_message_unref(message);
 985
 986                 osync_queue_disconnect(server_queue, &error);
 987                 fail_unless(error == NULL, NULL);
 988
 989                 int status = 0;
 990                 wait(&status);
 991                 fail_unless(WEXITSTATUS(status) == 0, NULL);
 992         }
 993
 994         fail_unless(osync_testing_file_exists("/tmp/testpipe") == TRUE, NULL);
 995
 996         fail_unless(osync_queue_remove(server_queue, &error), NULL);
 997         fail_unless(!osync_error_is_set(&error), NULL);
 998
 999         fail_unless(osync_testing_file_exists("/tmp/testpipe") == FALSE, NULL);
1000
1001         osync_queue_unref(server_queue);
1002
1003         destroy_testbed(testbed);
1004 }
1005 END_TEST
1006
1007 OSyncQueue *server_queue = NULL;
1008 OSyncQueue *client_queue = NULL;
1009
1010 void server_handler1(OSyncMessage *message, void *user_data)
1011 {
1012         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
1013         OSyncError *error = NULL;
1014
1015         osync_assert(GPOINTER_TO_INT(user_data) ==1);
1016
1017         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
1018
1019         osync_queue_disconnect(server_queue, &error);
1020         osync_assert(error == NULL);
1021
1022         osync_trace(TRACE_EXIT, "%s", __func__);
1023 }
1024
1025 void client_handler1(OSyncMessage *message, void *user_data)
1026 {
1027         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
1028         OSyncError *error = NULL;
1029
1030         osync_assert(GPOINTER_TO_INT(user_data) ==1);
1031         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
1032
1033         int int1;
1034         long long int longint1;
1035         char *string;
1036         void *databuf;
1037
1038         osync_message_read_int(message, &int1);
1039         osync_message_read_const_string(message, &string);
1040         osync_message_read_long_long_int(message, &longint1);
1041         osync_message_read_const_data(message, &databuf, strlen("this is another test string") + 1);
1042
1043         osync_assert(int1 == 4000000);
1044         osync_assert(!strcmp(string, "this is a test string"));
1045         osync_assert(longint1 == 400000000);
1046         osync_assert(!strcmp(databuf, "this is another test string"));
1047
1048         OSyncMessage *reply = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
1049
1050         osync_queue_send_message(server_queue, NULL, reply, &error);
1051
1052         osync_message_unref(reply);
1053
1054         osync_trace(TRACE_EXIT, "%s", __func__);
1055 }
1056
1057 START_TEST (ipc_loop_payload)
1058 {
1059         char *testbed = setup_testbed(NULL);
1060         osync_testing_file_remove("/tmp/testpipe-server");
1061         osync_testing_file_remove("/tmp/testpipe-client");
1062
1063         OSyncError *error = NULL;
1064         server_queue = osync_queue_new("/tmp/testpipe-server", &error);
1065         client_queue = osync_queue_new("/tmp/testpipe-client", &error);
1066         OSyncMessage *message = NULL;
1067
1068         osync_queue_create(server_queue, &error);
1069         fail_unless(error == NULL, NULL);
1070
1071         osync_queue_create(client_queue, &error);
1072         fail_unless(error == NULL, NULL);
1073         char *data = "this is another test string";
1074
1075         GMainContext *context = g_main_context_new();
1076         OSyncThread *thread = osync_thread_new(context, &error);
1077
1078         pid_t cpid = fork();
1079         if (cpid == 0) { //Child
1080                 osync_queue_set_message_handler(client_queue, client_handler1, GINT_TO_POINTER(1));
1081
1082                 osync_queue_setup_with_gmainloop(client_queue, context);
1083
1084                 osync_thread_start(thread);
1085
1086                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
1087                 osync_assert(error == NULL);
1088                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
1089                 osync_assert(error == NULL);
1090
1091                 osync_queue_cross_link(client_queue, server_queue);
1092
1093                 message = osync_queue_get_message(server_queue);
1094
1095                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
1096                         exit (1);
1097                 }
1098
1099                 osync_message_unref(message);
1100
1101                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
1102                         exit(1);
1103                 osync_queue_unref(server_queue);
1104
1105                 osync_assert(osync_queue_disconnect(client_queue, &error));
1106                 osync_assert(error == NULL);
1107
1108                 osync_thread_stop(thread);
1109                 osync_thread_unref(thread);
1110
1111                 osync_queue_unref(client_queue);
1112
1113                 g_free(testbed);
1114
1115                 exit(0);
1116         } else {
1117                 osync_queue_set_message_handler(server_queue, server_handler1, GINT_TO_POINTER(1));
1118
1119                 osync_queue_setup_with_gmainloop(server_queue, context);
1120
1121                 osync_thread_start(thread);
1122
1123                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
1124                 fail_unless(error == NULL, NULL);
1125
1126                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
1127                 fail_unless(error == NULL, NULL);
1128
1129                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
1130                 fail_unless(message != NULL, NULL);
1131                 fail_unless(!osync_error_is_set(&error), NULL);
1132
1133                 osync_message_write_int(message, 4000000);
1134                 osync_message_write_string(message, "this is a test string");
1135                 osync_message_write_long_long_int(message, 400000000);
1136                 osync_message_write_data(message, data, strlen(data) + 1);
1137
1138                 fail_unless(osync_queue_send_message(client_queue, NULL, message, &error), NULL);
1139                 fail_unless(!osync_error_is_set(&error), NULL);
1140
1141                 osync_message_unref(message);
1142
1143                 message = osync_queue_get_message(client_queue);
1144
1145                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
1146
1147                 osync_message_unref(message);
1148
1149                 osync_queue_disconnect(client_queue, &error);
1150                 fail_unless(error == NULL, NULL);
1151
1152                 osync_thread_stop(thread);
1153                 osync_thread_unref(thread);
1154
1155                 int status = 0;
1156                 wait(&status);
1157                 fail_unless(WEXITSTATUS(status) == 0, NULL);
1158         }
1159
1160         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
1161
1162         fail_unless(osync_queue_remove(client_queue, &error), NULL);
1163         fail_unless(osync_queue_remove(server_queue, &error), NULL);
1164         fail_unless(!osync_error_is_set(&error), NULL);
1165
1166         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
1167
1168         osync_queue_unref(client_queue);
1169         osync_queue_unref(server_queue);
1170
1171         destroy_testbed(testbed);
1172 }
1173 END_TEST
1174
1175 int num_msgs = 0;
1176 int req_msgs = 1000;
1177
1178 void server_handler2(OSyncMessage *message, void *user_data)
1179 {
1180         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
1181         OSyncError *error = NULL;
1182         char *data = "this is another test string";
1183
1184         osync_assert(GPOINTER_TO_INT(user_data) ==1);
1185
1186         num_msgs++;
1187         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
1188
1189         if (num_msgs >= req_msgs) {
1190                 osync_queue_disconnect(server_queue, &error);
1191                 osync_assert(error == NULL);
1192         } else {
1193                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
1194                 osync_assert(message != NULL);
1195                 osync_assert(!osync_error_is_set(&error));
1196
1197                 osync_message_write_int(message, 4000000);
1198                 osync_message_write_string(message, "this is a test string");
1199                 osync_message_write_long_long_int(message, 400000000);
1200                 osync_message_write_data(message, data, strlen(data) + 1);
1201
1202                 osync_assert(osync_queue_send_message(client_queue, NULL, message, &error));
1203                 osync_assert(!osync_error_is_set(&error));
1204
1205                 osync_message_unref(message);
1206         }
1207
1208         osync_trace(TRACE_EXIT, "%s", __func__);
1209 }
1210
1211 void client_handler2(OSyncMessage *message, void *user_data)
1212 {
1213         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
1214         OSyncError *error = NULL;
1215
1216         osync_assert(GPOINTER_TO_INT(user_data) ==1);
1217         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
1218
1219         int int1;
1220         long long int longint1;
1221         char *string;
1222         void *databuf;
1223
1224         osync_message_read_int(message, &int1);
1225         osync_message_read_const_string(message, &string);
1226         osync_message_read_long_long_int(message, &longint1);
1227         osync_message_read_const_data(message, &databuf, strlen("this is another test string") + 1);
1228
1229         osync_assert(int1 == 4000000);
1230         osync_assert(!strcmp(string, "this is a test string"));
1231         osync_assert(longint1 == 400000000);
1232         osync_assert(!strcmp(databuf, "this is another test string"));
1233
1234         OSyncMessage *reply = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
1235
1236         osync_queue_send_message(server_queue, NULL, reply, &error);
1237
1238         osync_message_unref(reply);
1239
1240         osync_trace(TRACE_EXIT, "%s", __func__);
1241 }
1242
1243 START_TEST (ipc_loop_stress)
1244 {
1245         char *testbed = setup_testbed(NULL);
1246         osync_testing_file_remove("/tmp/testpipe-server");
1247         osync_testing_file_remove("/tmp/testpipe-client");
1248
1249         OSyncError *error = NULL;
1250         server_queue = osync_queue_new("/tmp/testpipe-server", &error);
1251         client_queue = osync_queue_new("/tmp/testpipe-client", &error);
1252         OSyncMessage *message = NULL;
1253
1254         osync_queue_create(server_queue, &error);
1255         fail_unless(error == NULL, NULL);
1256
1257         osync_queue_create(client_queue, &error);
1258         fail_unless(error == NULL, NULL);
1259         char *data = "this is another test string";
1260
1261         pid_t cpid = fork();
1262         if (cpid == 0) { //Child
1263
1264                 GMainContext *context = g_main_context_new();
1265                 OSyncThread *thread = osync_thread_new(context, &error);
1266
1267                 osync_queue_set_message_handler(client_queue, client_handler2, GINT_TO_POINTER(1));
1268
1269                 osync_queue_setup_with_gmainloop(client_queue, context);
1270
1271                 osync_thread_start(thread);
1272
1273                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
1274                 osync_assert(error == NULL);
1275                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
1276                 osync_assert(error == NULL);
1277
1278                 osync_queue_cross_link(client_queue, server_queue);
1279
1280                 message = osync_queue_get_message(server_queue);
1281
1282                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
1283                         exit (1);
1284                 }
1285
1286                 osync_message_unref(message);
1287
1288                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
1289                         exit(1);
1290                 osync_queue_unref(server_queue);
1291
1292                 osync_assert(osync_queue_disconnect(client_queue, &error));
1293                 osync_assert(error == NULL);
1294
1295                 osync_thread_stop(thread);
1296                 osync_thread_unref(thread);
1297
1298                 osync_queue_unref(client_queue);
1299
1300                 g_free(testbed);
1301
1302                 exit(0);
1303         } else {
1304                 GMainContext *context = g_main_context_new();
1305                 OSyncThread *thread = osync_thread_new(context, &error);
1306
1307                 osync_queue_set_message_handler(server_queue, server_handler2, GINT_TO_POINTER(1));
1308
1309                 osync_queue_setup_with_gmainloop(server_queue, context);
1310
1311                 osync_thread_start(thread);
1312
1313                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
1314                 fail_unless(error == NULL, NULL);
1315
1316                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
1317                 fail_unless(error == NULL, NULL);
1318
1319                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
1320                 fail_unless(message != NULL, NULL);
1321                 fail_unless(!osync_error_is_set(&error), NULL);
1322
1323                 osync_message_write_int(message, 4000000);
1324                 osync_message_write_string(message, "this is a test string");
1325                 osync_message_write_long_long_int(message, 400000000);
1326                 osync_message_write_data(message, data, strlen(data) + 1);
1327
1328                 fail_unless(osync_queue_send_message(client_queue, NULL, message, &error), NULL);
1329                 fail_unless(!osync_error_is_set(&error), NULL);
1330
1331                 osync_message_unref(message);
1332
1333                 message = osync_queue_get_message(client_queue);
1334
1335                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
1336
1337                 osync_message_unref(message);
1338
1339                 osync_queue_disconnect(client_queue, &error);
1340                 fail_unless(error == NULL, NULL);
1341
1342                 osync_thread_stop(thread);
1343                 osync_thread_unref(thread);
1344
1345                 int status = 0;
1346                 wait(&status);
1347                 fail_unless(WEXITSTATUS(status) == 0, NULL);
1348         }
1349
1350         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
1351
1352         fail_unless(osync_queue_remove(client_queue, &error), NULL);
1353         fail_unless(osync_queue_remove(server_queue, &error), NULL);
1354         fail_unless(!osync_error_is_set(&error), NULL);
1355
1356         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
1357
1358         osync_queue_unref(client_queue);
1359         osync_queue_unref(server_queue);
1360
1361         destroy_testbed(testbed);
1362 }
1363 END_TEST
1364
1365 void callback_handler_check_reply(OSyncMessage *message, void *user_data)
1366 {
1367         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
1368         OSyncError *error = NULL;
1369
1370         osync_assert(GPOINTER_TO_INT(user_data) == 1);
1371
1372         num_msgs++;
1373         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_REPLY);
1374
1375         if (num_msgs >= req_msgs) {
1376                 osync_queue_disconnect(server_queue, &error);
1377                 osync_assert(error == NULL);
1378         }
1379
1380         osync_trace(TRACE_EXIT, "%s", __func__);
1381 }
1382
1383 void server_handler_abort(OSyncMessage *message, void *user_data)
1384 {
1385         abort();
1386 }
1387
1388 void client_handler3(OSyncMessage *message, void *user_data)
1389 {
1390         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
1391         OSyncError *error = NULL;
1392
1393         osync_assert(GPOINTER_TO_INT(user_data) ==1);
1394         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
1395
1396         int int1;
1397         long long int longint1;
1398         char *string;
1399         void *databuf;
1400
1401         osync_message_read_int(message, &int1);
1402         osync_message_read_const_string(message, &string);
1403         osync_message_read_long_long_int(message, &longint1);
1404         osync_message_read_const_data(message, &databuf, strlen("this is another test string") + 1);
1405
1406         osync_assert(int1 == 4000000);
1407         osync_assert(!strcmp(string, "this is a test string"));
1408         osync_assert(longint1 == 400000000);
1409         osync_assert(!strcmp(databuf, "this is another test string"));
1410
1411         OSyncMessage *reply = osync_message_new_reply(message, &error);
1412
1413         osync_queue_send_message(server_queue, NULL, reply, &error);
1414
1415         osync_message_unref(reply);
1416
1417         osync_trace(TRACE_EXIT, "%s", __func__);
1418 }
1419
1420 START_TEST (ipc_loop_callback)
1421 {
1422         num_msgs = 0;
1423
1424         char *testbed = setup_testbed(NULL);
1425         osync_testing_file_remove("/tmp/testpipe-server");
1426         osync_testing_file_remove("/tmp/testpipe-client");
1427
1428         OSyncError *error = NULL;
1429         server_queue = osync_queue_new("/tmp/testpipe-server", &error);
1430         client_queue = osync_queue_new("/tmp/testpipe-client", &error);
1431         OSyncMessage *message = NULL;
1432
1433         osync_queue_create(server_queue, &error);
1434         fail_unless(error == NULL, NULL);
1435
1436         osync_queue_create(client_queue, &error);
1437         fail_unless(error == NULL, NULL);
1438         char *data = "this is another test string";
1439
1440         pid_t cpid = fork();
1441         if (cpid == 0) { //Child
1442
1443                 GMainContext *context = g_main_context_new();
1444                 OSyncThread *thread = osync_thread_new(context, &error);
1445
1446                 osync_queue_set_message_handler(client_queue, client_handler3, GINT_TO_POINTER(1));
1447
1448                 osync_queue_setup_with_gmainloop(client_queue, context);
1449
1450                 osync_thread_start(thread);
1451
1452                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
1453                 osync_assert(error == NULL);
1454
1455                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
1456                 osync_assert(error == NULL);
1457
1458                 osync_queue_cross_link(client_queue, server_queue);
1459
1460                 message = osync_queue_get_message(server_queue);
1461
1462                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
1463                         exit (1);
1464                 }
1465
1466                 osync_message_unref(message);
1467
1468                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
1469                         exit(1);
1470                 osync_queue_unref(server_queue);
1471
1472                 osync_assert(osync_queue_disconnect(client_queue, &error));
1473                 osync_assert(error == NULL);
1474
1475                 osync_thread_stop(thread);
1476                 osync_thread_unref(thread);
1477
1478                 osync_queue_unref(client_queue);
1479
1480                 g_free(testbed);
1481
1482                 exit(0);
1483         } else {
1484                 GMainContext *context = g_main_context_new();
1485                 OSyncThread *thread = osync_thread_new(context, &error);
1486
1487                 osync_queue_set_message_handler(server_queue, server_handler_abort, GINT_TO_POINTER(1));
1488
1489                 osync_queue_setup_with_gmainloop(server_queue, context);
1490
1491                 osync_thread_start(thread);
1492
1493                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
1494                 fail_unless(error == NULL, NULL);
1495
1496                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
1497                 fail_unless(error == NULL, NULL);
1498
1499                 int i = 0;
1500                 for (i = 0; i < req_msgs; i++) {
1501                         message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
1502                         fail_unless(message != NULL, NULL);
1503                         fail_unless(!osync_error_is_set(&error), NULL);
1504
1505                         osync_message_write_int(message, 4000000);
1506                         osync_message_write_string(message, "this is a test string");
1507                         osync_message_write_long_long_int(message, 400000000);
1508                         osync_message_write_data(message, data, strlen(data) + 1);
1509
1510                         osync_message_set_handler(message, callback_handler_check_reply, GINT_TO_POINTER(1));
1511
1512                         fail_unless(osync_queue_send_message(client_queue, server_queue, message, &error), NULL);
1513                         fail_unless(!osync_error_is_set(&error), NULL);
1514
1515                         osync_message_unref(message);
1516                 }
1517
1518                 message = osync_queue_get_message(client_queue);
1519
1520                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
1521
1522                 osync_message_unref(message);
1523
1524                 osync_queue_disconnect(client_queue, &error);
1525                 fail_unless(error == NULL, NULL);
1526
1527                 osync_thread_stop(thread);
1528                 osync_thread_unref(thread);
1529
1530                 int status = 0;
1531                 wait(&status);
1532                 fail_unless(WEXITSTATUS(status) == 0, NULL);
1533         }
1534
1535         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
1536
1537         fail_unless(osync_queue_remove(client_queue, &error), NULL);
1538         fail_unless(osync_queue_remove(server_queue, &error), NULL);
1539         fail_unless(!osync_error_is_set(&error), NULL);
1540
1541         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
1542
1543         osync_queue_unref(client_queue);
1544         osync_queue_unref(server_queue);
1545
1546         destroy_testbed(testbed);
1547 }
1548 END_TEST
1549
1550 int stop_after = 500;
1551
1552 void callback_handler2(OSyncMessage *message, void *user_data)
1553 {
1554         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
1555
1556         osync_assert(GPOINTER_TO_INT(user_data) == 1);
1557
1558         if (num_msgs >= stop_after) {
1559                 osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_ERRORREPLY);
1560         } else {
1561                 osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_REPLY);
1562         }
1563
1564         num_msgs++;
1565
1566         osync_trace(TRACE_EXIT, "%s", __func__);
1567 }
1568
1569 int num_msgs2 = 0;
1570
1571 void server_handler4(OSyncMessage *message, void *user_data)
1572 {
1573         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP || osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_ERROR);
1574 }
1575
1576 void client_handler4(OSyncMessage *message, void *user_data)
1577 {
1578         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
1579         OSyncError *error = NULL;
1580
1581         osync_assert(GPOINTER_TO_INT(user_data) ==1);
1582         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
1583
1584         int int1;
1585         long long int longint1;
1586         char *string;
1587         void *databuf;
1588
1589
1590         osync_message_read_int(message, &int1);
1591         osync_message_read_const_string(message, &string);
1592         osync_message_read_long_long_int(message, &longint1);
1593         osync_message_read_const_data(message, &databuf, strlen("this is another test string") + 1);
1594
1595         osync_assert(int1 == 4000000);
1596         osync_assert(!strcmp(string, "this is a test string"));
1597         osync_assert(longint1 == 400000000);
1598         osync_assert(!strcmp(databuf, "this is another test string"));
1599
1600         if (num_msgs2 >= stop_after) {
1601                 osync_assert(osync_queue_disconnect(client_queue, &error));
1602                 osync_assert(error == NULL);
1603         } else {
1604                 OSyncMessage *reply = osync_message_new_reply(message, &error);
1605
1606                 osync_queue_send_message(server_queue, NULL, reply, &error);
1607
1608                 osync_message_unref(reply);
1609         }
1610
1611         num_msgs2++;
1612
1613         osync_trace(TRACE_EXIT, "%s", __func__);
1614 }
1615
1616 START_TEST (ipc_callback_break)
1617 {
1618         num_msgs = 0;
1619
1620         char *testbed = setup_testbed(NULL);
1621         osync_testing_file_remove("/tmp/testpipe-server");
1622         osync_testing_file_remove("/tmp/testpipe-client");
1623
1624         OSyncError *error = NULL;
1625         server_queue = osync_queue_new("/tmp/testpipe-server", &error);
1626         client_queue = osync_queue_new("/tmp/testpipe-client", &error);
1627         OSyncMessage *message = NULL;
1628
1629         osync_queue_create(server_queue, &error);
1630         fail_unless(error == NULL, NULL);
1631
1632         osync_queue_create(client_queue, &error);
1633         fail_unless(error == NULL, NULL);
1634         char *data = "this is another test string";
1635
1636         pid_t cpid = fork();
1637         if (cpid == 0) { //Child
1638
1639                 GMainContext *context = g_main_context_new();
1640                 OSyncThread *thread = osync_thread_new(context, &error);
1641
1642                 osync_queue_set_message_handler(client_queue, client_handler4, GINT_TO_POINTER(1));
1643
1644                 osync_queue_setup_with_gmainloop(client_queue, context);
1645
1646                 osync_thread_start(thread);
1647
1648                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
1649                 osync_assert(error == NULL);
1650
1651                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
1652                 osync_assert(error == NULL);
1653
1654                 osync_queue_cross_link(client_queue, server_queue);
1655
1656                 while (osync_queue_is_connected(client_queue)) { g_usleep(100); }
1657
1658                 osync_assert(osync_queue_disconnect(server_queue, &error));
1659                 osync_assert(error == NULL);
1660
1661                 osync_thread_stop(thread);
1662                 osync_thread_unref(thread);
1663
1664                 osync_queue_unref(client_queue);
1665                 osync_queue_unref(server_queue);
1666
1667                 g_free(testbed);
1668                 exit(0);
1669         } else {
1670                 GMainContext *context = g_main_context_new();
1671                 OSyncThread *thread = osync_thread_new(context, &error);
1672
1673                 osync_queue_set_message_handler(server_queue, server_handler4, GINT_TO_POINTER(1));
1674
1675                 osync_queue_setup_with_gmainloop(server_queue, context);
1676
1677                 osync_thread_start(thread);
1678
1679                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
1680                 fail_unless(error == NULL, NULL);
1681
1682                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
1683                 fail_unless(error == NULL, NULL);
1684
1685                 int i = 0;
1686                 for (i = 0; i < req_msgs; i++) {
1687                         message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
1688                         fail_unless(message != NULL, NULL);
1689                         fail_unless(!osync_error_is_set(&error), NULL);
1690
1691                         osync_message_write_int(message, 4000000);
1692                         osync_message_write_string(message, "this is a test string");
1693                         osync_message_write_long_long_int(message, 400000000);
1694                         osync_message_write_data(message, data, strlen(data) + 1);
1695
1696                         osync_message_set_handler(message, callback_handler2, GINT_TO_POINTER(1));
1697
1698                         fail_unless(osync_queue_send_message(client_queue, server_queue, message, &error), NULL);
1699                         fail_unless(!osync_error_is_set(&error), NULL);
1700
1701                         osync_message_unref(message);
1702                 }
1703
1704                 message = osync_queue_get_message(client_queue);
1705
1706                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
1707
1708                 osync_message_unref(message);
1709
1710                 while (num_msgs < req_msgs) { g_usleep(100); };
1711
1712                 osync_queue_disconnect(client_queue, &error);
1713                 fail_unless(error == NULL, NULL);
1714
1715                 osync_queue_disconnect(server_queue, &error);
1716                 osync_assert(error == NULL);
1717
1718                 osync_thread_stop(thread);
1719                 osync_thread_unref(thread);
1720
1721                 int status = 0;
1722                 wait(&status);
1723                 fail_unless(WEXITSTATUS(status) == 0, NULL);
1724         }
1725
1726         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
1727
1728         fail_unless(osync_queue_remove(client_queue, &error), NULL);
1729         fail_unless(osync_queue_remove(server_queue, &error), NULL);
1730         fail_unless(!osync_error_is_set(&error), NULL);
1731
1732         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
1733
1734         osync_queue_unref(client_queue);
1735         osync_queue_unref(server_queue);
1736
1737         destroy_testbed(testbed);
1738 }
1739 END_TEST
1740
1741
1742 START_TEST (ipc_pipes)
1743 {
1744         char *testbed = setup_testbed(NULL);
1745
1746         OSyncError *error = NULL;
1747         OSyncQueue *read1 = NULL;
1748         OSyncQueue *write1 = NULL;
1749         char *data = "this is another test string";
1750
1751         osync_assert(osync_queue_new_pipes(&read1, &write1, &error));
1752         osync_assert(error == NULL);
1753
1754         fail_unless(osync_queue_connect(read1, OSYNC_QUEUE_RECEIVER, &error), NULL);
1755         fail_unless(error == NULL, NULL);
1756
1757         fail_unless(osync_queue_connect(write1, OSYNC_QUEUE_SENDER, &error), NULL);
1758         fail_unless(error == NULL, NULL);
1759
1760         OSyncMessage *message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
1761         fail_unless(message != NULL, NULL);
1762         fail_unless(!osync_error_is_set(&error), NULL);
1763
1764         osync_message_write_int(message, 4000000);
1765         osync_message_write_string(message, "this is a test string");
1766         osync_message_write_long_long_int(message, 400000000);
1767         osync_message_write_data(message, data, strlen(data) + 1);
1768
1769         fail_unless(osync_queue_send_message(write1, NULL, message, &error), NULL);
1770         fail_unless(!osync_error_is_set(&error), NULL);
1771         osync_message_unref(message);
1772
1773         message = osync_queue_get_message(read1);
1774         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
1775
1776         int int1;
1777         long long int longint1;
1778         char *string;
1779         void *databuf;
1780
1781         osync_message_read_int(message, &int1);
1782         osync_message_read_const_string(message, &string);
1783         osync_message_read_long_long_int(message, &longint1);
1784         osync_message_read_const_data(message, &databuf, strlen("this is another test string") + 1);
1785
1786         fail_unless(int1 == 4000000, NULL);
1787         fail_unless(!strcmp(string, "this is a test string"), NULL);
1788         fail_unless(longint1 == 400000000, NULL);
1789         fail_unless(!strcmp(databuf, "this is another test string"), NULL);
1790
1791         osync_message_unref(message);
1792
1793         osync_assert(osync_queue_disconnect(read1, &error));
1794         osync_assert(error == NULL);
1795
1796         message = osync_queue_get_message(write1);
1797         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
1798         osync_message_unref(message);
1799
1800         osync_assert(osync_queue_disconnect(write1, &error));
1801         osync_assert(error == NULL);
1802
1803
1804         osync_queue_unref(read1);
1805         osync_queue_unref(write1);
1806
1807         destroy_testbed(testbed);
1808 }
1809 END_TEST
1810
1811 START_TEST (ipc_pipes_stress)
1812 {
1813         char *testbed = setup_testbed(NULL);
1814
1815         OSyncError *error = NULL;
1816         OSyncQueue *read1 = NULL;
1817         OSyncQueue *read2 = NULL;
1818         OSyncQueue *write1 = NULL;
1819         OSyncQueue *write2 = NULL;
1820
1821
1822         // First the pipe from the parent to the child
1823         osync_assert(osync_queue_new_pipes(&read1, &write1, &error));
1824         osync_assert(error == NULL);
1825
1826         // Then the pipe from the child to the parent
1827         osync_assert(osync_queue_new_pipes(&read2, &write2, &error));
1828         osync_assert(error == NULL);
1829
1830         OSyncMessage *message = NULL;
1831
1832         char *data = "this is another test string";
1833
1834         pid_t cpid = fork();
1835         if (cpid == 0) { //Child
1836
1837                 osync_assert(osync_queue_disconnect(write1, &error));
1838                 osync_queue_unref(write1);
1839
1840                 osync_assert(osync_queue_disconnect(read2, &error));
1841                 osync_queue_unref(read2);
1842
1843                 client_queue = read1;
1844                 server_queue = write2;
1845
1846                 GMainContext *context = g_main_context_new();
1847                 OSyncThread *thread = osync_thread_new(context, &error);
1848
1849                 osync_queue_set_message_handler(client_queue, client_handler2, GINT_TO_POINTER(1));
1850
1851                 osync_queue_setup_with_gmainloop(client_queue, context);
1852
1853                 osync_thread_start(thread);
1854
1855                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
1856                 osync_assert(error == NULL);
1857
1858                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
1859                 osync_assert(error == NULL);
1860
1861                 osync_queue_cross_link(client_queue, server_queue);
1862
1863                 message = osync_queue_get_message(server_queue);
1864                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
1865                         exit (1);
1866                 }
1867                 osync_message_unref(message);
1868
1869
1870                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
1871                         exit(1);
1872                 osync_queue_unref(server_queue);
1873
1874                 osync_assert(osync_queue_disconnect(client_queue, &error));
1875                 osync_assert(error == NULL);
1876
1877                 osync_thread_stop(thread);
1878                 osync_thread_unref(thread);
1879
1880                 osync_queue_unref(client_queue);
1881
1882                 g_free(testbed);
1883
1884                 exit(0);
1885         } else {
1886
1887                 osync_assert(osync_queue_disconnect(write2, &error));
1888                 osync_queue_unref(write2);
1889
1890                 osync_assert(osync_queue_disconnect(read1, &error));
1891                 osync_queue_unref(read1);
1892
1893                 client_queue = write1;
1894                 server_queue = read2;
1895
1896                 GMainContext *context = g_main_context_new();
1897                 OSyncThread *thread = osync_thread_new(context, &error);
1898
1899                 osync_queue_set_message_handler(server_queue, server_handler2, GINT_TO_POINTER(1));
1900
1901                 osync_queue_setup_with_gmainloop(server_queue, context);
1902
1903                 osync_thread_start(thread);
1904
1905                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
1906                 fail_unless(error == NULL, NULL);
1907
1908                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
1909                 fail_unless(error == NULL, NULL);
1910
1911                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
1912                 fail_unless(message != NULL, NULL);
1913                 fail_unless(!osync_error_is_set(&error), NULL);
1914
1915                 osync_message_write_int(message, 4000000);
1916                 osync_message_write_string(message, "this is a test string");
1917                 osync_message_write_long_long_int(message, 400000000);
1918                 osync_message_write_data(message, data, strlen(data) + 1);
1919
1920                 fail_unless(osync_queue_send_message(client_queue, NULL, message, &error), NULL);
1921                 fail_unless(!osync_error_is_set(&error), NULL);
1922
1923                 osync_message_unref(message);
1924
1925                 message = osync_queue_get_message(client_queue);
1926                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
1927
1928                 osync_message_unref(message);
1929
1930                 osync_queue_disconnect(client_queue, &error);
1931                 fail_unless(error == NULL, NULL);
1932
1933                 osync_thread_stop(thread);
1934                 osync_thread_unref(thread);
1935
1936                 int status = 0;
1937                 wait(&status);
1938                 fail_unless(WEXITSTATUS(status) == 0, NULL);
1939         }
1940
1941         osync_queue_unref(client_queue);
1942         osync_queue_unref(server_queue);
1943
1944         destroy_testbed(testbed);
1945 }
1946 END_TEST
1947
1948 START_TEST (ipc_callback_break_pipes)
1949 {
1950         num_msgs = 0;
1951
1952         char *testbed = setup_testbed(NULL);
1953
1954         OSyncError *error = NULL;
1955         OSyncQueue *read1 = NULL;
1956         OSyncQueue *read2 = NULL;
1957         OSyncQueue *write1 = NULL;
1958         OSyncQueue *write2 = NULL;
1959         OSyncMessage *message = NULL;
1960
1961         // First the pipe from the parent to the child
1962         osync_assert(osync_queue_new_pipes(&read1, &write1, &error));
1963         osync_assert(error == NULL);
1964
1965         // Then the pipe from the child to the parent
1966         osync_assert(osync_queue_new_pipes(&read2, &write2, &error));
1967         osync_assert(error == NULL);
1968
1969         char *data = "this is another test string";
1970
1971         pid_t cpid = fork();
1972         if (cpid == 0) { //Child
1973
1974                 osync_assert(osync_queue_disconnect(write1, &error));
1975                 osync_queue_unref(write1);
1976
1977                 osync_assert(osync_queue_disconnect(read2, &error));
1978                 osync_queue_unref(read2);
1979
1980                 client_queue = read1;
1981                 server_queue = write2;
1982
1983                 GMainContext *context = g_main_context_new();
1984                 OSyncThread *thread = osync_thread_new(context, &error);
1985
1986                 osync_queue_set_message_handler(client_queue, client_handler4, GINT_TO_POINTER(1));
1987
1988                 osync_queue_setup_with_gmainloop(client_queue, context);
1989
1990                 osync_thread_start(thread);
1991
1992                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
1993                 osync_assert(error == NULL);
1994
1995                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
1996                 osync_assert(error == NULL);
1997
1998                 osync_queue_cross_link(client_queue, server_queue);
1999
2000                 while (osync_queue_is_connected(client_queue)) { g_usleep(100); }
2001
2002                 osync_assert(osync_queue_disconnect(server_queue, &error));
2003                 osync_assert(error == NULL);
2004
2005                 osync_thread_stop(thread);
2006                 osync_thread_unref(thread);
2007
2008                 osync_queue_unref(client_queue);
2009                 osync_queue_unref(server_queue);
2010
2011                 g_free(testbed);
2012                 exit(0);
2013         } else {
2014
2015                 osync_assert(osync_queue_disconnect(write2, &error));
2016                 osync_queue_unref(write2);
2017
2018                 osync_assert(osync_queue_disconnect(read1, &error));
2019                 osync_queue_unref(read1);
2020
2021                 client_queue = write1;
2022                 server_queue = read2;
2023
2024                 GMainContext *context = g_main_context_new();
2025                 OSyncThread *thread = osync_thread_new(context, &error);
2026
2027                 osync_queue_set_message_handler(server_queue, server_handler4, GINT_TO_POINTER(1));
2028
2029                 osync_queue_setup_with_gmainloop(server_queue, context);
2030
2031                 osync_thread_start(thread);
2032
2033                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
2034                 fail_unless(error == NULL, NULL);
2035
2036                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
2037                 fail_unless(error == NULL, NULL);
2038
2039                 int i = 0;
2040                 for (i = 0; i < req_msgs; i++) {
2041                         message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
2042                         fail_unless(message != NULL, NULL);
2043                         fail_unless(!osync_error_is_set(&error), NULL);
2044
2045                         osync_message_write_int(message, 4000000);
2046                         osync_message_write_string(message, "this is a test string");
2047                         osync_message_write_long_long_int(message, 400000000);
2048                         osync_message_write_data(message, data, strlen(data) + 1);
2049
2050                         osync_message_set_handler(message, callback_handler2, GINT_TO_POINTER(1));
2051
2052                         fail_unless(osync_queue_send_message(client_queue, server_queue, message, &error), NULL);
2053                         fail_unless(!osync_error_is_set(&error), NULL);
2054
2055                         osync_message_unref(message);
2056                 }
2057
2058                 message = osync_queue_get_message(client_queue);
2059
2060                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
2061
2062                 osync_message_unref(message);
2063
2064                 while (num_msgs < req_msgs) { g_usleep(100); };
2065
2066                 osync_queue_disconnect(client_queue, &error);
2067                 fail_unless(error == NULL, NULL);
2068
2069                 osync_queue_disconnect(server_queue, &error);
2070                 osync_assert(error == NULL);
2071
2072                 osync_thread_stop(thread);
2073                 osync_thread_unref(thread);
2074
2075                 int status = 0;
2076                 wait(&status);
2077                 fail_unless(WEXITSTATUS(status) == 0, NULL);
2078         }
2079
2080         osync_queue_unref(client_queue);
2081         osync_queue_unref(server_queue);
2082
2083         destroy_testbed(testbed);
2084 }
2085 END_TEST
2086
2087 int num_callback_timeout = 0;
2088 int num_callback = 0;
2089
2090 static void _message_handler(OSyncMessage *message, void *user_data)
2091 {
2092         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
2093         osync_trace(TRACE_INTERNAL, "%s",osync_message_get_commandstr(message));
2094         if (osync_message_is_error(message))
2095                 num_callback_timeout++;
2096         else
2097                 num_callback++;
2098         osync_trace(TRACE_EXIT, "%s", __func__);
2099 }
2100
2101 char *data5 = "this is another test string";
2102 void client_handler5(OSyncMessage *message, void *user_data)
2103 {
2104         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
2105         OSyncError *error = NULL;
2106
2107         osync_assert(GPOINTER_TO_INT(user_data) ==1);
2108         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
2109
2110         int int1;
2111         long long int longint1;
2112         char *string;
2113         char databuf[strlen(data5) + 1];
2114
2115
2116         osync_message_read_int(message, &int1);
2117         osync_message_read_string(message, &string);
2118         osync_message_read_long_long_int(message, &longint1);
2119         osync_message_read_data(message, databuf, strlen(data5) + 1);
2120
2121         osync_assert(int1 == 4000000);
2122         osync_assert(!strcmp(string, "this is a test string"));
2123         osync_assert(longint1 == 400000000);
2124         osync_assert(!strcmp(databuf, data5));
2125
2126         /* TIMEOUT TIMEOUT TIMEOUT (no reply...) */
2127
2128         /* Proper code would reply to this message, but for testing
2129            purposes we don't reply and simulate a "timeout" situation */
2130
2131         osync_trace(TRACE_EXIT, "%s", __func__);
2132 }
2133
2134 START_TEST (ipc_timeout)
2135 {
2136         /* This testcase is inteded to test osync_queue_send_message_with_timeout().
2137            Client got forked and listens for messages from Server and replies.
2138
2139            To simulate a "timeout" situation the Client doesn't reply to one of the Server messages.
2140
2141            The timeout handler will call the _message_handler() with an error.
2142            JFYI, every timed out message calls the callback/message_handler with an (timeout) error.
2143            */
2144
2145         char *testbed = setup_testbed(NULL);
2146         osync_testing_file_remove("/tmp/testpipe-server");
2147         osync_testing_file_remove("/tmp/testpipe-client");
2148
2149         num_callback_timeout = 0;
2150         num_callback = 0;
2151
2152         OSyncError *error = NULL;
2153         server_queue = osync_queue_new("/tmp/testpipe-server", &error);
2154         client_queue = osync_queue_new("/tmp/testpipe-client", &error);
2155         OSyncMessage *message = NULL;
2156
2157         osync_queue_create(server_queue, &error);
2158         fail_unless(error == NULL, NULL);
2159
2160         osync_queue_create(client_queue, &error);
2161         fail_unless(error == NULL, NULL);
2162
2163         pid_t cpid = fork();
2164         if (cpid == 0) { //Child
2165
2166                 GMainContext *context = g_main_context_new();
2167                 OSyncThread *thread = osync_thread_new(context, &error);
2168
2169                 osync_queue_set_message_handler(client_queue, client_handler5, GINT_TO_POINTER(1));
2170                 osync_queue_set_pending_limit(client_queue, OSYNC_QUEUE_PENDING_LIMIT);
2171
2172                 osync_queue_setup_with_gmainloop(client_queue, context);
2173
2174                 osync_thread_start(thread);
2175
2176                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
2177                 osync_assert(error == NULL);
2178
2179                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
2180                 osync_assert(error == NULL);
2181
2182                 osync_queue_cross_link(client_queue, server_queue);
2183
2184                 message = osync_queue_get_message(server_queue);
2185
2186                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
2187                         exit (1);
2188                 }
2189
2190                 osync_message_unref(message);
2191
2192                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
2193                         exit(1);
2194                 osync_queue_unref(server_queue);
2195
2196                 osync_assert(osync_queue_disconnect(client_queue, &error));
2197                 osync_assert(error == NULL);
2198
2199                 osync_thread_stop(thread);
2200                 osync_thread_unref(thread);
2201
2202                 osync_queue_unref(client_queue);
2203
2204                 g_free(testbed);
2205
2206                 exit(0);
2207         } else {
2208                 GMainContext *context = g_main_context_new();
2209                 OSyncThread *thread = osync_thread_new(context, &error);
2210
2211                 osync_queue_set_message_handler(server_queue, server_handler4, GINT_TO_POINTER(1));
2212
2213                 osync_queue_setup_with_gmainloop(server_queue, context);
2214
2215                 osync_thread_start(thread);
2216
2217                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
2218                 fail_unless(error == NULL, NULL);
2219
2220                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
2221                 fail_unless(error == NULL, NULL);
2222
2223                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
2224                 fail_unless(message != NULL, NULL);
2225                 fail_unless(!osync_error_is_set(&error), NULL);
2226
2227                 osync_message_set_handler(message, _message_handler, NULL);
2228
2229                 osync_message_write_int(message, 4000000);
2230                 osync_message_write_string(message, "this is a test string");
2231                 osync_message_write_long_long_int(message, 400000000);
2232                 osync_message_write_data(message, data5, strlen(data5) + 1);
2233
2234                 // Send with timeout of one second
2235                 fail_unless(osync_queue_send_message_with_timeout(client_queue, server_queue, message, 1, &error), NULL);
2236                 fail_unless(!osync_error_is_set(&error), NULL);
2237
2238                 osync_message_unref(message);
2239
2240                 // Block
2241                 g_usleep(5*G_USEC_PER_SEC);
2242
2243                 osync_queue_disconnect(server_queue, &error);
2244                 fail_unless(error == NULL, NULL);
2245
2246                 while (!(message = osync_queue_get_message(client_queue))) {
2247                         g_usleep(10000);
2248                 }
2249
2250                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
2251                         exit (1);
2252                 }
2253                 osync_message_unref(message);
2254
2255                 osync_queue_disconnect(client_queue, &error);
2256                 fail_unless(error == NULL, NULL);
2257
2258                 int status = 0;
2259                 wait(&status);
2260                 fail_unless(WEXITSTATUS(status) == 0, NULL);
2261         }
2262
2263         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
2264
2265         fail_unless(osync_queue_remove(client_queue, &error), NULL);
2266         fail_unless(osync_queue_remove(server_queue, &error), NULL);
2267         fail_unless(!osync_error_is_set(&error), NULL);
2268
2269         /* Check if the timeout handler replied with an error */
2270         fail_unless(num_callback_timeout == 1, NULL);
2271         fail_unless(num_callback == 0, NULL);
2272
2273         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
2274
2275         osync_queue_unref(client_queue);
2276         osync_queue_unref(server_queue);
2277
2278         destroy_testbed(testbed);
2279 }
2280 END_TEST
2281
2282 int ch_sleep_time = 3; // Seconds
2283 void client_handler_sleep(OSyncMessage *message, void *user_data)
2284 {
2285         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
2286         OSyncError *error = NULL;
2287
2288         osync_assert(GPOINTER_TO_INT(user_data) ==1);
2289         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
2290
2291         int int1;
2292         long long int longint1;
2293         char *string;
2294         char databuf[strlen(data5) + 1];
2295
2296
2297         osync_message_read_int(message, &int1);
2298         osync_message_read_string(message, &string);
2299         osync_message_read_long_long_int(message, &longint1);
2300         osync_message_read_data(message, databuf, strlen(data5) + 1);
2301
2302         osync_assert(int1 == 4000000);
2303         osync_assert(!strcmp(string, "this is a test string"));
2304         osync_assert(longint1 == 400000000);
2305         osync_assert(!strcmp(databuf, data5));
2306
2307         // Do some time consuming processing
2308         g_usleep(ch_sleep_time*G_USEC_PER_SEC);
2309
2310         OSyncMessage *reply = osync_message_new_reply(message, &error);
2311
2312         osync_queue_send_message(server_queue, NULL, reply, &error);
2313
2314         osync_message_unref(reply);
2315
2316         osync_trace(TRACE_EXIT, "%s", __func__);
2317 }
2318
2319 START_TEST (ipc_late_reply)
2320 {
2321         /* This testcase is inteded to test osync_queue_send_message_with_timeout().
2322            Client got forked and listens for messages from Server and replies.
2323
2324            To simulate a "timeout" situation the Client delays 3 seconds and then replies
2325
2326            The timeout handler will call the _message_handler() with an error and the late reply
2327            will be discarded.
2328
2329            JFYI, every timed out message calls the callback/message_handler with an (timeout) error.
2330            */
2331
2332         char *testbed = setup_testbed(NULL);
2333         osync_testing_file_remove("/tmp/testpipe-server");
2334         osync_testing_file_remove("/tmp/testpipe-client");
2335
2336         num_callback_timeout = 0;
2337         num_callback = 0;
2338         ch_sleep_time = 3;
2339
2340         OSyncError *error = NULL;
2341         server_queue = osync_queue_new("/tmp/testpipe-server", &error);
2342         client_queue = osync_queue_new("/tmp/testpipe-client", &error);
2343         OSyncMessage *message = NULL;
2344
2345         osync_queue_create(server_queue, &error);
2346         fail_unless(error == NULL, NULL);
2347
2348         osync_queue_create(client_queue, &error);
2349         fail_unless(error == NULL, NULL);
2350
2351         pid_t cpid = fork();
2352         if (cpid == 0) { //Child
2353
2354                 GMainContext *context = g_main_context_new();
2355                 OSyncThread *thread = osync_thread_new(context, &error);
2356
2357                 osync_queue_set_message_handler(client_queue, client_handler_sleep, GINT_TO_POINTER(1));
2358                 osync_queue_set_pending_limit(client_queue, OSYNC_QUEUE_PENDING_LIMIT);
2359
2360                 osync_queue_setup_with_gmainloop(client_queue, context);
2361
2362                 osync_thread_start(thread);
2363
2364                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
2365                 osync_assert(error == NULL);
2366
2367                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
2368                 osync_assert(error == NULL);
2369
2370                 osync_queue_cross_link(client_queue, server_queue);
2371
2372                 message = osync_queue_get_message(server_queue);
2373
2374                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
2375                         exit (1);
2376                 }
2377
2378                 osync_message_unref(message);
2379
2380                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
2381                         exit(1);
2382                 osync_queue_unref(server_queue);
2383
2384                 osync_assert(osync_queue_disconnect(client_queue, &error));
2385                 osync_assert(error == NULL);
2386
2387                 osync_thread_stop(thread);
2388                 osync_thread_unref(thread);
2389
2390                 osync_queue_unref(client_queue);
2391
2392                 g_free(testbed);
2393
2394                 exit(0);
2395         } else {
2396                 GMainContext *context = g_main_context_new();
2397                 OSyncThread *thread = osync_thread_new(context, &error);
2398
2399                 osync_queue_set_message_handler(server_queue, server_handler4, GINT_TO_POINTER(1));
2400
2401                 osync_queue_setup_with_gmainloop(server_queue, context);
2402
2403                 osync_thread_start(thread);
2404
2405                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
2406                 fail_unless(error == NULL, NULL);
2407
2408                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
2409                 fail_unless(error == NULL, NULL);
2410
2411                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
2412                 fail_unless(message != NULL, NULL);
2413                 fail_unless(!osync_error_is_set(&error), NULL);
2414
2415                 osync_message_set_handler(message, _message_handler, NULL);
2416
2417                 osync_message_write_int(message, 4000000);
2418                 osync_message_write_string(message, "this is a test string");
2419                 osync_message_write_long_long_int(message, 400000000);
2420                 osync_message_write_data(message, data5, strlen(data5) + 1);
2421
2422                 // Send with timeout of one second
2423                 fail_unless(osync_queue_send_message_with_timeout(client_queue, server_queue, message, 1, &error), NULL);
2424                 fail_unless(!osync_error_is_set(&error), NULL);
2425
2426                 osync_message_unref(message);
2427
2428                 // Block
2429                 g_usleep(5*G_USEC_PER_SEC);
2430
2431                 osync_queue_disconnect(server_queue, &error);
2432                 fail_unless(error == NULL, NULL);
2433
2434                 while (!(message = osync_queue_get_message(client_queue))) {
2435                         g_usleep(10000);
2436                 }
2437
2438                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
2439                         exit (1);
2440                 }
2441                 osync_message_unref(message);
2442
2443                 osync_queue_disconnect(client_queue, &error);
2444                 fail_unless(error == NULL, NULL);
2445
2446                 int status = 0;
2447                 wait(&status);
2448                 fail_unless(WEXITSTATUS(status) == 0, NULL);
2449         }
2450
2451         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
2452
2453         fail_unless(osync_queue_remove(client_queue, &error), NULL);
2454         fail_unless(osync_queue_remove(server_queue, &error), NULL);
2455         fail_unless(!osync_error_is_set(&error), NULL);
2456
2457         /* Check if the timeout handler replied with an error */
2458         fail_unless(num_callback_timeout == 1, NULL);
2459         fail_unless(num_callback == 0, NULL);
2460
2461         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
2462
2463         osync_queue_unref(client_queue);
2464         osync_queue_unref(server_queue);
2465
2466         destroy_testbed(testbed);
2467 }
2468 END_TEST
2469
2470 START_TEST (ipc_loop_with_timeout)
2471 {
2472
2473         /* Even though each action takes 1 second, none of these messages should time out
2474            as they are being sent with a timeout of 3 seconds */
2475
2476         num_msgs = 0;
2477         req_msgs = 20;
2478         ch_sleep_time = 1; // Second
2479
2480         char *testbed = setup_testbed(NULL);
2481         osync_testing_file_remove("/tmp/testpipe-server");
2482         osync_testing_file_remove("/tmp/testpipe-client");
2483
2484         OSyncError *error = NULL;
2485         server_queue = osync_queue_new("/tmp/testpipe-server", &error);
2486         client_queue = osync_queue_new("/tmp/testpipe-client", &error);
2487         OSyncMessage *message = NULL;
2488
2489         osync_queue_create(server_queue, &error);
2490         fail_unless(error == NULL, NULL);
2491
2492         osync_queue_create(client_queue, &error);
2493         fail_unless(error == NULL, NULL);
2494         char *data = "this is another test string";
2495
2496         pid_t cpid = fork();
2497         if (cpid == 0) { //Child
2498
2499                 GMainContext *context = g_main_context_new();
2500                 OSyncThread *thread = osync_thread_new(context, &error);
2501
2502                 osync_queue_set_message_handler(client_queue, client_handler_sleep, GINT_TO_POINTER(1));
2503                 osync_queue_set_pending_limit(client_queue, OSYNC_QUEUE_PENDING_LIMIT);
2504
2505                 osync_queue_setup_with_gmainloop(client_queue, context);
2506
2507                 osync_thread_start(thread);
2508
2509                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
2510                 osync_assert(error == NULL);
2511
2512                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
2513                 osync_assert(error == NULL);
2514
2515                 osync_queue_cross_link(client_queue, server_queue);
2516
2517                 message = osync_queue_get_message(server_queue);
2518
2519                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
2520                         exit (1);
2521                 }
2522
2523                 osync_message_unref(message);
2524
2525                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
2526                         exit(1);
2527                 osync_queue_unref(server_queue);
2528
2529                 osync_assert(osync_queue_disconnect(client_queue, &error));
2530                 osync_assert(error == NULL);
2531
2532                 osync_thread_stop(thread);
2533                 osync_thread_unref(thread);
2534
2535                 osync_queue_unref(client_queue);
2536
2537                 g_free(testbed);
2538
2539                 exit(0);
2540         } else {
2541                 GMainContext *context = g_main_context_new();
2542                 OSyncThread *thread = osync_thread_new(context, &error);
2543
2544                 osync_queue_set_message_handler(server_queue, server_handler_abort, GINT_TO_POINTER(1));
2545
2546                 osync_queue_setup_with_gmainloop(server_queue, context);
2547
2548                 osync_thread_start(thread);
2549
2550                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
2551                 fail_unless(error == NULL, NULL);
2552
2553                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
2554                 fail_unless(error == NULL, NULL);
2555
2556                 int i = 0;
2557                 for (i = 0; i < req_msgs; i++) {
2558                         message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
2559                         fail_unless(message != NULL, NULL);
2560                         fail_unless(!osync_error_is_set(&error), NULL);
2561
2562                         osync_message_write_int(message, 4000000);
2563                         osync_message_write_string(message, "this is a test string");
2564                         osync_message_write_long_long_int(message, 400000000);
2565                         osync_message_write_data(message, data, strlen(data) + 1);
2566
2567                         osync_message_set_handler(message, callback_handler_check_reply, GINT_TO_POINTER(1));
2568
2569                         fail_unless(osync_queue_send_message_with_timeout(client_queue, server_queue, message, 3, &error), NULL);
2570                         fail_unless(!osync_error_is_set(&error), NULL);
2571
2572                         osync_message_unref(message);
2573                 }
2574
2575                 message = osync_queue_get_message(client_queue);
2576
2577                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
2578
2579                 osync_message_unref(message);
2580
2581                 osync_queue_disconnect(client_queue, &error);
2582                 fail_unless(error == NULL, NULL);
2583
2584                 osync_thread_stop(thread);
2585                 osync_thread_unref(thread);
2586
2587                 int status = 0;
2588                 wait(&status);
2589                 fail_unless(WEXITSTATUS(status) == 0, NULL);
2590         }
2591
2592         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
2593
2594         fail_unless(osync_queue_remove(client_queue, &error), NULL);
2595         fail_unless(osync_queue_remove(server_queue, &error), NULL);
2596         fail_unless(!osync_error_is_set(&error), NULL);
2597
2598         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
2599
2600         osync_queue_unref(client_queue);
2601         osync_queue_unref(server_queue);
2602
2603         destroy_testbed(testbed);
2604 }
2605 END_TEST
2606
2607 GSList *ch_pending = NULL;
2608 void client_handler_first_part(OSyncMessage *message, void *user_data)
2609 {
2610         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
2611         OSyncError *error = NULL;
2612
2613         osync_assert(GPOINTER_TO_INT(user_data) ==1);
2614         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
2615
2616         int int1;
2617         long long int longint1;
2618         char *string;
2619         char databuf[strlen(data5) + 1];
2620
2621
2622         osync_message_read_int(message, &int1);
2623         osync_message_read_string(message, &string);
2624         osync_message_read_long_long_int(message, &longint1);
2625         osync_message_read_data(message, databuf, strlen(data5) + 1);
2626
2627         osync_assert(int1 == 4000000);
2628         osync_assert(!strcmp(string, "this is a test string"));
2629         osync_assert(longint1 == 400000000);
2630         osync_assert(!strcmp(databuf, data5));
2631
2632         // Put message on pending queue and return
2633         osync_message_ref(message);
2634         ch_pending = g_slist_append(ch_pending, message);
2635
2636         osync_trace(TRACE_EXIT, "%s", __func__);
2637 }
2638 gboolean client_handler_second_part(gpointer userdata)
2639 {
2640         OSyncError *error = NULL;
2641
2642         osync_trace(TRACE_ENTRY, "%s(%p)", __func__, userdata);
2643
2644         if (ch_pending) {
2645
2646                 OSyncMessage *message = ch_pending->data;
2647
2648                 OSyncMessage *reply = osync_message_new_reply(message, &error);
2649
2650                 osync_queue_send_message(server_queue, NULL, reply, &error);
2651
2652                 osync_message_unref(reply);
2653
2654                 ch_pending = g_slist_remove(ch_pending, message);
2655                 osync_message_unref(message);
2656
2657                 osync_trace(TRACE_EXIT, "%s", __func__);
2658                 return TRUE;
2659         }
2660
2661         osync_trace(TRACE_EXIT, "%s: no more entries", __func__);
2662         return FALSE;
2663 }
2664
2665 START_TEST (ipc_loop_timeout_with_idle)
2666 {
2667
2668         /* Same as ipc_loop_with_timeout except that the client handler doesn't sleep,
2669            so the queue dispatchers can run while the operation is waiting.
2670            Even though each action takes 1 second, and might be delayed by 3 seconds
2671            due to the messages already processed on the pending queue, none of these
2672            messages should time out as they are being sent with a timeout of 5 seconds */
2673
2674         num_msgs = 0;
2675         req_msgs = 10;
2676
2677         char *testbed = setup_testbed(NULL);
2678         osync_testing_file_remove("/tmp/testpipe-server");
2679         osync_testing_file_remove("/tmp/testpipe-client");
2680
2681         OSyncError *error = NULL;
2682         server_queue = osync_queue_new("/tmp/testpipe-server", &error);
2683         client_queue = osync_queue_new("/tmp/testpipe-client", &error);
2684         OSyncMessage *message = NULL;
2685
2686         osync_queue_create(server_queue, &error);
2687         fail_unless(error == NULL, NULL);
2688
2689         osync_queue_create(client_queue, &error);
2690         fail_unless(error == NULL, NULL);
2691         char *data = "this is another test string";
2692
2693         pid_t cpid = fork();
2694         if (cpid == 0) { //Child
2695
2696                 GMainContext *context = g_main_context_new();
2697                 OSyncThread *thread = osync_thread_new(context, &error);
2698
2699                 osync_queue_set_message_handler(client_queue, client_handler_first_part, GINT_TO_POINTER(1));
2700                 // Set pending limit to 3 so response wil be delayed at most 3 seconds
2701                 osync_queue_set_pending_limit(client_queue, 3);
2702
2703                 osync_queue_setup_with_gmainloop(client_queue, context);
2704
2705                 osync_thread_start(thread);
2706
2707                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
2708                 osync_assert(error == NULL);
2709
2710                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
2711                 osync_assert(error == NULL);
2712
2713                 osync_queue_cross_link(client_queue, server_queue);
2714
2715                 GSource *tsource = g_timeout_source_new(1000);
2716                 osync_assert(tsource);
2717                 g_source_set_callback(tsource, client_handler_second_part, NULL, NULL);
2718                 osync_assert(g_source_attach(tsource, context));
2719                 g_source_unref(tsource);
2720
2721                 message = osync_queue_get_message(server_queue);
2722
2723                 if (osync_message_get_command(message) != OSYNC_MESSAGE_QUEUE_HUP) {
2724                         exit (1);
2725                 }
2726
2727                 osync_message_unref(message);
2728
2729                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
2730                         exit(1);
2731                 osync_queue_unref(server_queue);
2732
2733                 osync_assert(osync_queue_disconnect(client_queue, &error));
2734                 osync_assert(error == NULL);
2735
2736                 osync_thread_stop(thread);
2737                 osync_thread_unref(thread);
2738
2739                 osync_queue_unref(client_queue);
2740
2741                 g_free(testbed);
2742
2743                 exit(0);
2744         } else {
2745                 GMainContext *context = g_main_context_new();
2746                 OSyncThread *thread = osync_thread_new(context, &error);
2747
2748                 osync_queue_set_message_handler(server_queue, server_handler_abort, GINT_TO_POINTER(1));
2749
2750                 osync_queue_setup_with_gmainloop(server_queue, context);
2751
2752                 osync_thread_start(thread);
2753
2754                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
2755                 fail_unless(error == NULL, NULL);
2756
2757                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
2758                 fail_unless(error == NULL, NULL);
2759
2760                 int i = 0;
2761                 for (i = 0; i < req_msgs; i++) {
2762                         message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
2763                         fail_unless(message != NULL, NULL);
2764                         fail_unless(!osync_error_is_set(&error), NULL);
2765
2766                         osync_message_write_int(message, 4000000);
2767                         osync_message_write_string(message, "this is a test string");
2768                         osync_message_write_long_long_int(message, 400000000);
2769                         osync_message_write_data(message, data, strlen(data) + 1);
2770
2771                         osync_message_set_handler(message, callback_handler_check_reply, GINT_TO_POINTER(1));
2772
2773                         // Timeout of 5 will do as pending limit is 3
2774                         fail_unless(osync_queue_send_message_with_timeout(client_queue, server_queue, message, 5, &error), NULL);
2775                         fail_unless(!osync_error_is_set(&error), NULL);
2776
2777                         osync_message_unref(message);
2778                 }
2779
2780                 message = osync_queue_get_message(client_queue);
2781
2782                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
2783
2784                 osync_message_unref(message);
2785
2786                 osync_queue_disconnect(client_queue, &error);
2787                 fail_unless(error == NULL, NULL);
2788
2789                 osync_thread_stop(thread);
2790                 osync_thread_unref(thread);
2791
2792                 int status = 0;
2793                 wait(&status);
2794                 fail_unless(WEXITSTATUS(status) == 0, NULL);
2795         }
2796
2797         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
2798
2799         fail_unless(osync_queue_remove(client_queue, &error), NULL);
2800         fail_unless(osync_queue_remove(server_queue, &error), NULL);
2801         fail_unless(!osync_error_is_set(&error), NULL);
2802
2803         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
2804
2805         osync_queue_unref(client_queue);
2806         osync_queue_unref(server_queue);
2807
2808         destroy_testbed(testbed);
2809 }
2810 END_TEST
2811
2812 void client_handler6(OSyncMessage *message, void *user_data)
2813 {
2814         osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, message, user_data);
2815         OSyncError *error = NULL;
2816
2817         osync_assert(GPOINTER_TO_INT(user_data) ==1);
2818
2819         if (osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_ERROR) {
2820                 osync_queue_disconnect(client_queue, NULL);
2821                 osync_trace(TRACE_EXIT, "%s: disconnect", __func__);
2822                 return;
2823         }
2824
2825         osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_INITIALIZE);
2826
2827         int int1;
2828         long long int longint1;
2829         char *string;
2830         char databuf[strlen(data5) + 1];
2831
2832         osync_message_read_int(message, &int1);
2833         osync_message_read_string(message, &string);
2834         osync_message_read_long_long_int(message, &longint1);
2835         osync_message_read_data(message, databuf, strlen(data5) + 1);
2836
2837         osync_assert(int1 == 4000000);
2838         osync_assert(!strcmp(string, "this is a test string"));
2839         osync_assert(longint1 == 400000000);
2840         osync_assert(!strcmp(databuf, data5));
2841
2842         /* TIMEOUT TIMEOUT TIMEOUT (no reply...) */
2843
2844         /* Proper code would reply to this message, but for testing
2845            purposes we don't reply and simulate a "timeout" situation */
2846
2847         osync_trace(TRACE_EXIT, "%s", __func__);
2848 }
2849 START_TEST (ipc_timeout_noreplyq)
2850 {
2851         /* This testcase is inteded to test timeout before the command and reply queues are cross-linked.
2852            Client got forked and listens for messages from Server and replies.
2853
2854            To simulate a "timeout" situation the Client doesn't reply to one of the Server messages.
2855
2856            As there is no reply queue, an error will be sent to the **client**, who then disconnects
2857            so an error (although not a timeout) ends up sent to the server.
2858            */
2859
2860         char *testbed = setup_testbed(NULL);
2861         osync_testing_file_remove("/tmp/testpipe-server");
2862         osync_testing_file_remove("/tmp/testpipe-client");
2863
2864         num_callback_timeout = 0;
2865         num_callback = 0;
2866
2867         OSyncError *error = NULL;
2868         server_queue = osync_queue_new("/tmp/testpipe-server", &error);
2869         client_queue = osync_queue_new("/tmp/testpipe-client", &error);
2870         OSyncMessage *message = NULL;
2871
2872         osync_queue_create(server_queue, &error);
2873         fail_unless(error == NULL, NULL);
2874
2875         osync_queue_create(client_queue, &error);
2876         fail_unless(error == NULL, NULL);
2877
2878         pid_t cpid = fork();
2879         if (cpid == 0) { //Child
2880
2881                 GMainContext *context = g_main_context_new();
2882                 OSyncThread *thread = osync_thread_new(context, &error);
2883
2884                 osync_queue_set_message_handler(client_queue, client_handler6, GINT_TO_POINTER(1));
2885                 osync_queue_set_pending_limit(client_queue, OSYNC_QUEUE_PENDING_LIMIT);
2886
2887                 osync_queue_setup_with_gmainloop(client_queue, context);
2888
2889                 osync_thread_start(thread);
2890
2891                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
2892                 osync_assert(error == NULL);
2893
2894                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
2895                 osync_assert(error == NULL);
2896
2897                 /* Do not cross-link */
2898                 /*osync_queue_cross_link(client_queue, server_queue);*/
2899
2900                 message = osync_queue_get_message(server_queue);
2901
2902                 osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
2903
2904                 osync_message_unref(message);
2905
2906                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
2907                         exit(1);
2908                 osync_queue_unref(server_queue);
2909
2910                 osync_assert(osync_queue_disconnect(client_queue, &error));
2911                 osync_assert(error == NULL);
2912
2913                 osync_thread_stop(thread);
2914                 osync_thread_unref(thread);
2915
2916                 osync_queue_unref(client_queue);
2917
2918                 g_free(testbed);
2919
2920                 exit(0);
2921         } else {
2922                 GMainContext *context = g_main_context_new();
2923                 OSyncThread *thread = osync_thread_new(context, &error);
2924
2925                 osync_queue_set_message_handler(server_queue, server_handler4, GINT_TO_POINTER(1));
2926
2927                 osync_queue_setup_with_gmainloop(server_queue, context);
2928
2929                 osync_thread_start(thread);
2930
2931                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
2932                 fail_unless(error == NULL, NULL);
2933
2934                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
2935                 fail_unless(error == NULL, NULL);
2936
2937                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
2938                 fail_unless(message != NULL, NULL);
2939                 fail_unless(!osync_error_is_set(&error), NULL);
2940
2941                 osync_message_set_handler(message, _message_handler, NULL);
2942
2943                 osync_message_write_int(message, 4000000);
2944                 osync_message_write_string(message, "this is a test string");
2945                 osync_message_write_long_long_int(message, 400000000);
2946                 osync_message_write_data(message, data5, strlen(data5) + 1);
2947
2948                 // Send with timeout of one second
2949                 fail_unless(osync_queue_send_message_with_timeout(client_queue, server_queue, message, 1, &error), NULL);
2950                 fail_unless(!osync_error_is_set(&error), NULL);
2951
2952                 osync_message_unref(message);
2953
2954                 while (!(message = osync_queue_get_message(client_queue))) {
2955                         g_usleep(10000);
2956                 }
2957
2958                 fail_unless(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
2959                 osync_message_unref(message);
2960
2961                 osync_queue_disconnect(client_queue, &error);
2962                 fail_unless(error == NULL, NULL);
2963
2964                 osync_queue_disconnect(server_queue, &error);
2965                 fail_unless(error == NULL, NULL);
2966
2967                 int status = 0;
2968                 wait(&status);
2969                 fail_unless(WEXITSTATUS(status) == 0, NULL);
2970         }
2971
2972         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
2973
2974         fail_unless(osync_queue_remove(client_queue, &error), NULL);
2975         fail_unless(osync_queue_remove(server_queue, &error), NULL);
2976         fail_unless(!osync_error_is_set(&error), NULL);
2977
2978         /* Check if the timeout handler replied with an error */
2979         fail_unless(num_callback_timeout == 1, NULL);
2980         fail_unless(num_callback == 0, NULL);
2981
2982         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
2983
2984         osync_queue_unref(client_queue);
2985         osync_queue_unref(server_queue);
2986
2987         destroy_testbed(testbed);
2988 }
2989 END_TEST
2990
2991 START_TEST (ipc_timeout_noreceiver)
2992 {
2993         /* This testcase is intended to test the case where the receiver is not even listening,
2994            and so does not run the timeout.
2995         */
2996
2997         char *testbed = setup_testbed(NULL);
2998         osync_testing_file_remove("/tmp/testpipe-server");
2999         osync_testing_file_remove("/tmp/testpipe-client");
3000
3001         num_callback_timeout = 0;
3002         num_callback = 0;
3003
3004         OSyncError *error = NULL;
3005         server_queue = osync_queue_new("/tmp/testpipe-server", &error);
3006         client_queue = osync_queue_new("/tmp/testpipe-client", &error);
3007         OSyncMessage *message = NULL;
3008
3009         osync_queue_create(server_queue, &error);
3010         fail_unless(error == NULL, NULL);
3011
3012         osync_queue_create(client_queue, &error);
3013         fail_unless(error == NULL, NULL);
3014
3015         pid_t cpid = fork();
3016         if (cpid == 0) { //Child
3017
3018                 GMainContext *context = g_main_context_new();
3019                 OSyncThread *thread = osync_thread_new(context, &error);
3020
3021                 osync_queue_set_message_handler(client_queue, client_handler1, GINT_TO_POINTER(1));
3022                 osync_queue_set_pending_limit(client_queue, OSYNC_QUEUE_PENDING_LIMIT);
3023
3024                 /* Do not start receiver */
3025                 /* osync_queue_setup_with_gmainloop(client_queue, context); */
3026
3027                 osync_thread_start(thread);
3028
3029                 osync_assert(osync_queue_connect(client_queue, OSYNC_QUEUE_RECEIVER, &error));
3030                 osync_assert(error == NULL);
3031
3032                 osync_assert(osync_queue_connect(server_queue, OSYNC_QUEUE_SENDER, &error));
3033                 osync_assert(error == NULL);
3034
3035                 /* Do not cross-link */
3036                 osync_queue_cross_link(client_queue, server_queue);
3037
3038                 message = osync_queue_get_message(server_queue);
3039
3040                 osync_assert(osync_message_get_command(message) == OSYNC_MESSAGE_QUEUE_HUP);
3041
3042                 osync_message_unref(message);
3043
3044                 if (osync_queue_disconnect(server_queue, &error) != TRUE || error != NULL)
3045                         exit(1);
3046                 osync_queue_unref(server_queue);
3047
3048                 osync_assert(osync_queue_disconnect(client_queue, &error));
3049                 osync_assert(error == NULL);
3050
3051                 osync_thread_stop(thread);
3052                 osync_thread_unref(thread);
3053
3054                 osync_queue_unref(client_queue);
3055
3056                 g_free(testbed);
3057
3058                 exit(0);
3059         } else {
3060                 GMainContext *context = g_main_context_new();
3061                 OSyncThread *thread = osync_thread_new(context, &error);
3062
3063                 osync_queue_set_message_handler(server_queue, server_handler4, GINT_TO_POINTER(1));
3064
3065                 osync_queue_setup_with_gmainloop(server_queue, context);
3066
3067                 osync_thread_start(thread);
3068
3069                 fail_unless(osync_queue_connect(client_queue, OSYNC_QUEUE_SENDER, &error), NULL);
3070                 fail_unless(error == NULL, NULL);
3071
3072                 fail_unless(osync_queue_connect(server_queue, OSYNC_QUEUE_RECEIVER, &error), NULL);
3073                 fail_unless(error == NULL, NULL);
3074
3075                 message = osync_message_new(OSYNC_MESSAGE_INITIALIZE, 0, &error);
3076                 fail_unless(message != NULL, NULL);
3077                 fail_unless(!osync_error_is_set(&error), NULL);
3078
3079                 osync_message_set_handler(message, _message_handler, NULL);
3080
3081                 osync_message_write_int(message, 4000000);
3082                 osync_message_write_string(message, "this is a test string");
3083                 osync_message_write_long_long_int(message, 400000000);
3084                 osync_message_write_data(message, data5, strlen(data5) + 1);
3085
3086                 // Send with timeout of one second
3087                 fail_unless(osync_queue_send_message_with_timeout(client_queue, server_queue, message, 1, &error), NULL);
3088                 fail_unless(!osync_error_is_set(&error), NULL);
3089
3090                 osync_message_unref(message);
3091
3092                 /* Note: OSYNC_QUEUE_PENDING_QUEUE_MIN_TIMEOUT is 20 */
3093                 g_usleep(25*G_USEC_PER_SEC);
3094
3095                 /* Check if the timeout handler replied with an error.
3096                    Note: it is important we check **before** we start disconnecting
3097                    otherwise we are not testing the right thing */
3098                 fail_unless(num_callback_timeout == 1, NULL);
3099                 fail_unless(num_callback == 0, NULL);
3100
3101                 osync_queue_disconnect(client_queue, &error);
3102                 fail_unless(error == NULL, NULL);
3103
3104                 osync_queue_disconnect(server_queue, &error);
3105                 fail_unless(error == NULL, NULL);
3106
3107                 int status = 0;
3108                 wait(&status);
3109                 fail_unless(WEXITSTATUS(status) == 0, NULL);
3110         }
3111
3112         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == TRUE, NULL);
3113
3114         fail_unless(osync_queue_remove(client_queue, &error), NULL);
3115         fail_unless(osync_queue_remove(server_queue, &error), NULL);
3116         fail_unless(!osync_error_is_set(&error), NULL);
3117
3118         fail_unless(osync_testing_file_exists("/tmp/testpipe-client") == FALSE, NULL);
3119
3120         osync_queue_unref(client_queue);
3121         osync_queue_unref(server_queue);
3122
3123         destroy_testbed(testbed);
3124 }
3125 END_TEST
3126
3127 OSYNC_TESTCASE_START("ipc")
3128 OSYNC_TESTCASE_ADD(ipc_new)
3129 OSYNC_TESTCASE_ADD(ipc_ref)
3130 OSYNC_TESTCASE_ADD(ipc_create)
3131 OSYNC_TESTCASE_ADD(ipc_connect)
3132 OSYNC_TESTCASE_ADD(ipc_payload)
3133 OSYNC_TESTCASE_ADD(ipc_payload_wait)
3134 OSYNC_TESTCASE_ADD(ipc_payload_stress)
3135 OSYNC_TESTCASE_ADD(ipc_payload_stress2)
3136 OSYNC_TESTCASE_ADD(ipc_large_payload)
3137
3138 OSYNC_TESTCASE_ADD(ipc_error_no_pipe)
3139 OSYNC_TESTCASE_ADD(ipc_error_perm)
3140 OSYNC_TESTCASE_ADD(ipc_error_rem)
3141 OSYNC_TESTCASE_ADD(ipc_error_rem2)
3142
3143 OSYNC_TESTCASE_ADD(ipc_loop_payload)
3144 OSYNC_TESTCASE_ADD(ipc_loop_stress)
3145 OSYNC_TESTCASE_ADD(ipc_loop_callback)
3146 OSYNC_TESTCASE_ADD(ipc_callback_break)
3147
3148 OSYNC_TESTCASE_ADD(ipc_pipes)
3149 OSYNC_TESTCASE_ADD(ipc_pipes_stress)
3150 OSYNC_TESTCASE_ADD(ipc_callback_break_pipes)
3151
3152 OSYNC_TESTCASE_ADD(ipc_timeout)
3153 OSYNC_TESTCASE_ADD(ipc_late_reply)
3154 OSYNC_TESTCASE_ADD(ipc_loop_with_timeout)
3155 OSYNC_TESTCASE_ADD(ipc_loop_timeout_with_idle)
3156 OSYNC_TESTCASE_ADD(ipc_timeout_noreplyq)
3157 OSYNC_TESTCASE_ADD(ipc_timeout_noreceiver)
3158 OSYNC_TESTCASE_END
3159