third_party/libevent/test/regress.c

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