external/bsd/libevent/dist/test/regress.c

   1 /*      $NetBSD$        */
   2 /*
   3  * Copyright (c) 2003, 2004 Niels Provos <provos@citi.umich.edu>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #ifdef WIN32
  30 #include <winsock2.h>
  31 #include <windows.h>
  32 #endif
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include "config.h"
  36 #endif
  37
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40 #ifdef HAVE_SYS_TIME_H
  41 #include <sys/time.h>
  42 #endif
  43 #include <sys/queue.h>
  44 #ifndef WIN32
  45 #include <sys/socket.h>
  46 #include <sys/wait.h>
  47 #include <signal.h>
  48 #include <unistd.h>
  49 #include <netdb.h>
  50 #endif
  51 #include <assert.h>
  52 #include <fcntl.h>
  53 #include <signal.h>
  54 #include <stdlib.h>
  55 #include <stdio.h>
  56 #include <string.h>
  57 #include <errno.h>
  58
  59 #include "event.h"
  60 #include "evutil.h"
  61 #include "event-internal.h"
  62 #include "log.h"
  63
  64 #include "regress.h"
  65 #ifndef WIN32
  66 #include "regress.gen.h"
  67 #endif
  68
  69 int pair[2];
  70 int test_ok;
  71 static int called;
  72 static char wbuf[4096];
  73 static char rbuf[4096];
  74 static int woff;
  75 static int roff;
  76 static int usepersist;
  77 static struct timeval tset;
  78 static struct timeval tcalled;
  79 static struct event_base *global_base;
  80
  81 #define TEST1   "this is a test"
  82 #define SECONDS 1
  83
  84 #ifndef SHUT_WR
  85 #define SHUT_WR 1
  86 #endif
  87
  88 #ifdef WIN32
  89 #define write(fd,buf,len) send((fd),(buf),(len),0)
  90 #define read(fd,buf,len) recv((fd),(buf),(len),0)
  91 #endif
  92
  93 static void
  94 simple_read_cb(int fd, short event, void *arg)
  95 {
  96         char buf[256];
  97         int len;
  98
  99         if (arg == NULL)
 100                 return;
 101
 102         len = read(fd, buf, sizeof(buf));
 103
 104         if (len) {
 105                 if (!called) {
 106                         if (event_add(arg, NULL) == -1)
 107                                 exit(1);
 108                 }
 109         } else if (called == 1)
 110                 test_ok = 1;
 111
 112         called++;
 113 }
 114
 115 static void
 116 simple_write_cb(int fd, short event, void *arg)
 117 {
 118         int len;
 119
 120         if (arg == NULL)
 121                 return;
 122
 123         len = write(fd, TEST1, strlen(TEST1) + 1);
 124         if (len == -1)
 125                 test_ok = 0;
 126         else
 127                 test_ok = 1;
 128 }
 129
 130 static void
 131 multiple_write_cb(int fd, short event, void *arg)
 132 {
 133         struct event *ev = arg;
 134         int len;
 135
 136         len = 128;
 137         if (woff + len >= sizeof(wbuf))
 138                 len = sizeof(wbuf) - woff;
 139
 140         len = write(fd, wbuf + woff, len);
 141         if (len == -1) {
 142                 fprintf(stderr, "%s: write\n", __func__);
 143                 if (usepersist)
 144                         event_del(ev);
 145                 return;
 146         }
 147
 148         woff += len;
 149
 150         if (woff >= sizeof(wbuf)) {
 151                 shutdown(fd, SHUT_WR);
 152                 if (usepersist)
 153                         event_del(ev);
 154                 return;
 155         }
 156
 157         if (!usepersist) {
 158                 if (event_add(ev, NULL) == -1)
 159                         exit(1);
 160         }
 161 }
 162
 163 static void
 164 multiple_read_cb(int fd, short event, void *arg)
 165 {
 166         struct event *ev = arg;
 167         int len;
 168
 169         len = read(fd, rbuf + roff, sizeof(rbuf) - roff);
 170         if (len == -1)
 171                 fprintf(stderr, "%s: read\n", __func__);
 172         if (len <= 0) {
 173                 if (usepersist)
 174                         event_del(ev);
 175                 return;
 176         }
 177
 178         roff += len;
 179         if (!usepersist) {
 180                 if (event_add(ev, NULL) == -1)
 181                         exit(1);
 182         }
 183 }
 184
 185 static void
 186 timeout_cb(int fd, short event, void *arg)
 187 {
 188         struct timeval tv;
 189         int diff;
 190
 191         evutil_gettimeofday(&tcalled, NULL);
 192         if (evutil_timercmp(&tcalled, &tset, >))
 193                 evutil_timersub(&tcalled, &tset, &tv);
 194         else
 195                 evutil_timersub(&tset, &tcalled, &tv);
 196
 197         diff = tv.tv_sec*1000 + tv.tv_usec/1000 - SECONDS * 1000;
 198         if (diff < 0)
 199                 diff = -diff;
 200
 201         if (diff < 100)
 202                 test_ok = 1;
 203 }
 204
 205 #ifndef WIN32
 206 static void
 207 signal_cb_sa(int sig)
 208 {
 209         test_ok = 2;
 210 }
 211
 212 static void
 213 signal_cb(int fd, short event, void *arg)
 214 {
 215         struct event *ev = arg;
 216
 217         signal_del(ev);
 218         test_ok = 1;
 219 }
 220 #endif
 221
 222 struct both {
 223         struct event ev;
 224         int nread;
 225 };
 226
 227 static void
 228 combined_read_cb(int fd, short event, void *arg)
 229 {
 230         struct both *both = arg;
 231         char buf[128];
 232         int len;
 233
 234         len = read(fd, buf, sizeof(buf));
 235         if (len == -1)
 236                 fprintf(stderr, "%s: read\n", __func__);
 237         if (len <= 0)
 238                 return;
 239
 240         both->nread += len;
 241         if (event_add(&both->ev, NULL) == -1)
 242                 exit(1);
 243 }
 244
 245 static void
 246 combined_write_cb(int fd, short event, void *arg)
 247 {
 248         struct both *both = arg;
 249         char buf[128];
 250         int len;
 251
 252         len = sizeof(buf);
 253         if (len > both->nread)
 254                 len = both->nread;
 255
 256         len = write(fd, buf, len);
 257         if (len == -1)
 258                 fprintf(stderr, "%s: write\n", __func__);
 259         if (len <= 0) {
 260                 shutdown(fd, SHUT_WR);
 261                 return;
 262         }
 263
 264         both->nread -= len;
 265         if (event_add(&both->ev, NULL) == -1)
 266                 exit(1);
 267 }
 268
 269 /* Test infrastructure */
 270
 271 static int
 272 setup_test(const char *name)
 273 {
 274
 275         fprintf(stdout, "%s", name);
 276
 277         if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {
 278                 fprintf(stderr, "%s: socketpair\n", __func__);
 279                 exit(1);
 280         }
 281
 282 #ifdef HAVE_FCNTL
 283         if (fcntl(pair[0], F_SETFL, O_NONBLOCK) == -1)
 284                 fprintf(stderr, "fcntl(O_NONBLOCK)");
 285
 286         if (fcntl(pair[1], F_SETFL, O_NONBLOCK) == -1)
 287                 fprintf(stderr, "fcntl(O_NONBLOCK)");
 288 #endif
 289
 290         test_ok = 0;
 291         called = 0;
 292         return (0);
 293 }
 294
 295 static int
 296 cleanup_test(void)
 297 {
 298 #ifndef WIN32
 299         close(pair[0]);
 300         close(pair[1]);
 301 #else
 302         CloseHandle((HANDLE)pair[0]);
 303         CloseHandle((HANDLE)pair[1]);
 304 #endif
 305         if (test_ok)
 306                 fprintf(stdout, "OK\n");
 307         else {
 308                 fprintf(stdout, "FAILED\n");
 309                 exit(1);
 310         }
 311         test_ok = 0;
 312         return (0);
 313 }
 314
 315 static void
 316 test_registerfds(void)
 317 {
 318         int i, j;
 319         int pair[2];
 320         struct event read_evs[512];
 321         struct event write_evs[512];
 322
 323         struct event_base *base = event_base_new();
 324
 325         fprintf(stdout, "Testing register fds: ");
 326
 327         for (i = 0; i < 512; ++i) {
 328                 if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {
 329                         /* run up to the limit of file descriptors */
 330                         break;
 331                 }
 332                 event_set(&read_evs[i], pair[0],
 333                     EV_READ|EV_PERSIST, simple_read_cb, NULL);
 334                 event_base_set(base, &read_evs[i]);
 335                 event_add(&read_evs[i], NULL);
 336                 event_set(&write_evs[i], pair[1],
 337                     EV_WRITE|EV_PERSIST, simple_write_cb, NULL);
 338                 event_base_set(base, &write_evs[i]);
 339                 event_add(&write_evs[i], NULL);
 340
 341                 /* just loop once */
 342                 event_base_loop(base, EVLOOP_ONCE);
 343         }
 344
 345         /* now delete everything */
 346         for (j = 0; j < i; ++j) {
 347                 event_del(&read_evs[j]);
 348                 event_del(&write_evs[j]);
 349 #ifndef WIN32
 350                 close(read_evs[j].ev_fd);
 351                 close(write_evs[j].ev_fd);
 352 #else
 353                 CloseHandle((HANDLE)read_evs[j].ev_fd);
 354                 CloseHandle((HANDLE)write_evs[j].ev_fd);
 355 #endif
 356
 357                 /* just loop once */
 358                 event_base_loop(base, EVLOOP_ONCE);
 359         }
 360
 361         event_base_free(base);
 362
 363         fprintf(stdout, "OK\n");
 364 }
 365
 366 static void
 367 test_simpleread(void)
 368 {
 369         struct event ev;
 370
 371         /* Very simple read test */
 372         setup_test("Simple read: ");
 373
 374         write(pair[0], TEST1, strlen(TEST1)+1);
 375         shutdown(pair[0], SHUT_WR);
 376
 377         event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
 378         if (event_add(&ev, NULL) == -1)
 379                 exit(1);
 380         event_dispatch();
 381
 382         cleanup_test();
 383 }
 384
 385 static void
 386 test_simplewrite(void)
 387 {
 388         struct event ev;
 389
 390         /* Very simple write test */
 391         setup_test("Simple write: ");
 392
 393         event_set(&ev, pair[0], EV_WRITE, simple_write_cb, &ev);
 394         if (event_add(&ev, NULL) == -1)
 395                 exit(1);
 396         event_dispatch();
 397
 398         cleanup_test();
 399 }
 400
 401 static void
 402 test_multiple(void)
 403 {
 404         struct event ev, ev2;
 405         int i;
 406
 407         /* Multiple read and write test */
 408         setup_test("Multiple read/write: ");
 409         memset(rbuf, 0, sizeof(rbuf));
 410         for (i = 0; i < sizeof(wbuf); i++)
 411                 wbuf[i] = i;
 412
 413         roff = woff = 0;
 414         usepersist = 0;
 415
 416         event_set(&ev, pair[0], EV_WRITE, multiple_write_cb, &ev);
 417         if (event_add(&ev, NULL) == -1)
 418                 exit(1);
 419         event_set(&ev2, pair[1], EV_READ, multiple_read_cb, &ev2);
 420         if (event_add(&ev2, NULL) == -1)
 421                 exit(1);
 422         event_dispatch();
 423
 424         if (roff == woff)
 425                 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
 426
 427         cleanup_test();
 428 }
 429
 430 static void
 431 test_persistent(void)
 432 {
 433         struct event ev, ev2;
 434         int i;
 435
 436         /* Multiple read and write test with persist */
 437         setup_test("Persist read/write: ");
 438         memset(rbuf, 0, sizeof(rbuf));
 439         for (i = 0; i < sizeof(wbuf); i++)
 440                 wbuf[i] = i;
 441
 442         roff = woff = 0;
 443         usepersist = 1;
 444
 445         event_set(&ev, pair[0], EV_WRITE|EV_PERSIST, multiple_write_cb, &ev);
 446         if (event_add(&ev, NULL) == -1)
 447                 exit(1);
 448         event_set(&ev2, pair[1], EV_READ|EV_PERSIST, multiple_read_cb, &ev2);
 449         if (event_add(&ev2, NULL) == -1)
 450                 exit(1);
 451         event_dispatch();
 452
 453         if (roff == woff)
 454                 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
 455
 456         cleanup_test();
 457 }
 458
 459 static void
 460 test_combined(void)
 461 {
 462         struct both r1, r2, w1, w2;
 463
 464         setup_test("Combined read/write: ");
 465         memset(&r1, 0, sizeof(r1));
 466         memset(&r2, 0, sizeof(r2));
 467         memset(&w1, 0, sizeof(w1));
 468         memset(&w2, 0, sizeof(w2));
 469
 470         w1.nread = 4096;
 471         w2.nread = 8192;
 472
 473         event_set(&r1.ev, pair[0], EV_READ, combined_read_cb, &r1);
 474         event_set(&w1.ev, pair[0], EV_WRITE, combined_write_cb, &w1);
 475         event_set(&r2.ev, pair[1], EV_READ, combined_read_cb, &r2);
 476         event_set(&w2.ev, pair[1], EV_WRITE, combined_write_cb, &w2);
 477         if (event_add(&r1.ev, NULL) == -1)
 478                 exit(1);
 479         if (event_add(&w1.ev, NULL))
 480                 exit(1);
 481         if (event_add(&r2.ev, NULL))
 482                 exit(1);
 483         if (event_add(&w2.ev, NULL))
 484                 exit(1);
 485
 486         event_dispatch();
 487
 488         if (r1.nread == 8192 && r2.nread == 4096)
 489                 test_ok = 1;
 490
 491         cleanup_test();
 492 }
 493
 494 static void
 495 test_simpletimeout(void)
 496 {
 497         struct timeval tv;
 498         struct event ev;
 499
 500         setup_test("Simple timeout: ");
 501
 502         tv.tv_usec = 0;
 503         tv.tv_sec = SECONDS;
 504         evtimer_set(&ev, timeout_cb, NULL);
 505         evtimer_add(&ev, &tv);
 506
 507         evutil_gettimeofday(&tset, NULL);
 508         event_dispatch();
 509
 510         cleanup_test();
 511 }
 512
 513 #ifndef WIN32
 514 extern struct event_base *current_base;
 515
 516 static void
 517 child_signal_cb(int fd, short event, void *arg)
 518 {
 519         struct timeval tv;
 520         int *pint = arg;
 521
 522         *pint = 1;
 523
 524         tv.tv_usec = 500000;
 525         tv.tv_sec = 0;
 526         event_loopexit(&tv);
 527 }
 528
 529 static void
 530 test_fork(void)
 531 {
 532         int status, got_sigchld = 0;
 533         struct event ev, sig_ev;
 534         pid_t pid;
 535
 536         setup_test("After fork: ");
 537
 538         write(pair[0], TEST1, strlen(TEST1)+1);
 539
 540         event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
 541         if (event_add(&ev, NULL) == -1)
 542                 exit(1);
 543
 544         signal_set(&sig_ev, SIGCHLD, child_signal_cb, &got_sigchld);
 545         signal_add(&sig_ev, NULL);
 546
 547         if ((pid = fork()) == 0) {
 548                 /* in the child */
 549                 if (event_reinit(current_base) == -1) {
 550                         fprintf(stderr, "FAILED (reinit)\n");
 551                         exit(1);
 552                 }
 553
 554                 signal_del(&sig_ev);
 555
 556                 called = 0;
 557
 558                 event_dispatch();
 559
 560                 /* we do not send an EOF; simple_read_cb requires an EOF
 561                  * to set test_ok.  we just verify that the callback was
 562                  * called. */
 563                 exit(test_ok != 0 || called != 2 ? -2 : 76);
 564         }
 565
 566         /* wait for the child to read the data */
 567         sleep(1);
 568
 569         write(pair[0], TEST1, strlen(TEST1)+1);
 570
 571         if (waitpid(pid, &status, 0) == -1) {
 572                 fprintf(stderr, "FAILED (fork)\n");
 573                 exit(1);
 574         }
 575
 576         if (WEXITSTATUS(status) != 76) {
 577                 fprintf(stderr, "FAILED (exit): %d\n", WEXITSTATUS(status));
 578                 exit(1);
 579         }
 580
 581         /* test that the current event loop still works */
 582         write(pair[0], TEST1, strlen(TEST1)+1);
 583         shutdown(pair[0], SHUT_WR);
 584
 585         event_dispatch();
 586
 587         if (!got_sigchld) {
 588                 fprintf(stdout, "FAILED (sigchld)\n");
 589                 exit(1);
 590         }
 591
 592         signal_del(&sig_ev);
 593
 594         cleanup_test();
 595 }
 596
 597 static void
 598 test_simplesignal(void)
 599 {
 600         struct event ev;
 601         struct itimerval itv;
 602
 603         setup_test("Simple signal: ");
 604         signal_set(&ev, SIGALRM, signal_cb, &ev);
 605         signal_add(&ev, NULL);
 606         /* find bugs in which operations are re-ordered */
 607         signal_del(&ev);
 608         signal_add(&ev, NULL);
 609
 610         memset(&itv, 0, sizeof(itv));
 611         itv.it_value.tv_sec = 1;
 612         if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
 613                 goto skip_simplesignal;
 614
 615         event_dispatch();
 616  skip_simplesignal:
 617         if (signal_del(&ev) == -1)
 618                 test_ok = 0;
 619
 620         cleanup_test();
 621 }
 622
 623 static void
 624 test_multiplesignal(void)
 625 {
 626         struct event ev_one, ev_two;
 627         struct itimerval itv;
 628
 629         setup_test("Multiple signal: ");
 630
 631         signal_set(&ev_one, SIGALRM, signal_cb, &ev_one);
 632         signal_add(&ev_one, NULL);
 633
 634         signal_set(&ev_two, SIGALRM, signal_cb, &ev_two);
 635         signal_add(&ev_two, NULL);
 636
 637         memset(&itv, 0, sizeof(itv));
 638         itv.it_value.tv_sec = 1;
 639         if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
 640                 goto skip_simplesignal;
 641
 642         event_dispatch();
 643
 644  skip_simplesignal:
 645         if (signal_del(&ev_one) == -1)
 646                 test_ok = 0;
 647         if (signal_del(&ev_two) == -1)
 648                 test_ok = 0;
 649
 650         cleanup_test();
 651 }
 652
 653 static void
 654 test_immediatesignal(void)
 655 {
 656         struct event ev;
 657
 658         test_ok = 0;
 659         printf("Immediate signal: ");
 660         signal_set(&ev, SIGUSR1, signal_cb, &ev);
 661         signal_add(&ev, NULL);
 662         raise(SIGUSR1);
 663         event_loop(EVLOOP_NONBLOCK);
 664         signal_del(&ev);
 665         cleanup_test();
 666 }
 667
 668 static void
 669 test_signal_dealloc(void)
 670 {
 671         /* make sure that signal_event is event_del'ed and pipe closed */
 672         struct event ev;
 673         struct event_base *base = event_init();
 674         printf("Signal dealloc: ");
 675         signal_set(&ev, SIGUSR1, signal_cb, &ev);
 676         signal_add(&ev, NULL);
 677         signal_del(&ev);
 678         event_base_free(base);
 679         /* If we got here without asserting, we're fine. */
 680         test_ok = 1;
 681         cleanup_test();
 682 }
 683
 684 static void
 685 test_signal_pipeloss(void)
 686 {
 687         /* make sure that the base1 pipe is closed correctly. */
 688         struct event_base *base1, *base2;
 689         int pipe1;
 690         test_ok = 0;
 691         printf("Signal pipeloss: ");
 692         base1 = event_init();
 693         pipe1 = base1->sig.ev_signal_pair[0];
 694         base2 = event_init();
 695         event_base_free(base2);
 696         event_base_free(base1);
 697         if (close(pipe1) != -1 || errno!=EBADF) {
 698                 /* fd must be closed, so second close gives -1, EBADF */
 699                 printf("signal pipe not closed. ");
 700                 test_ok = 0;
 701         } else {
 702                 test_ok = 1;
 703         }
 704         cleanup_test();
 705 }
 706
 707 /*
 708  * make two bases to catch signals, use both of them.  this only works
 709  * for event mechanisms that use our signal pipe trick.  kqueue handles
 710  * signals internally, and all interested kqueues get all the signals.
 711  */
 712 static void
 713 test_signal_switchbase(void)
 714 {
 715         struct event ev1, ev2;
 716         struct event_base *base1, *base2;
 717         int is_kqueue;
 718         test_ok = 0;
 719         printf("Signal switchbase: ");
 720         base1 = event_init();
 721         base2 = event_init();
 722         is_kqueue = !strcmp(event_get_method(),"kqueue");
 723         signal_set(&ev1, SIGUSR1, signal_cb, &ev1);
 724         signal_set(&ev2, SIGUSR1, signal_cb, &ev2);
 725         if (event_base_set(base1, &ev1) ||
 726             event_base_set(base2, &ev2) ||
 727             event_add(&ev1, NULL) ||
 728             event_add(&ev2, NULL)) {
 729                 fprintf(stderr, "%s: cannot set base, add\n", __func__);
 730                 exit(1);
 731         }
 732
 733         test_ok = 0;
 734         /* can handle signal before loop is called */
 735         raise(SIGUSR1);
 736         event_base_loop(base2, EVLOOP_NONBLOCK);
 737         if (is_kqueue) {
 738                 if (!test_ok)
 739                         goto done;
 740                 test_ok = 0;
 741         }
 742         event_base_loop(base1, EVLOOP_NONBLOCK);
 743         if (test_ok && !is_kqueue) {
 744                 test_ok = 0;
 745
 746                 /* set base1 to handle signals */
 747                 event_base_loop(base1, EVLOOP_NONBLOCK);
 748                 raise(SIGUSR1);
 749                 event_base_loop(base1, EVLOOP_NONBLOCK);
 750                 event_base_loop(base2, EVLOOP_NONBLOCK);
 751         }
 752  done:
 753         event_base_free(base1);
 754         event_base_free(base2);
 755         cleanup_test();
 756 }
 757
 758 /*
 759  * assert that a signal event removed from the event queue really is
 760  * removed - with no possibility of it's parent handler being fired.
 761  */
 762 static void
 763 test_signal_assert(void)
 764 {
 765         struct event ev;
 766         struct event_base *base = event_init();
 767         test_ok = 0;
 768         printf("Signal handler assert: ");
 769         /* use SIGCONT so we don't kill ourselves when we signal to nowhere */
 770         signal_set(&ev, SIGCONT, signal_cb, &ev);
 771         signal_add(&ev, NULL);
 772         /*
 773          * if signal_del() fails to reset the handler, it's current handler
 774          * will still point to evsignal_handler().
 775          */
 776         signal_del(&ev);
 777
 778         raise(SIGCONT);
 779         /* only way to verify we were in evsignal_handler() */
 780         if (base->sig.evsignal_caught)
 781                 test_ok = 0;
 782         else
 783                 test_ok = 1;
 784
 785         event_base_free(base);
 786         cleanup_test();
 787         return;
 788 }
 789
 790 /*
 791  * assert that we restore our previous signal handler properly.
 792  */
 793 static void
 794 test_signal_restore(void)
 795 {
 796         struct event ev;
 797         struct event_base *base = event_init();
 798 #ifdef HAVE_SIGACTION
 799         struct sigaction sa;
 800 #endif
 801
 802         test_ok = 0;
 803         printf("Signal handler restore: ");
 804 #ifdef HAVE_SIGACTION
 805         sa.sa_handler = signal_cb_sa;
 806         sa.sa_flags = 0x0;
 807         sigemptyset(&sa.sa_mask);
 808         if (sigaction(SIGUSR1, &sa, NULL) == -1)
 809                 goto out;
 810 #else
 811         if (signal(SIGUSR1, signal_cb_sa) == SIG_ERR)
 812                 goto out;
 813 #endif
 814         signal_set(&ev, SIGUSR1, signal_cb, &ev);
 815         signal_add(&ev, NULL);
 816         signal_del(&ev);
 817
 818         raise(SIGUSR1);
 819         /* 1 == signal_cb, 2 == signal_cb_sa, we want our previous handler */
 820         if (test_ok != 2)
 821                 test_ok = 0;
 822 out:
 823         event_base_free(base);
 824         cleanup_test();
 825         return;
 826 }
 827
 828 static void
 829 signal_cb_swp(int sig, short event, void *arg)
 830 {
 831         called++;
 832         if (called < 5)
 833                 raise(sig);
 834         else
 835                 event_loopexit(NULL);
 836 }
 837 static void
 838 timeout_cb_swp(int fd, short event, void *arg)
 839 {
 840         if (called == -1) {
 841                 struct timeval tv = {5, 0};
 842
 843                 called = 0;
 844                 evtimer_add((struct event *)arg, &tv);
 845                 raise(SIGUSR1);
 846                 return;
 847         }
 848         test_ok = 0;
 849         event_loopexit(NULL);
 850 }
 851
 852 static void
 853 test_signal_while_processing(void)
 854 {
 855         struct event_base *base = event_init();
 856         struct event ev, ev_timer;
 857         struct timeval tv = {0, 0};
 858
 859         setup_test("Receiving a signal while processing other signal: ");
 860
 861         called = -1;
 862         test_ok = 1;
 863         signal_set(&ev, SIGUSR1, signal_cb_swp, NULL);
 864         signal_add(&ev, NULL);
 865         evtimer_set(&ev_timer, timeout_cb_swp, &ev_timer);
 866         evtimer_add(&ev_timer, &tv);
 867         event_dispatch();
 868
 869         event_base_free(base);
 870         cleanup_test();
 871         return;
 872 }
 873 #endif
 874
 875 static void
 876 test_free_active_base(void)
 877 {
 878         struct event_base *base1;
 879         struct event ev1;
 880         setup_test("Free active base: ");
 881         base1 = event_init();
 882         event_set(&ev1, pair[1], EV_READ, simple_read_cb, &ev1);
 883         event_base_set(base1, &ev1);
 884         event_add(&ev1, NULL);
 885         /* event_del(&ev1); */
 886         event_base_free(base1);
 887         test_ok = 1;
 888         cleanup_test();
 889 }
 890
 891 static void
 892 test_event_base_new(void)
 893 {
 894         struct event_base *base;
 895         struct event ev1;
 896         setup_test("Event base new: ");
 897
 898         write(pair[0], TEST1, strlen(TEST1)+1);
 899         shutdown(pair[0], SHUT_WR);
 900
 901         base = event_base_new();
 902         event_set(&ev1, pair[1], EV_READ, simple_read_cb, &ev1);
 903         event_base_set(base, &ev1);
 904         event_add(&ev1, NULL);
 905
 906         event_base_dispatch(base);
 907
 908         event_base_free(base);
 909         test_ok = 1;
 910         cleanup_test();
 911 }
 912
 913 static void
 914 test_loopexit(void)
 915 {
 916         struct timeval tv, tv_start, tv_end;
 917         struct event ev;
 918
 919         setup_test("Loop exit: ");
 920
 921         tv.tv_usec = 0;
 922         tv.tv_sec = 60*60*24;
 923         evtimer_set(&ev, timeout_cb, NULL);
 924         evtimer_add(&ev, &tv);
 925
 926         tv.tv_usec = 0;
 927         tv.tv_sec = 1;
 928         event_loopexit(&tv);
 929
 930         evutil_gettimeofday(&tv_start, NULL);
 931         event_dispatch();
 932         evutil_gettimeofday(&tv_end, NULL);
 933         evutil_timersub(&tv_end, &tv_start, &tv_end);
 934
 935         evtimer_del(&ev);
 936
 937         if (tv.tv_sec < 2)
 938                 test_ok = 1;
 939
 940         cleanup_test();
 941 }
 942
 943 static void
 944 test_loopexit_multiple(void)
 945 {
 946         struct timeval tv;
 947         struct event_base *base;
 948
 949         setup_test("Loop Multiple exit: ");
 950
 951         base = event_base_new();
 952
 953         tv.tv_usec = 0;
 954         tv.tv_sec = 1;
 955         event_base_loopexit(base, &tv);
 956
 957         tv.tv_usec = 0;
 958         tv.tv_sec = 2;
 959         event_base_loopexit(base, &tv);
 960
 961         event_base_dispatch(base);
 962
 963         event_base_free(base);
 964
 965         test_ok = 1;
 966
 967         cleanup_test();
 968 }
 969
 970 static void
 971 break_cb(int fd, short events, void *arg)
 972 {
 973         test_ok = 1;
 974         event_loopbreak();
 975 }
 976
 977 static void
 978 fail_cb(int fd, short events, void *arg)
 979 {
 980         test_ok = 0;
 981 }
 982
 983 static void
 984 test_loopbreak(void)
 985 {
 986         struct event ev1, ev2;
 987         struct timeval tv;
 988
 989         setup_test("Loop break: ");
 990
 991         tv.tv_sec = 0;
 992         tv.tv_usec = 0;
 993         evtimer_set(&ev1, break_cb, NULL);
 994         evtimer_add(&ev1, &tv);
 995         evtimer_set(&ev2, fail_cb, NULL);
 996         evtimer_add(&ev2, &tv);
 997
 998         event_dispatch();
 999
1000         evtimer_del(&ev1);
1001         evtimer_del(&ev2);
1002
1003         cleanup_test();
1004 }
1005
1006 static void
1007 test_evbuffer(void) {
1008
1009         struct evbuffer *evb = evbuffer_new();
1010         setup_test("Testing Evbuffer: ");
1011
1012         evbuffer_add_printf(evb, "%s/%d", "hello", 1);
1013
1014         if (EVBUFFER_LENGTH(evb) == 7 &&
1015             strcmp((char*)EVBUFFER_DATA(evb), "hello/1") == 0)
1016             test_ok = 1;
1017
1018         evbuffer_free(evb);
1019
1020         cleanup_test();
1021 }
1022
1023 static void
1024 test_evbuffer_find(void)
1025 {
1026         u_char* p;
1027         const char* test1 = "1234567890\r\n";
1028         const char* test2 = "1234567890\r";
1029 #define EVBUFFER_INITIAL_LENGTH 256
1030         char test3[EVBUFFER_INITIAL_LENGTH];
1031         unsigned int i;
1032         struct evbuffer * buf = evbuffer_new();
1033
1034         /* make sure evbuffer_find doesn't match past the end of the buffer */
1035         fprintf(stdout, "Testing evbuffer_find 1: ");
1036         evbuffer_add(buf, (u_char*)test1, strlen(test1));
1037         evbuffer_drain(buf, strlen(test1));
1038         evbuffer_add(buf, (u_char*)test2, strlen(test2));
1039         p = evbuffer_find(buf, (u_char*)"\r\n", 2);
1040         if (p == NULL) {
1041                 fprintf(stdout, "OK\n");
1042         } else {
1043                 fprintf(stdout, "FAILED\n");
1044                 exit(1);
1045         }
1046
1047         /*
1048          * drain the buffer and do another find; in r309 this would
1049          * read past the allocated buffer causing a valgrind error.
1050          */
1051         fprintf(stdout, "Testing evbuffer_find 2: ");
1052         evbuffer_drain(buf, strlen(test2));
1053         for (i = 0; i < EVBUFFER_INITIAL_LENGTH; ++i)
1054                 test3[i] = 'a';
1055         test3[EVBUFFER_INITIAL_LENGTH - 1] = 'x';
1056         evbuffer_add(buf, (u_char *)test3, EVBUFFER_INITIAL_LENGTH);
1057         p = evbuffer_find(buf, (u_char *)"xy", 2);
1058         if (p == NULL) {
1059                 printf("OK\n");
1060         } else {
1061                 fprintf(stdout, "FAILED\n");
1062                 exit(1);
1063         }
1064
1065         /* simple test for match at end of allocated buffer */
1066         fprintf(stdout, "Testing evbuffer_find 3: ");
1067         p = evbuffer_find(buf, (u_char *)"ax", 2);
1068         if (p != NULL && strncmp((char*)p, "ax", 2) == 0) {
1069                 printf("OK\n");
1070         } else {
1071                 fprintf(stdout, "FAILED\n");
1072                 exit(1);
1073         }
1074
1075         evbuffer_free(buf);
1076 }
1077
1078 /*
1079  * simple bufferevent test
1080  */
1081
1082 static void
1083 readcb(struct bufferevent *bev, void *arg)
1084 {
1085         if (EVBUFFER_LENGTH(bev->input) == 8333) {
1086                 bufferevent_disable(bev, EV_READ);
1087                 test_ok++;
1088         }
1089 }
1090
1091 static void
1092 writecb(struct bufferevent *bev, void *arg)
1093 {
1094         if (EVBUFFER_LENGTH(bev->output) == 0)
1095                 test_ok++;
1096 }
1097
1098 static void
1099 errorcb(struct bufferevent *bev, short what, void *arg)
1100 {
1101         test_ok = -2;
1102 }
1103
1104 static void
1105 test_bufferevent(void)
1106 {
1107         struct bufferevent *bev1, *bev2;
1108         char buffer[8333];
1109         int i;
1110
1111         setup_test("Bufferevent: ");
1112
1113         bev1 = bufferevent_new(pair[0], readcb, writecb, errorcb, NULL);
1114         bev2 = bufferevent_new(pair[1], readcb, writecb, errorcb, NULL);
1115
1116         bufferevent_disable(bev1, EV_READ);
1117         bufferevent_enable(bev2, EV_READ);
1118
1119         for (i = 0; i < sizeof(buffer); i++)
1120                 buffer[i] = i;
1121
1122         bufferevent_write(bev1, buffer, sizeof(buffer));
1123
1124         event_dispatch();
1125
1126         bufferevent_free(bev1);
1127         bufferevent_free(bev2);
1128
1129         if (test_ok != 2)
1130                 test_ok = 0;
1131
1132         cleanup_test();
1133 }
1134
1135 /*
1136  * test watermarks and bufferevent
1137  */
1138
1139 static void
1140 wm_readcb(struct bufferevent *bev, void *arg)
1141 {
1142         int len = EVBUFFER_LENGTH(bev->input);
1143         static int nread;
1144
1145         assert(len >= 10 && len <= 20);
1146
1147         evbuffer_drain(bev->input, len);
1148
1149         nread += len;
1150         if (nread == 65000) {
1151                 bufferevent_disable(bev, EV_READ);
1152                 test_ok++;
1153         }
1154 }
1155
1156 static void
1157 wm_writecb(struct bufferevent *bev, void *arg)
1158 {
1159         if (EVBUFFER_LENGTH(bev->output) == 0)
1160                 test_ok++;
1161 }
1162
1163 static void
1164 wm_errorcb(struct bufferevent *bev, short what, void *arg)
1165 {
1166         test_ok = -2;
1167 }
1168
1169 static void
1170 test_bufferevent_watermarks(void)
1171 {
1172         struct bufferevent *bev1, *bev2;
1173         char buffer[65000];
1174         int i;
1175
1176         setup_test("Bufferevent Watermarks: ");
1177
1178         bev1 = bufferevent_new(pair[0], NULL, wm_writecb, wm_errorcb, NULL);
1179         bev2 = bufferevent_new(pair[1], wm_readcb, NULL, wm_errorcb, NULL);
1180
1181         bufferevent_disable(bev1, EV_READ);
1182         bufferevent_enable(bev2, EV_READ);
1183
1184         for (i = 0; i < sizeof(buffer); i++)
1185                 buffer[i] = i;
1186
1187         bufferevent_write(bev1, buffer, sizeof(buffer));
1188
1189         /* limit the reading on the receiving bufferevent */
1190         bufferevent_setwatermark(bev2, EV_READ, 10, 20);
1191
1192         event_dispatch();
1193
1194         bufferevent_free(bev1);
1195         bufferevent_free(bev2);
1196
1197         if (test_ok != 2)
1198                 test_ok = 0;
1199
1200         cleanup_test();
1201 }
1202
1203 struct test_pri_event {
1204         struct event ev;
1205         int count;
1206 };
1207
1208 static void
1209 test_priorities_cb(int fd, short what, void *arg)
1210 {
1211         struct test_pri_event *pri = arg;
1212         struct timeval tv;
1213
1214         if (pri->count == 3) {
1215                 event_loopexit(NULL);
1216                 return;
1217         }
1218
1219         pri->count++;
1220
1221         evutil_timerclear(&tv);
1222         event_add(&pri->ev, &tv);
1223 }
1224
1225 static void
1226 test_priorities(int npriorities)
1227 {
1228         char buf[32];
1229         struct test_pri_event one, two;
1230         struct timeval tv;
1231
1232         evutil_snprintf(buf, sizeof(buf), "Testing Priorities %d: ", npriorities);
1233         setup_test(buf);
1234
1235         event_base_priority_init(global_base, npriorities);
1236
1237         memset(&one, 0, sizeof(one));
1238         memset(&two, 0, sizeof(two));
1239
1240         timeout_set(&one.ev, test_priorities_cb, &one);
1241         if (event_priority_set(&one.ev, 0) == -1) {
1242                 fprintf(stderr, "%s: failed to set priority", __func__);
1243                 exit(1);
1244         }
1245
1246         timeout_set(&two.ev, test_priorities_cb, &two);
1247         if (event_priority_set(&two.ev, npriorities - 1) == -1) {
1248                 fprintf(stderr, "%s: failed to set priority", __func__);
1249                 exit(1);
1250         }
1251
1252         evutil_timerclear(&tv);
1253
1254         if (event_add(&one.ev, &tv) == -1)
1255                 exit(1);
1256         if (event_add(&two.ev, &tv) == -1)
1257                 exit(1);
1258
1259         event_dispatch();
1260
1261         event_del(&one.ev);
1262         event_del(&two.ev);
1263
1264         if (npriorities == 1) {
1265                 if (one.count == 3 && two.count == 3)
1266                         test_ok = 1;
1267         } else if (npriorities == 2) {
1268                 /* Two is called once because event_loopexit is priority 1 */
1269                 if (one.count == 3 && two.count == 1)
1270                         test_ok = 1;
1271         } else {
1272                 if (one.count == 3 && two.count == 0)
1273                         test_ok = 1;
1274         }
1275
1276         cleanup_test();
1277 }
1278
1279 static void
1280 test_multiple_cb(int fd, short event, void *arg)
1281 {
1282         if (event & EV_READ)
1283                 test_ok |= 1;
1284         else if (event & EV_WRITE)
1285                 test_ok |= 2;
1286 }
1287
1288 static void
1289 test_multiple_events_for_same_fd(void)
1290 {
1291    struct event e1, e2;
1292
1293    setup_test("Multiple events for same fd: ");
1294
1295    event_set(&e1, pair[0], EV_READ, test_multiple_cb, NULL);
1296    event_add(&e1, NULL);
1297    event_set(&e2, pair[0], EV_WRITE, test_multiple_cb, NULL);
1298    event_add(&e2, NULL);
1299    event_loop(EVLOOP_ONCE);
1300    event_del(&e2);
1301    write(pair[1], TEST1, strlen(TEST1)+1);
1302    event_loop(EVLOOP_ONCE);
1303    event_del(&e1);
1304
1305    if (test_ok != 3)
1306            test_ok = 0;
1307
1308    cleanup_test();
1309 }
1310
1311 int evtag_decode_int(uint32_t *pnumber, struct evbuffer *evbuf);
1312 int evtag_encode_tag(struct evbuffer *evbuf, uint32_t number);
1313 int evtag_decode_tag(uint32_t *pnumber, struct evbuffer *evbuf);
1314
1315 static void
1316 read_once_cb(int fd, short event, void *arg)
1317 {
1318         char buf[256];
1319         int len;
1320
1321         len = read(fd, buf, sizeof(buf));
1322
1323         if (called) {
1324                 test_ok = 0;
1325         } else if (len) {
1326                 /* Assumes global pair[0] can be used for writing */
1327                 write(pair[0], TEST1, strlen(TEST1)+1);
1328                 test_ok = 1;
1329         }
1330
1331         called++;
1332 }
1333
1334 static void
1335 test_want_only_once(void)
1336 {
1337         struct event ev;
1338         struct timeval tv;
1339
1340         /* Very simple read test */
1341         setup_test("Want read only once: ");
1342
1343         write(pair[0], TEST1, strlen(TEST1)+1);
1344
1345         /* Setup the loop termination */
1346         evutil_timerclear(&tv);
1347         tv.tv_sec = 1;
1348         event_loopexit(&tv);
1349
1350         event_set(&ev, pair[1], EV_READ, read_once_cb, &ev);
1351         if (event_add(&ev, NULL) == -1)
1352                 exit(1);
1353         event_dispatch();
1354
1355         cleanup_test();
1356 }
1357
1358 #define TEST_MAX_INT    6
1359
1360 static void
1361 evtag_int_test(void)
1362 {
1363         struct evbuffer *tmp = evbuffer_new();
1364         uint32_t integers[TEST_MAX_INT] = {
1365                 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1366         };
1367         uint32_t integer;
1368         int i;
1369
1370         for (i = 0; i < TEST_MAX_INT; i++) {
1371                 int oldlen, newlen;
1372                 oldlen = EVBUFFER_LENGTH(tmp);
1373                 encode_int(tmp, integers[i]);
1374                 newlen = EVBUFFER_LENGTH(tmp);
1375                 fprintf(stdout, "\t\tencoded 0x%08x with %d bytes\n",
1376                     integers[i], newlen - oldlen);
1377         }
1378
1379         for (i = 0; i < TEST_MAX_INT; i++) {
1380                 if (evtag_decode_int(&integer, tmp) == -1) {
1381                         fprintf(stderr, "decode %d failed", i);
1382                         exit(1);
1383                 }
1384                 if (integer != integers[i]) {
1385                         fprintf(stderr, "got %x, wanted %x",
1386                             integer, integers[i]);
1387                         exit(1);
1388                 }
1389         }
1390
1391         if (EVBUFFER_LENGTH(tmp) != 0) {
1392                 fprintf(stderr, "trailing data");
1393                 exit(1);
1394         }
1395         evbuffer_free(tmp);
1396
1397         fprintf(stdout, "\t%s: OK\n", __func__);
1398 }
1399
1400 static void
1401 evtag_fuzz(void)
1402 {
1403         u_char buffer[4096];
1404         struct evbuffer *tmp = evbuffer_new();
1405         struct timeval tv;
1406         int i, j;
1407
1408         int not_failed = 0;
1409         for (j = 0; j < 100; j++) {
1410                 for (i = 0; i < sizeof(buffer); i++)
1411                         buffer[i] = rand();
1412                 evbuffer_drain(tmp, -1);
1413                 evbuffer_add(tmp, buffer, sizeof(buffer));
1414
1415                 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1)
1416                         not_failed++;
1417         }
1418
1419         /* The majority of decodes should fail */
1420         if (not_failed >= 10) {
1421                 fprintf(stderr, "evtag_unmarshal should have failed");
1422                 exit(1);
1423         }
1424
1425         /* Now insert some corruption into the tag length field */
1426         evbuffer_drain(tmp, -1);
1427         evutil_timerclear(&tv);
1428         tv.tv_sec = 1;
1429         evtag_marshal_timeval(tmp, 0, &tv);
1430         evbuffer_add(tmp, buffer, sizeof(buffer));
1431
1432         EVBUFFER_DATA(tmp)[1] = 0xff;
1433         if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1) {
1434                 fprintf(stderr, "evtag_unmarshal_timeval should have failed");
1435                 exit(1);
1436         }
1437
1438         evbuffer_free(tmp);
1439
1440         fprintf(stdout, "\t%s: OK\n", __func__);
1441 }
1442
1443 static void
1444 evtag_tag_encoding(void)
1445 {
1446         struct evbuffer *tmp = evbuffer_new();
1447         uint32_t integers[TEST_MAX_INT] = {
1448                 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1449         };
1450         uint32_t integer;
1451         int i;
1452
1453         for (i = 0; i < TEST_MAX_INT; i++) {
1454                 int oldlen, newlen;
1455                 oldlen = EVBUFFER_LENGTH(tmp);
1456                 evtag_encode_tag(tmp, integers[i]);
1457                 newlen = EVBUFFER_LENGTH(tmp);
1458                 fprintf(stdout, "\t\tencoded 0x%08x with %d bytes\n",
1459                     integers[i], newlen - oldlen);
1460         }
1461
1462         for (i = 0; i < TEST_MAX_INT; i++) {
1463                 if (evtag_decode_tag(&integer, tmp) == -1) {
1464                         fprintf(stderr, "decode %d failed", i);
1465                         exit(1);
1466                 }
1467                 if (integer != integers[i]) {
1468                         fprintf(stderr, "got %x, wanted %x",
1469                             integer, integers[i]);
1470                         exit(1);
1471                 }
1472         }
1473
1474         if (EVBUFFER_LENGTH(tmp) != 0) {
1475                 fprintf(stderr, "trailing data");
1476                 exit(1);
1477         }
1478         evbuffer_free(tmp);
1479
1480         fprintf(stdout, "\t%s: OK\n", __func__);
1481 }
1482
1483 static void
1484 evtag_test(void)
1485 {
1486         fprintf(stdout, "Testing Tagging:\n");
1487
1488         evtag_init();
1489         evtag_int_test();
1490         evtag_fuzz();
1491
1492         evtag_tag_encoding();
1493
1494         fprintf(stdout, "OK\n");
1495 }
1496
1497 #ifndef WIN32
1498 static void
1499 rpc_test(void)
1500 {
1501         struct msg *msg, *msg2;
1502         struct kill *attack;
1503         struct run *run;
1504         struct evbuffer *tmp = evbuffer_new();
1505         struct timeval tv_start, tv_end;
1506         uint32_t tag;
1507         int i;
1508
1509         fprintf(stdout, "Testing RPC: ");
1510
1511         msg = msg_new();
1512         EVTAG_ASSIGN(msg, from_name, "niels");
1513         EVTAG_ASSIGN(msg, to_name, "phoenix");
1514
1515         if (EVTAG_GET(msg, attack, &attack) == -1) {
1516                 fprintf(stderr, "Failed to set kill message.\n");
1517                 exit(1);
1518         }
1519
1520         EVTAG_ASSIGN(attack, weapon, "feather");
1521         EVTAG_ASSIGN(attack, action, "tickle");
1522
1523         evutil_gettimeofday(&tv_start, NULL);
1524         for (i = 0; i < 1000; ++i) {
1525                 run = EVTAG_ADD(msg, run);
1526                 if (run == NULL) {
1527                         fprintf(stderr, "Failed to add run message.\n");
1528                         exit(1);
1529                 }
1530                 EVTAG_ASSIGN(run, how, "very fast but with some data in it");
1531                 EVTAG_ASSIGN(run, fixed_bytes,
1532                     (unsigned char*)"012345678901234567890123");
1533         }
1534
1535         if (msg_complete(msg) == -1) {
1536                 fprintf(stderr, "Failed to make complete message.\n");
1537                 exit(1);
1538         }
1539
1540         evtag_marshal_msg(tmp, 0xdeaf, msg);
1541
1542         if (evtag_peek(tmp, &tag) == -1) {
1543                 fprintf(stderr, "Failed to peak tag.\n");
1544                 exit (1);
1545         }
1546
1547         if (tag != 0xdeaf) {
1548                 fprintf(stderr, "Got incorrect tag: %0x.\n", tag);
1549                 exit (1);
1550         }
1551
1552         msg2 = msg_new();
1553         if (evtag_unmarshal_msg(tmp, 0xdeaf, msg2) == -1) {
1554                 fprintf(stderr, "Failed to unmarshal message.\n");
1555                 exit(1);
1556         }
1557
1558         evutil_gettimeofday(&tv_end, NULL);
1559         evutil_timersub(&tv_end, &tv_start, &tv_end);
1560         fprintf(stderr, "(%.1f us/add) ",
1561             (float)tv_end.tv_sec/(float)i * 1000000.0 +
1562             tv_end.tv_usec / (float)i);
1563
1564         if (!EVTAG_HAS(msg2, from_name) ||
1565             !EVTAG_HAS(msg2, to_name) ||
1566             !EVTAG_HAS(msg2, attack)) {
1567                 fprintf(stderr, "Missing data structures.\n");
1568                 exit(1);
1569         }
1570
1571         if (EVTAG_LEN(msg2, run) != i) {
1572                 fprintf(stderr, "Wrong number of run messages.\n");
1573                 exit(1);
1574         }
1575
1576         msg_free(msg);
1577         msg_free(msg2);
1578
1579         evbuffer_free(tmp);
1580
1581         fprintf(stdout, "OK\n");
1582 }
1583 #endif
1584
1585 static void
1586 test_evutil_strtoll(void)
1587 {
1588         const char *s;
1589         char *endptr;
1590         setup_test("evutil_stroll: ");
1591         test_ok = 0;
1592
1593         if (evutil_strtoll("5000000000", NULL, 10) != ((ev_int64_t)5000000)*1000)
1594                 goto err;
1595         if (evutil_strtoll("-5000000000", NULL, 10) != ((ev_int64_t)5000000)*-1000)
1596                 goto err;
1597         s = " 99999stuff";
1598         if (evutil_strtoll(s, &endptr, 10) != (ev_int64_t)99999)
1599                 goto err;
1600         if (endptr != s+6)
1601                 goto err;
1602         if (evutil_strtoll("foo", NULL, 10) != 0)
1603                 goto err;
1604
1605         test_ok = 1;
1606  err:
1607         cleanup_test();
1608 }
1609
1610
1611 int
1612 main (int argc, char **argv)
1613 {
1614 #ifdef WIN32
1615         WORD wVersionRequested;
1616         WSADATA wsaData;
1617         int     err;
1618
1619         wVersionRequested = MAKEWORD( 2, 2 );
1620
1621         err = WSAStartup( wVersionRequested, &wsaData );
1622 #endif
1623
1624 #ifndef WIN32
1625         if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
1626                 return (1);
1627 #endif
1628         setvbuf(stdout, NULL, _IONBF, 0);
1629
1630         /* Initalize the event library */
1631         global_base = event_init();
1632
1633         test_registerfds();
1634
1635         test_evutil_strtoll();
1636
1637         /* use the global event base and need to be called first */
1638         test_priorities(1);
1639         test_priorities(2);
1640         test_priorities(3);
1641
1642         test_evbuffer();
1643         test_evbuffer_find();
1644
1645         test_bufferevent();
1646         test_bufferevent_watermarks();
1647
1648         test_free_active_base();
1649
1650         test_event_base_new();
1651
1652         http_suite();
1653
1654 #ifndef WIN32
1655         rpc_suite();
1656 #endif
1657
1658         dns_suite();
1659
1660 #ifndef WIN32
1661         test_fork();
1662 #endif
1663
1664         test_simpleread();
1665
1666         test_simplewrite();
1667
1668         test_multiple();
1669
1670         test_persistent();
1671
1672         test_combined();
1673
1674         test_simpletimeout();
1675 #ifndef WIN32
1676         test_simplesignal();
1677         test_multiplesignal();
1678         test_immediatesignal();
1679 #endif
1680         test_loopexit();
1681         test_loopbreak();
1682
1683         test_loopexit_multiple();
1684
1685         test_multiple_events_for_same_fd();
1686
1687         test_want_only_once();
1688
1689         evtag_test();
1690
1691 #ifndef WIN32
1692         rpc_test();
1693
1694         test_signal_dealloc();
1695         test_signal_pipeloss();
1696         test_signal_switchbase();
1697         test_signal_restore();
1698         test_signal_assert();
1699         test_signal_while_processing();
1700 #endif
1701
1702         return (0);
1703 }
1704