contrib/libevent/test/regress.c

   1 /*
   2  * Copyright (c) 2003-2007 Niels Provos <provos@citi.umich.edu>
   3  * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
   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 #include "util-internal.h"
  28
  29 #ifdef _WIN32
  30 #include <winsock2.h>
  31 #include <windows.h>
  32 #endif
  33
  34 #ifdef EVENT__HAVE_PTHREADS
  35 #include <pthread.h>
  36 #endif
  37
  38 #include "event2/event-config.h"
  39
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #ifdef EVENT__HAVE_SYS_TIME_H
  43 #include <sys/time.h>
  44 #endif
  45 #include <sys/queue.h>
  46 #ifndef _WIN32
  47 #include <sys/socket.h>
  48 #include <sys/wait.h>
  49 #include <signal.h>
  50 #include <unistd.h>
  51 #include <netdb.h>
  52 #endif
  53 #include <fcntl.h>
  54 #include <signal.h>
  55 #include <stdlib.h>
  56 #include <stdio.h>
  57 #include <string.h>
  58 #include <errno.h>
  59 #include <assert.h>
  60 #include <ctype.h>
  61
  62 #include "event2/event.h"
  63 #include "event2/event_struct.h"
  64 #include "event2/event_compat.h"
  65 #include "event2/tag.h"
  66 #include "event2/buffer.h"
  67 #include "event2/buffer_compat.h"
  68 #include "event2/util.h"
  69 #include "event-internal.h"
  70 #include "evthread-internal.h"
  71 #include "log-internal.h"
  72 #include "time-internal.h"
  73
  74 #include "regress.h"
  75
  76 #ifndef _WIN32
  77 #include "regress.gen.h"
  78 #endif
  79
  80 evutil_socket_t pair[2];
  81 int test_ok;
  82 int called;
  83 struct event_base *global_base;
  84
  85 static char wbuf[4096];
  86 static char rbuf[4096];
  87 static int woff;
  88 static int roff;
  89 static int usepersist;
  90 static struct timeval tset;
  91 static struct timeval tcalled;
  92
  93
  94 #define TEST1   "this is a test"
  95
  96 #ifdef _WIN32
  97 #define write(fd,buf,len) send((fd),(buf),(int)(len),0)
  98 #define read(fd,buf,len) recv((fd),(buf),(int)(len),0)
  99 #endif
 100
 101 struct basic_cb_args
 102 {
 103         struct event_base *eb;
 104         struct event *ev;
 105         unsigned int callcount;
 106 };
 107
 108 static void
 109 simple_read_cb(evutil_socket_t fd, short event, void *arg)
 110 {
 111         char buf[256];
 112         int len;
 113
 114         len = read(fd, buf, sizeof(buf));
 115
 116         if (len) {
 117                 if (!called) {
 118                         if (event_add(arg, NULL) == -1)
 119                                 exit(1);
 120                 }
 121         } else if (called == 1)
 122                 test_ok = 1;
 123
 124         called++;
 125 }
 126
 127 static void
 128 basic_read_cb(evutil_socket_t fd, short event, void *data)
 129 {
 130         char buf[256];
 131         int len;
 132         struct basic_cb_args *arg = data;
 133
 134         len = read(fd, buf, sizeof(buf));
 135
 136         if (len < 0) {
 137                 tt_fail_perror("read (callback)");
 138         } else {
 139                 switch (arg->callcount++) {
 140                 case 0:  /* first call: expect to read data; cycle */
 141                         if (len > 0)
 142                                 return;
 143
 144                         tt_fail_msg("EOF before data read");
 145                         break;
 146
 147                 case 1:  /* second call: expect EOF; stop */
 148                         if (len > 0)
 149                                 tt_fail_msg("not all data read on first cycle");
 150                         break;
 151
 152                 default:  /* third call: should not happen */
 153                         tt_fail_msg("too many cycles");
 154                 }
 155         }
 156
 157         event_del(arg->ev);
 158         event_base_loopexit(arg->eb, NULL);
 159 }
 160
 161 static void
 162 dummy_read_cb(evutil_socket_t fd, short event, void *arg)
 163 {
 164 }
 165
 166 static void
 167 simple_write_cb(evutil_socket_t fd, short event, void *arg)
 168 {
 169         int len;
 170
 171         len = write(fd, TEST1, strlen(TEST1) + 1);
 172         if (len == -1)
 173                 test_ok = 0;
 174         else
 175                 test_ok = 1;
 176 }
 177
 178 static void
 179 multiple_write_cb(evutil_socket_t fd, short event, void *arg)
 180 {
 181         struct event *ev = arg;
 182         int len;
 183
 184         len = 128;
 185         if (woff + len >= (int)sizeof(wbuf))
 186                 len = sizeof(wbuf) - woff;
 187
 188         len = write(fd, wbuf + woff, len);
 189         if (len == -1) {
 190                 fprintf(stderr, "%s: write\n", __func__);
 191                 if (usepersist)
 192                         event_del(ev);
 193                 return;
 194         }
 195
 196         woff += len;
 197
 198         if (woff >= (int)sizeof(wbuf)) {
 199                 shutdown(fd, EVUTIL_SHUT_WR);
 200                 if (usepersist)
 201                         event_del(ev);
 202                 return;
 203         }
 204
 205         if (!usepersist) {
 206                 if (event_add(ev, NULL) == -1)
 207                         exit(1);
 208         }
 209 }
 210
 211 static void
 212 multiple_read_cb(evutil_socket_t fd, short event, void *arg)
 213 {
 214         struct event *ev = arg;
 215         int len;
 216
 217         len = read(fd, rbuf + roff, sizeof(rbuf) - roff);
 218         if (len == -1)
 219                 fprintf(stderr, "%s: read\n", __func__);
 220         if (len <= 0) {
 221                 if (usepersist)
 222                         event_del(ev);
 223                 return;
 224         }
 225
 226         roff += len;
 227         if (!usepersist) {
 228                 if (event_add(ev, NULL) == -1)
 229                         exit(1);
 230         }
 231 }
 232
 233 static void
 234 timeout_cb(evutil_socket_t fd, short event, void *arg)
 235 {
 236         evutil_gettimeofday(&tcalled, NULL);
 237 }
 238
 239 struct both {
 240         struct event ev;
 241         int nread;
 242 };
 243
 244 static void
 245 combined_read_cb(evutil_socket_t fd, short event, void *arg)
 246 {
 247         struct both *both = arg;
 248         char buf[128];
 249         int len;
 250
 251         len = read(fd, buf, sizeof(buf));
 252         if (len == -1)
 253                 fprintf(stderr, "%s: read\n", __func__);
 254         if (len <= 0)
 255                 return;
 256
 257         both->nread += len;
 258         if (event_add(&both->ev, NULL) == -1)
 259                 exit(1);
 260 }
 261
 262 static void
 263 combined_write_cb(evutil_socket_t fd, short event, void *arg)
 264 {
 265         struct both *both = arg;
 266         char buf[128];
 267         int len;
 268
 269         len = sizeof(buf);
 270         if (len > both->nread)
 271                 len = both->nread;
 272
 273         memset(buf, 'q', len);
 274
 275         len = write(fd, buf, len);
 276         if (len == -1)
 277                 fprintf(stderr, "%s: write\n", __func__);
 278         if (len <= 0) {
 279                 shutdown(fd, EVUTIL_SHUT_WR);
 280                 return;
 281         }
 282
 283         both->nread -= len;
 284         if (event_add(&both->ev, NULL) == -1)
 285                 exit(1);
 286 }
 287
 288 /* These macros used to replicate the work of the legacy test wrapper code */
 289 #define setup_test(x) do {                                              \
 290         if (!in_legacy_test_wrapper) {                                  \
 291                 TT_FAIL(("Legacy test %s not wrapped properly", x));    \
 292                 return;                                                 \
 293         }                                                               \
 294         } while (0)
 295 #define cleanup_test() setup_test("cleanup")
 296
 297 static void
 298 test_simpleread(void)
 299 {
 300         struct event ev;
 301
 302         /* Very simple read test */
 303         setup_test("Simple read: ");
 304
 305         if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
 306                 tt_fail_perror("write");
 307         }
 308
 309         shutdown(pair[0], EVUTIL_SHUT_WR);
 310
 311         event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
 312         if (event_add(&ev, NULL) == -1)
 313                 exit(1);
 314         event_dispatch();
 315
 316         cleanup_test();
 317 }
 318
 319 static void
 320 test_simplewrite(void)
 321 {
 322         struct event ev;
 323
 324         /* Very simple write test */
 325         setup_test("Simple write: ");
 326
 327         event_set(&ev, pair[0], EV_WRITE, simple_write_cb, &ev);
 328         if (event_add(&ev, NULL) == -1)
 329                 exit(1);
 330         event_dispatch();
 331
 332         cleanup_test();
 333 }
 334
 335 static void
 336 simpleread_multiple_cb(evutil_socket_t fd, short event, void *arg)
 337 {
 338         if (++called == 2)
 339                 test_ok = 1;
 340 }
 341
 342 static void
 343 test_simpleread_multiple(void)
 344 {
 345         struct event one, two;
 346
 347         /* Very simple read test */
 348         setup_test("Simple read to multiple evens: ");
 349
 350         if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
 351                 tt_fail_perror("write");
 352         }
 353
 354         shutdown(pair[0], EVUTIL_SHUT_WR);
 355
 356         event_set(&one, pair[1], EV_READ, simpleread_multiple_cb, NULL);
 357         if (event_add(&one, NULL) == -1)
 358                 exit(1);
 359         event_set(&two, pair[1], EV_READ, simpleread_multiple_cb, NULL);
 360         if (event_add(&two, NULL) == -1)
 361                 exit(1);
 362         event_dispatch();
 363
 364         cleanup_test();
 365 }
 366
 367 static int have_closed = 0;
 368 static int premature_event = 0;
 369 static void
 370 simpleclose_close_fd_cb(evutil_socket_t s, short what, void *ptr)
 371 {
 372         evutil_socket_t **fds = ptr;
 373         TT_BLATHER(("Closing"));
 374         evutil_closesocket(*fds[0]);
 375         evutil_closesocket(*fds[1]);
 376         *fds[0] = -1;
 377         *fds[1] = -1;
 378         have_closed = 1;
 379 }
 380
 381 static void
 382 record_event_cb(evutil_socket_t s, short what, void *ptr)
 383 {
 384         short *whatp = ptr;
 385         if (!have_closed)
 386                 premature_event = 1;
 387         *whatp = what;
 388         TT_BLATHER(("Recorded %d on socket %d", (int)what, (int)s));
 389 }
 390
 391 static void
 392 test_simpleclose(void *ptr)
 393 {
 394         /* Test that a close of FD is detected as a read and as a write. */
 395         struct event_base *base = event_base_new();
 396         evutil_socket_t pair1[2]={-1,-1}, pair2[2] = {-1, -1};
 397         evutil_socket_t *to_close[2];
 398         struct event *rev=NULL, *wev=NULL, *closeev=NULL;
 399         struct timeval tv;
 400         short got_read_on_close = 0, got_write_on_close = 0;
 401         char buf[1024];
 402         memset(buf, 99, sizeof(buf));
 403 #ifdef _WIN32
 404 #define LOCAL_SOCKETPAIR_AF AF_INET
 405 #else
 406 #define LOCAL_SOCKETPAIR_AF AF_UNIX
 407 #endif
 408         if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0, pair1)<0)
 409                 TT_DIE(("socketpair: %s", strerror(errno)));
 410         if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0, pair2)<0)
 411                 TT_DIE(("socketpair: %s", strerror(errno)));
 412         if (evutil_make_socket_nonblocking(pair1[1]) < 0)
 413                 TT_DIE(("make_socket_nonblocking"));
 414         if (evutil_make_socket_nonblocking(pair2[1]) < 0)
 415                 TT_DIE(("make_socket_nonblocking"));
 416
 417         /** Stuff pair2[1] full of data, until write fails */
 418         while (1) {
 419                 int r = write(pair2[1], buf, sizeof(buf));
 420                 if (r<0) {
 421                         int err = evutil_socket_geterror(pair2[1]);
 422                         if (! EVUTIL_ERR_RW_RETRIABLE(err))
 423                                 TT_DIE(("write failed strangely: %s",
 424                                         evutil_socket_error_to_string(err)));
 425                         break;
 426                 }
 427         }
 428         to_close[0] = &pair1[0];
 429         to_close[1] = &pair2[0];
 430
 431         closeev = event_new(base, -1, EV_TIMEOUT, simpleclose_close_fd_cb,
 432             to_close);
 433         rev = event_new(base, pair1[1], EV_READ, record_event_cb,
 434             &got_read_on_close);
 435         TT_BLATHER(("Waiting for read on %d", (int)pair1[1]));
 436         wev = event_new(base, pair2[1], EV_WRITE, record_event_cb,
 437             &got_write_on_close);
 438         TT_BLATHER(("Waiting for write on %d", (int)pair2[1]));
 439         tv.tv_sec = 0;
 440         tv.tv_usec = 100*1000; /* Close pair1[0] after a little while, and make
 441                                * sure we get a read event. */
 442         event_add(closeev, &tv);
 443         event_add(rev, NULL);
 444         event_add(wev, NULL);
 445         /* Don't let the test go on too long. */
 446         tv.tv_sec = 0;
 447         tv.tv_usec = 200*1000;
 448         event_base_loopexit(base, &tv);
 449         event_base_loop(base, 0);
 450
 451         tt_int_op(got_read_on_close, ==, EV_READ);
 452         tt_int_op(got_write_on_close, ==, EV_WRITE);
 453         tt_int_op(premature_event, ==, 0);
 454
 455 end:
 456         if (pair1[0] >= 0)
 457                 evutil_closesocket(pair1[0]);
 458         if (pair1[1] >= 0)
 459                 evutil_closesocket(pair1[1]);
 460         if (pair2[0] >= 0)
 461                 evutil_closesocket(pair2[0]);
 462         if (pair2[1] >= 0)
 463                 evutil_closesocket(pair2[1]);
 464         if (rev)
 465                 event_free(rev);
 466         if (wev)
 467                 event_free(wev);
 468         if (closeev)
 469                 event_free(closeev);
 470         if (base)
 471                 event_base_free(base);
 472 }
 473
 474
 475 static void
 476 test_multiple(void)
 477 {
 478         struct event ev, ev2;
 479         int i;
 480
 481         /* Multiple read and write test */
 482         setup_test("Multiple read/write: ");
 483         memset(rbuf, 0, sizeof(rbuf));
 484         for (i = 0; i < (int)sizeof(wbuf); i++)
 485                 wbuf[i] = i;
 486
 487         roff = woff = 0;
 488         usepersist = 0;
 489
 490         event_set(&ev, pair[0], EV_WRITE, multiple_write_cb, &ev);
 491         if (event_add(&ev, NULL) == -1)
 492                 exit(1);
 493         event_set(&ev2, pair[1], EV_READ, multiple_read_cb, &ev2);
 494         if (event_add(&ev2, NULL) == -1)
 495                 exit(1);
 496         event_dispatch();
 497
 498         if (roff == woff)
 499                 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
 500
 501         cleanup_test();
 502 }
 503
 504 static void
 505 test_persistent(void)
 506 {
 507         struct event ev, ev2;
 508         int i;
 509
 510         /* Multiple read and write test with persist */
 511         setup_test("Persist read/write: ");
 512         memset(rbuf, 0, sizeof(rbuf));
 513         for (i = 0; i < (int)sizeof(wbuf); i++)
 514                 wbuf[i] = i;
 515
 516         roff = woff = 0;
 517         usepersist = 1;
 518
 519         event_set(&ev, pair[0], EV_WRITE|EV_PERSIST, multiple_write_cb, &ev);
 520         if (event_add(&ev, NULL) == -1)
 521                 exit(1);
 522         event_set(&ev2, pair[1], EV_READ|EV_PERSIST, multiple_read_cb, &ev2);
 523         if (event_add(&ev2, NULL) == -1)
 524                 exit(1);
 525         event_dispatch();
 526
 527         if (roff == woff)
 528                 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
 529
 530         cleanup_test();
 531 }
 532
 533 static void
 534 test_combined(void)
 535 {
 536         struct both r1, r2, w1, w2;
 537
 538         setup_test("Combined read/write: ");
 539         memset(&r1, 0, sizeof(r1));
 540         memset(&r2, 0, sizeof(r2));
 541         memset(&w1, 0, sizeof(w1));
 542         memset(&w2, 0, sizeof(w2));
 543
 544         w1.nread = 4096;
 545         w2.nread = 8192;
 546
 547         event_set(&r1.ev, pair[0], EV_READ, combined_read_cb, &r1);
 548         event_set(&w1.ev, pair[0], EV_WRITE, combined_write_cb, &w1);
 549         event_set(&r2.ev, pair[1], EV_READ, combined_read_cb, &r2);
 550         event_set(&w2.ev, pair[1], EV_WRITE, combined_write_cb, &w2);
 551         tt_assert(event_add(&r1.ev, NULL) != -1);
 552         tt_assert(!event_add(&w1.ev, NULL));
 553         tt_assert(!event_add(&r2.ev, NULL));
 554         tt_assert(!event_add(&w2.ev, NULL));
 555         event_dispatch();
 556
 557         if (r1.nread == 8192 && r2.nread == 4096)
 558                 test_ok = 1;
 559
 560 end:
 561         cleanup_test();
 562 }
 563
 564 static void
 565 test_simpletimeout(void)
 566 {
 567         struct timeval tv;
 568         struct event ev;
 569
 570         setup_test("Simple timeout: ");
 571
 572         tv.tv_usec = 200*1000;
 573         tv.tv_sec = 0;
 574         evutil_timerclear(&tcalled);
 575         evtimer_set(&ev, timeout_cb, NULL);
 576         evtimer_add(&ev, &tv);
 577
 578         evutil_gettimeofday(&tset, NULL);
 579         event_dispatch();
 580         test_timeval_diff_eq(&tset, &tcalled, 200);
 581
 582         test_ok = 1;
 583 end:
 584         cleanup_test();
 585 }
 586
 587 static void
 588 periodic_timeout_cb(evutil_socket_t fd, short event, void *arg)
 589 {
 590         int *count = arg;
 591
 592         (*count)++;
 593         if (*count == 6) {
 594                 /* call loopexit only once - on slow machines(?), it is
 595                  * apparently possible for this to get called twice. */
 596                 test_ok = 1;
 597                 event_base_loopexit(global_base, NULL);
 598         }
 599 }
 600
 601 static void
 602 test_persistent_timeout(void)
 603 {
 604         struct timeval tv;
 605         struct event ev;
 606         int count = 0;
 607
 608         evutil_timerclear(&tv);
 609         tv.tv_usec = 10000;
 610
 611         event_assign(&ev, global_base, -1, EV_TIMEOUT|EV_PERSIST,
 612             periodic_timeout_cb, &count);
 613         event_add(&ev, &tv);
 614
 615         event_dispatch();
 616
 617         event_del(&ev);
 618 }
 619
 620 static void
 621 test_persistent_timeout_jump(void *ptr)
 622 {
 623         struct basic_test_data *data = ptr;
 624         struct event ev;
 625         int count = 0;
 626         struct timeval msec100 = { 0, 100 * 1000 };
 627         struct timeval msec50 = { 0, 50 * 1000 };
 628         struct timeval msec300 = { 0, 300 * 1000 };
 629
 630         event_assign(&ev, data->base, -1, EV_PERSIST, periodic_timeout_cb, &count);
 631         event_add(&ev, &msec100);
 632         /* Wait for a bit */
 633         evutil_usleep_(&msec300);
 634         event_base_loopexit(data->base, &msec50);
 635         event_base_dispatch(data->base);
 636         tt_int_op(count, ==, 1);
 637
 638 end:
 639         event_del(&ev);
 640 }
 641
 642 struct persist_active_timeout_called {
 643         int n;
 644         short events[16];
 645         struct timeval tvs[16];
 646 };
 647
 648 static void
 649 activate_cb(evutil_socket_t fd, short event, void *arg)
 650 {
 651         struct event *ev = arg;
 652         event_active(ev, EV_READ, 1);
 653 }
 654
 655 static void
 656 persist_active_timeout_cb(evutil_socket_t fd, short event, void *arg)
 657 {
 658         struct persist_active_timeout_called *c = arg;
 659         if (c->n < 15) {
 660                 c->events[c->n] = event;
 661                 evutil_gettimeofday(&c->tvs[c->n], NULL);
 662                 ++c->n;
 663         }
 664 }
 665
 666 static void
 667 test_persistent_active_timeout(void *ptr)
 668 {
 669         struct timeval tv, tv2, tv_exit, start;
 670         struct event ev;
 671         struct persist_active_timeout_called res;
 672
 673         struct basic_test_data *data = ptr;
 674         struct event_base *base = data->base;
 675
 676         memset(&res, 0, sizeof(res));
 677
 678         tv.tv_sec = 0;
 679         tv.tv_usec = 200 * 1000;
 680         event_assign(&ev, base, -1, EV_TIMEOUT|EV_PERSIST,
 681             persist_active_timeout_cb, &res);
 682         event_add(&ev, &tv);
 683
 684         tv2.tv_sec = 0;
 685         tv2.tv_usec = 100 * 1000;
 686         event_base_once(base, -1, EV_TIMEOUT, activate_cb, &ev, &tv2);
 687
 688         tv_exit.tv_sec = 0;
 689         tv_exit.tv_usec = 600 * 1000;
 690         event_base_loopexit(base, &tv_exit);
 691
 692         event_base_assert_ok_(base);
 693         evutil_gettimeofday(&start, NULL);
 694
 695         event_base_dispatch(base);
 696         event_base_assert_ok_(base);
 697
 698         tt_int_op(res.n, ==, 3);
 699         tt_int_op(res.events[0], ==, EV_READ);
 700         tt_int_op(res.events[1], ==, EV_TIMEOUT);
 701         tt_int_op(res.events[2], ==, EV_TIMEOUT);
 702         test_timeval_diff_eq(&start, &res.tvs[0], 100);
 703         test_timeval_diff_eq(&start, &res.tvs[1], 300);
 704         test_timeval_diff_eq(&start, &res.tvs[2], 500);
 705 end:
 706         event_del(&ev);
 707 }
 708
 709 struct common_timeout_info {
 710         struct event ev;
 711         struct timeval called_at;
 712         int which;
 713         int count;
 714 };
 715
 716 static void
 717 common_timeout_cb(evutil_socket_t fd, short event, void *arg)
 718 {
 719         struct common_timeout_info *ti = arg;
 720         ++ti->count;
 721         evutil_gettimeofday(&ti->called_at, NULL);
 722         if (ti->count >= 4)
 723                 event_del(&ti->ev);
 724 }
 725
 726 static void
 727 test_common_timeout(void *ptr)
 728 {
 729         struct basic_test_data *data = ptr;
 730
 731         struct event_base *base = data->base;
 732         int i;
 733         struct common_timeout_info info[100];
 734
 735         struct timeval start;
 736         struct timeval tmp_100_ms = { 0, 100*1000 };
 737         struct timeval tmp_200_ms = { 0, 200*1000 };
 738         struct timeval tmp_5_sec = { 5, 0 };
 739         struct timeval tmp_5M_usec = { 0, 5*1000*1000 };
 740
 741         const struct timeval *ms_100, *ms_200, *sec_5;
 742
 743         ms_100 = event_base_init_common_timeout(base, &tmp_100_ms);
 744         ms_200 = event_base_init_common_timeout(base, &tmp_200_ms);
 745         sec_5 = event_base_init_common_timeout(base, &tmp_5_sec);
 746         tt_assert(ms_100);
 747         tt_assert(ms_200);
 748         tt_assert(sec_5);
 749         tt_ptr_op(event_base_init_common_timeout(base, &tmp_200_ms),
 750             ==, ms_200);
 751         tt_ptr_op(event_base_init_common_timeout(base, ms_200), ==, ms_200);
 752         tt_ptr_op(event_base_init_common_timeout(base, &tmp_5M_usec), ==, sec_5);
 753         tt_int_op(ms_100->tv_sec, ==, 0);
 754         tt_int_op(ms_200->tv_sec, ==, 0);
 755         tt_int_op(sec_5->tv_sec, ==, 5);
 756         tt_int_op(ms_100->tv_usec, ==, 100000|0x50000000);
 757         tt_int_op(ms_200->tv_usec, ==, 200000|0x50100000);
 758         tt_int_op(sec_5->tv_usec, ==, 0|0x50200000);
 759
 760         memset(info, 0, sizeof(info));
 761
 762         for (i=0; i<100; ++i) {
 763                 info[i].which = i;
 764                 event_assign(&info[i].ev, base, -1, EV_TIMEOUT|EV_PERSIST,
 765                     common_timeout_cb, &info[i]);
 766                 if (i % 2) {
 767                         if ((i%20)==1) {
 768                                 /* Glass-box test: Make sure we survive the
 769                                  * transition to non-common timeouts. It's
 770                                  * a little tricky. */
 771                                 event_add(&info[i].ev, ms_200);
 772                                 event_add(&info[i].ev, &tmp_100_ms);
 773                         } else if ((i%20)==3) {
 774                                 /* Check heap-to-common too. */
 775                                 event_add(&info[i].ev, &tmp_200_ms);
 776                                 event_add(&info[i].ev, ms_100);
 777                         } else if ((i%20)==5) {
 778                                 /* Also check common-to-common. */
 779                                 event_add(&info[i].ev, ms_200);
 780                                 event_add(&info[i].ev, ms_100);
 781                         } else {
 782                                 event_add(&info[i].ev, ms_100);
 783                         }
 784                 } else {
 785                         event_add(&info[i].ev, ms_200);
 786                 }
 787         }
 788
 789         event_base_assert_ok_(base);
 790         evutil_gettimeofday(&start, NULL);
 791         event_base_dispatch(base);
 792
 793         event_base_assert_ok_(base);
 794
 795         for (i=0; i<10; ++i) {
 796                 tt_int_op(info[i].count, ==, 4);
 797                 if (i % 2) {
 798                         test_timeval_diff_eq(&start, &info[i].called_at, 400);
 799                 } else {
 800                         test_timeval_diff_eq(&start, &info[i].called_at, 800);
 801                 }
 802         }
 803
 804         /* Make sure we can free the base with some events in. */
 805         for (i=0; i<100; ++i) {
 806                 if (i % 2) {
 807                         event_add(&info[i].ev, ms_100);
 808                 } else {
 809                         event_add(&info[i].ev, ms_200);
 810                 }
 811         }
 812
 813 end:
 814         event_base_free(data->base); /* need to do this here before info is
 815                                       * out-of-scope */
 816         data->base = NULL;
 817 }
 818
 819 #ifndef _WIN32
 820
 821 #define current_base event_global_current_base_
 822 extern struct event_base *current_base;
 823
 824 static void
 825 fork_signal_cb(evutil_socket_t fd, short events, void *arg)
 826 {
 827         event_del(arg);
 828 }
 829
 830 int child_pair[2] = { -1, -1 };
 831 static void
 832 simple_child_read_cb(evutil_socket_t fd, short event, void *arg)
 833 {
 834         char buf[256];
 835         int len;
 836
 837         len = read(fd, buf, sizeof(buf));
 838         if (write(child_pair[0], "", 1) < 0)
 839                 tt_fail_perror("write");
 840
 841         if (len) {
 842                 if (!called) {
 843                         if (event_add(arg, NULL) == -1)
 844                                 exit(1);
 845                 }
 846         } else if (called == 1)
 847                 test_ok = 1;
 848
 849         called++;
 850 }
 851 static void
 852 test_fork(void)
 853 {
 854         char c;
 855         int status;
 856         struct event ev, sig_ev, usr_ev, existing_ev;
 857         pid_t pid;
 858         int wait_flags = 0;
 859
 860 #ifdef EVENT__HAVE_WAITPID_WITH_WNOWAIT
 861         wait_flags |= WNOWAIT;
 862 #endif
 863
 864         setup_test("After fork: ");
 865
 866         {
 867                 if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, child_pair) == -1) {
 868                         fprintf(stderr, "%s: socketpair\n", __func__);
 869                         exit(1);
 870                 }
 871
 872                 if (evutil_make_socket_nonblocking(child_pair[0]) == -1) {
 873                         fprintf(stderr, "fcntl(O_NONBLOCK)");
 874                         exit(1);
 875                 }
 876         }
 877
 878         tt_assert(current_base);
 879         evthread_make_base_notifiable(current_base);
 880
 881         if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
 882                 tt_fail_perror("write");
 883         }
 884
 885         event_set(&ev, pair[1], EV_READ, simple_child_read_cb, &ev);
 886         if (event_add(&ev, NULL) == -1)
 887                 exit(1);
 888
 889         evsignal_set(&sig_ev, SIGCHLD, fork_signal_cb, &sig_ev);
 890         evsignal_add(&sig_ev, NULL);
 891
 892         evsignal_set(&existing_ev, SIGUSR2, fork_signal_cb, &existing_ev);
 893         evsignal_add(&existing_ev, NULL);
 894
 895         event_base_assert_ok_(current_base);
 896         TT_BLATHER(("Before fork"));
 897         if ((pid = regress_fork()) == 0) {
 898                 /* in the child */
 899                 TT_BLATHER(("In child, before reinit"));
 900                 event_base_assert_ok_(current_base);
 901                 if (event_reinit(current_base) == -1) {
 902                         fprintf(stdout, "FAILED (reinit)\n");
 903                         exit(1);
 904                 }
 905                 TT_BLATHER(("After reinit"));
 906                 event_base_assert_ok_(current_base);
 907                 TT_BLATHER(("After assert-ok"));
 908
 909                 evsignal_del(&sig_ev);
 910
 911                 evsignal_set(&usr_ev, SIGUSR1, fork_signal_cb, &usr_ev);
 912                 evsignal_add(&usr_ev, NULL);
 913                 raise(SIGUSR1);
 914                 raise(SIGUSR2);
 915
 916                 called = 0;
 917
 918                 event_dispatch();
 919
 920                 event_base_free(current_base);
 921
 922                 /* we do not send an EOF; simple_read_cb requires an EOF
 923                  * to set test_ok.  we just verify that the callback was
 924                  * called. */
 925                 exit(test_ok != 0 || called != 2 ? -2 : 76);
 926         }
 927
 928         /** wait until client read first message */
 929         if (read(child_pair[1], &c, 1) < 0) {
 930                 tt_fail_perror("read");
 931         }
 932         if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
 933                 tt_fail_perror("write");
 934         }
 935
 936         TT_BLATHER(("Before waitpid"));
 937         if (waitpid(pid, &status, wait_flags) == -1) {
 938                 perror("waitpid");
 939                 exit(1);
 940         }
 941         TT_BLATHER(("After waitpid"));
 942
 943         if (WEXITSTATUS(status) != 76) {
 944                 fprintf(stdout, "FAILED (exit): %d\n", WEXITSTATUS(status));
 945                 exit(1);
 946         }
 947
 948         /* test that the current event loop still works */
 949         if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
 950                 fprintf(stderr, "%s: write\n", __func__);
 951         }
 952
 953         shutdown(pair[0], EVUTIL_SHUT_WR);
 954
 955         evsignal_set(&usr_ev, SIGUSR1, fork_signal_cb, &usr_ev);
 956         evsignal_add(&usr_ev, NULL);
 957         raise(SIGUSR1);
 958         raise(SIGUSR2);
 959
 960         event_dispatch();
 961
 962         evsignal_del(&sig_ev);
 963         tt_int_op(test_ok, ==, 1);
 964
 965         end:
 966         cleanup_test();
 967         if (child_pair[0] != -1)
 968                 evutil_closesocket(child_pair[0]);
 969         if (child_pair[1] != -1)
 970                 evutil_closesocket(child_pair[1]);
 971 }
 972
 973 #ifdef EVENT__HAVE_PTHREADS
 974 static void* del_wait_thread(void *arg)
 975 {
 976         struct timeval tv_start, tv_end;
 977
 978         evutil_gettimeofday(&tv_start, NULL);
 979         event_dispatch();
 980         evutil_gettimeofday(&tv_end, NULL);
 981
 982         test_timeval_diff_eq(&tv_start, &tv_end, 300);
 983
 984         end:
 985         return NULL;
 986 }
 987
 988 static void
 989 del_wait_cb(evutil_socket_t fd, short event, void *arg)
 990 {
 991         struct timeval delay = { 0, 300*1000 };
 992         TT_BLATHER(("Sleeping"));
 993         evutil_usleep_(&delay);
 994         test_ok = 1;
 995 }
 996
 997 static void
 998 test_del_wait(void)
 999 {
1000         struct event ev;
1001         pthread_t thread;
1002
1003         setup_test("event_del will wait: ");
1004
1005         event_set(&ev, pair[1], EV_READ, del_wait_cb, &ev);
1006         event_add(&ev, NULL);
1007
1008         pthread_create(&thread, NULL, del_wait_thread, NULL);
1009
1010         if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
1011                 tt_fail_perror("write");
1012         }
1013
1014         {
1015                 struct timeval delay = { 0, 30*1000 };
1016                 evutil_usleep_(&delay);
1017         }
1018
1019         {
1020                 struct timeval tv_start, tv_end;
1021                 evutil_gettimeofday(&tv_start, NULL);
1022                 event_del(&ev);
1023                 evutil_gettimeofday(&tv_end, NULL);
1024                 test_timeval_diff_eq(&tv_start, &tv_end, 270);
1025         }
1026
1027         pthread_join(thread, NULL);
1028
1029         end:
1030         ;
1031 }
1032 #endif
1033
1034 static void
1035 signal_cb_sa(int sig)
1036 {
1037         test_ok = 2;
1038 }
1039
1040 static void
1041 signal_cb(evutil_socket_t fd, short event, void *arg)
1042 {
1043         struct event *ev = arg;
1044
1045         evsignal_del(ev);
1046         test_ok = 1;
1047 }
1048
1049 static void
1050 test_simplesignal_impl(int find_reorder)
1051 {
1052         struct event ev;
1053         struct itimerval itv;
1054
1055         evsignal_set(&ev, SIGALRM, signal_cb, &ev);
1056         evsignal_add(&ev, NULL);
1057         /* find bugs in which operations are re-ordered */
1058         if (find_reorder) {
1059                 evsignal_del(&ev);
1060                 evsignal_add(&ev, NULL);
1061         }
1062
1063         memset(&itv, 0, sizeof(itv));
1064         itv.it_value.tv_sec = 0;
1065         itv.it_value.tv_usec = 100000;
1066         if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
1067                 goto skip_simplesignal;
1068
1069         event_dispatch();
1070  skip_simplesignal:
1071         if (evsignal_del(&ev) == -1)
1072                 test_ok = 0;
1073
1074         cleanup_test();
1075 }
1076
1077 static void
1078 test_simplestsignal(void)
1079 {
1080         setup_test("Simplest one signal: ");
1081         test_simplesignal_impl(0);
1082 }
1083
1084 static void
1085 test_simplesignal(void)
1086 {
1087         setup_test("Simple signal: ");
1088         test_simplesignal_impl(1);
1089 }
1090
1091 static void
1092 test_multiplesignal(void)
1093 {
1094         struct event ev_one, ev_two;
1095         struct itimerval itv;
1096
1097         setup_test("Multiple signal: ");
1098
1099         evsignal_set(&ev_one, SIGALRM, signal_cb, &ev_one);
1100         evsignal_add(&ev_one, NULL);
1101
1102         evsignal_set(&ev_two, SIGALRM, signal_cb, &ev_two);
1103         evsignal_add(&ev_two, NULL);
1104
1105         memset(&itv, 0, sizeof(itv));
1106         itv.it_value.tv_sec = 0;
1107         itv.it_value.tv_usec = 100000;
1108         if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
1109                 goto skip_simplesignal;
1110
1111         event_dispatch();
1112
1113  skip_simplesignal:
1114         if (evsignal_del(&ev_one) == -1)
1115                 test_ok = 0;
1116         if (evsignal_del(&ev_two) == -1)
1117                 test_ok = 0;
1118
1119         cleanup_test();
1120 }
1121
1122 static void
1123 test_immediatesignal(void)
1124 {
1125         struct event ev;
1126
1127         test_ok = 0;
1128         evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
1129         evsignal_add(&ev, NULL);
1130         raise(SIGUSR1);
1131         event_loop(EVLOOP_NONBLOCK);
1132         evsignal_del(&ev);
1133         cleanup_test();
1134 }
1135
1136 static void
1137 test_signal_dealloc(void)
1138 {
1139         /* make sure that evsignal_event is event_del'ed and pipe closed */
1140         struct event ev;
1141         struct event_base *base = event_init();
1142         evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
1143         evsignal_add(&ev, NULL);
1144         evsignal_del(&ev);
1145         event_base_free(base);
1146         /* If we got here without asserting, we're fine. */
1147         test_ok = 1;
1148         cleanup_test();
1149 }
1150
1151 static void
1152 test_signal_pipeloss(void)
1153 {
1154         /* make sure that the base1 pipe is closed correctly. */
1155         struct event_base *base1, *base2;
1156         int pipe1;
1157         test_ok = 0;
1158         base1 = event_init();
1159         pipe1 = base1->sig.ev_signal_pair[0];
1160         base2 = event_init();
1161         event_base_free(base2);
1162         event_base_free(base1);
1163         if (close(pipe1) != -1 || errno!=EBADF) {
1164                 /* fd must be closed, so second close gives -1, EBADF */
1165                 printf("signal pipe not closed. ");
1166                 test_ok = 0;
1167         } else {
1168                 test_ok = 1;
1169         }
1170         cleanup_test();
1171 }
1172
1173 /*
1174  * make two bases to catch signals, use both of them.  this only works
1175  * for event mechanisms that use our signal pipe trick.  kqueue handles
1176  * signals internally, and all interested kqueues get all the signals.
1177  */
1178 static void
1179 test_signal_switchbase(void)
1180 {
1181         struct event ev1, ev2;
1182         struct event_base *base1, *base2;
1183         int is_kqueue;
1184         test_ok = 0;
1185         base1 = event_init();
1186         base2 = event_init();
1187         is_kqueue = !strcmp(event_get_method(),"kqueue");
1188         evsignal_set(&ev1, SIGUSR1, signal_cb, &ev1);
1189         evsignal_set(&ev2, SIGUSR1, signal_cb, &ev2);
1190         if (event_base_set(base1, &ev1) ||
1191             event_base_set(base2, &ev2) ||
1192             event_add(&ev1, NULL) ||
1193             event_add(&ev2, NULL)) {
1194                 fprintf(stderr, "%s: cannot set base, add\n", __func__);
1195                 exit(1);
1196         }
1197
1198         tt_ptr_op(event_get_base(&ev1), ==, base1);
1199         tt_ptr_op(event_get_base(&ev2), ==, base2);
1200
1201         test_ok = 0;
1202         /* can handle signal before loop is called */
1203         raise(SIGUSR1);
1204         event_base_loop(base2, EVLOOP_NONBLOCK);
1205         if (is_kqueue) {
1206                 if (!test_ok)
1207                         goto end;
1208                 test_ok = 0;
1209         }
1210         event_base_loop(base1, EVLOOP_NONBLOCK);
1211         if (test_ok && !is_kqueue) {
1212                 test_ok = 0;
1213
1214                 /* set base1 to handle signals */
1215                 event_base_loop(base1, EVLOOP_NONBLOCK);
1216                 raise(SIGUSR1);
1217                 event_base_loop(base1, EVLOOP_NONBLOCK);
1218                 event_base_loop(base2, EVLOOP_NONBLOCK);
1219         }
1220 end:
1221         event_base_free(base1);
1222         event_base_free(base2);
1223         cleanup_test();
1224 }
1225
1226 /*
1227  * assert that a signal event removed from the event queue really is
1228  * removed - with no possibility of it's parent handler being fired.
1229  */
1230 static void
1231 test_signal_assert(void)
1232 {
1233         struct event ev;
1234         struct event_base *base = event_init();
1235         test_ok = 0;
1236         /* use SIGCONT so we don't kill ourselves when we signal to nowhere */
1237         evsignal_set(&ev, SIGCONT, signal_cb, &ev);
1238         evsignal_add(&ev, NULL);
1239         /*
1240          * if evsignal_del() fails to reset the handler, it's current handler
1241          * will still point to evsig_handler().
1242          */
1243         evsignal_del(&ev);
1244
1245         raise(SIGCONT);
1246 #if 0
1247         /* only way to verify we were in evsig_handler() */
1248         /* XXXX Now there's no longer a good way. */
1249         if (base->sig.evsig_caught)
1250                 test_ok = 0;
1251         else
1252                 test_ok = 1;
1253 #else
1254         test_ok = 1;
1255 #endif
1256
1257         event_base_free(base);
1258         cleanup_test();
1259         return;
1260 }
1261
1262 /*
1263  * assert that we restore our previous signal handler properly.
1264  */
1265 static void
1266 test_signal_restore(void)
1267 {
1268         struct event ev;
1269         struct event_base *base = event_init();
1270 #ifdef EVENT__HAVE_SIGACTION
1271         struct sigaction sa;
1272 #endif
1273
1274         test_ok = 0;
1275 #ifdef EVENT__HAVE_SIGACTION
1276         sa.sa_handler = signal_cb_sa;
1277         sa.sa_flags = 0x0;
1278         sigemptyset(&sa.sa_mask);
1279         if (sigaction(SIGUSR1, &sa, NULL) == -1)
1280                 goto out;
1281 #else
1282         if (signal(SIGUSR1, signal_cb_sa) == SIG_ERR)
1283                 goto out;
1284 #endif
1285         evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
1286         evsignal_add(&ev, NULL);
1287         evsignal_del(&ev);
1288
1289         raise(SIGUSR1);
1290         /* 1 == signal_cb, 2 == signal_cb_sa, we want our previous handler */
1291         if (test_ok != 2)
1292                 test_ok = 0;
1293 out:
1294         event_base_free(base);
1295         cleanup_test();
1296         return;
1297 }
1298
1299 static void
1300 signal_cb_swp(int sig, short event, void *arg)
1301 {
1302         called++;
1303         if (called < 5)
1304                 raise(sig);
1305         else
1306                 event_loopexit(NULL);
1307 }
1308 static void
1309 timeout_cb_swp(evutil_socket_t fd, short event, void *arg)
1310 {
1311         if (called == -1) {
1312                 struct timeval tv = {5, 0};
1313
1314                 called = 0;
1315                 evtimer_add((struct event *)arg, &tv);
1316                 raise(SIGUSR1);
1317                 return;
1318         }
1319         test_ok = 0;
1320         event_loopexit(NULL);
1321 }
1322
1323 static void
1324 test_signal_while_processing(void)
1325 {
1326         struct event_base *base = event_init();
1327         struct event ev, ev_timer;
1328         struct timeval tv = {0, 0};
1329
1330         setup_test("Receiving a signal while processing other signal: ");
1331
1332         called = -1;
1333         test_ok = 1;
1334         signal_set(&ev, SIGUSR1, signal_cb_swp, NULL);
1335         signal_add(&ev, NULL);
1336         evtimer_set(&ev_timer, timeout_cb_swp, &ev_timer);
1337         evtimer_add(&ev_timer, &tv);
1338         event_dispatch();
1339
1340         event_base_free(base);
1341         cleanup_test();
1342         return;
1343 }
1344 #endif
1345
1346 static void
1347 test_free_active_base(void *ptr)
1348 {
1349         struct basic_test_data *data = ptr;
1350         struct event_base *base1;
1351         struct event ev1;
1352
1353         base1 = event_init();
1354         if (base1) {
1355                 event_assign(&ev1, base1, data->pair[1], EV_READ,
1356                              dummy_read_cb, NULL);
1357                 event_add(&ev1, NULL);
1358                 event_base_free(base1);  /* should not crash */
1359         } else {
1360                 tt_fail_msg("failed to create event_base for test");
1361         }
1362
1363         base1 = event_init();
1364         tt_assert(base1);
1365         event_assign(&ev1, base1, 0, 0, dummy_read_cb, NULL);
1366         event_active(&ev1, EV_READ, 1);
1367         event_base_free(base1);
1368 end:
1369         ;
1370 }
1371
1372 static void
1373 test_manipulate_active_events(void *ptr)
1374 {
1375         struct basic_test_data *data = ptr;
1376         struct event_base *base = data->base;
1377         struct event ev1;
1378
1379         event_assign(&ev1, base, -1, EV_TIMEOUT, dummy_read_cb, NULL);
1380
1381         /* Make sure an active event is pending. */
1382         event_active(&ev1, EV_READ, 1);
1383         tt_int_op(event_pending(&ev1, EV_READ|EV_TIMEOUT|EV_WRITE, NULL),
1384             ==, EV_READ);
1385
1386         /* Make sure that activating an event twice works. */
1387         event_active(&ev1, EV_WRITE, 1);
1388         tt_int_op(event_pending(&ev1, EV_READ|EV_TIMEOUT|EV_WRITE, NULL),
1389             ==, EV_READ|EV_WRITE);
1390
1391 end:
1392         event_del(&ev1);
1393 }
1394
1395 static void
1396 event_selfarg_cb(evutil_socket_t fd, short event, void *arg)
1397 {
1398         struct event *ev = arg;
1399         struct event_base *base = event_get_base(ev);
1400         event_base_assert_ok_(base);
1401         event_base_loopexit(base, NULL);
1402         tt_want(ev == event_base_get_running_event(base));
1403 }
1404
1405 static void
1406 test_event_new_selfarg(void *ptr)
1407 {
1408         struct basic_test_data *data = ptr;
1409         struct event_base *base = data->base;
1410         struct event *ev = event_new(base, -1, EV_READ, event_selfarg_cb,
1411                                      event_self_cbarg());
1412
1413         event_active(ev, EV_READ, 1);
1414         event_base_dispatch(base);
1415
1416         event_free(ev);
1417 }
1418
1419 static void
1420 test_event_assign_selfarg(void *ptr)
1421 {
1422         struct basic_test_data *data = ptr;
1423         struct event_base *base = data->base;
1424         struct event ev;
1425
1426         event_assign(&ev, base, -1, EV_READ, event_selfarg_cb,
1427                      event_self_cbarg());
1428         event_active(&ev, EV_READ, 1);
1429         event_base_dispatch(base);
1430 }
1431
1432 static void
1433 test_event_base_get_num_events(void *ptr)
1434 {
1435         struct basic_test_data *data = ptr;
1436         struct event_base *base = data->base;
1437         struct event ev;
1438         int event_count_active;
1439         int event_count_virtual;
1440         int event_count_added;
1441         int event_count_active_virtual;
1442         int event_count_active_added;
1443         int event_count_virtual_added;
1444         int event_count_active_added_virtual;
1445
1446         struct timeval qsec = {0, 100000};
1447
1448         event_assign(&ev, base, -1, EV_READ, event_selfarg_cb,
1449             event_self_cbarg());
1450
1451         event_add(&ev, &qsec);
1452         event_count_active = event_base_get_num_events(base,
1453             EVENT_BASE_COUNT_ACTIVE);
1454         event_count_virtual = event_base_get_num_events(base,
1455             EVENT_BASE_COUNT_VIRTUAL);
1456         event_count_added = event_base_get_num_events(base,
1457             EVENT_BASE_COUNT_ADDED);
1458         event_count_active_virtual = event_base_get_num_events(base,
1459             EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_VIRTUAL);
1460         event_count_active_added = event_base_get_num_events(base,
1461             EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_ADDED);
1462         event_count_virtual_added = event_base_get_num_events(base,
1463             EVENT_BASE_COUNT_VIRTUAL|EVENT_BASE_COUNT_ADDED);
1464         event_count_active_added_virtual = event_base_get_num_events(base,
1465             EVENT_BASE_COUNT_ACTIVE|
1466             EVENT_BASE_COUNT_ADDED|
1467             EVENT_BASE_COUNT_VIRTUAL);
1468         tt_int_op(event_count_active, ==, 0);
1469         tt_int_op(event_count_virtual, ==, 0);
1470         /* libevent itself adds a timeout event, so the event_count is 2 here */
1471         tt_int_op(event_count_added, ==, 2);
1472         tt_int_op(event_count_active_virtual, ==, 0);
1473         tt_int_op(event_count_active_added, ==, 2);
1474         tt_int_op(event_count_virtual_added, ==, 2);
1475         tt_int_op(event_count_active_added_virtual, ==, 2);
1476
1477         event_active(&ev, EV_READ, 1);
1478         event_count_active = event_base_get_num_events(base,
1479             EVENT_BASE_COUNT_ACTIVE);
1480         event_count_virtual = event_base_get_num_events(base,
1481             EVENT_BASE_COUNT_VIRTUAL);
1482         event_count_added = event_base_get_num_events(base,
1483             EVENT_BASE_COUNT_ADDED);
1484         event_count_active_virtual = event_base_get_num_events(base,
1485             EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_VIRTUAL);
1486         event_count_active_added = event_base_get_num_events(base,
1487             EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_ADDED);
1488         event_count_virtual_added = event_base_get_num_events(base,
1489             EVENT_BASE_COUNT_VIRTUAL|EVENT_BASE_COUNT_ADDED);
1490         event_count_active_added_virtual = event_base_get_num_events(base,
1491             EVENT_BASE_COUNT_ACTIVE|
1492             EVENT_BASE_COUNT_ADDED|
1493             EVENT_BASE_COUNT_VIRTUAL);
1494         tt_int_op(event_count_active, ==, 1);
1495         tt_int_op(event_count_virtual, ==, 0);
1496         tt_int_op(event_count_added, ==, 3);
1497         tt_int_op(event_count_active_virtual, ==, 1);
1498         tt_int_op(event_count_active_added, ==, 4);
1499         tt_int_op(event_count_virtual_added, ==, 3);
1500         tt_int_op(event_count_active_added_virtual, ==, 4);
1501
1502        event_base_loop(base, 0);
1503        event_count_active = event_base_get_num_events(base,
1504            EVENT_BASE_COUNT_ACTIVE);
1505        event_count_virtual = event_base_get_num_events(base,
1506            EVENT_BASE_COUNT_VIRTUAL);
1507        event_count_added = event_base_get_num_events(base,
1508            EVENT_BASE_COUNT_ADDED);
1509        event_count_active_virtual = event_base_get_num_events(base,
1510            EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_VIRTUAL);
1511        event_count_active_added = event_base_get_num_events(base,
1512            EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_ADDED);
1513        event_count_virtual_added = event_base_get_num_events(base,
1514            EVENT_BASE_COUNT_VIRTUAL|EVENT_BASE_COUNT_ADDED);
1515        event_count_active_added_virtual = event_base_get_num_events(base,
1516            EVENT_BASE_COUNT_ACTIVE|
1517            EVENT_BASE_COUNT_ADDED|
1518            EVENT_BASE_COUNT_VIRTUAL);
1519        tt_int_op(event_count_active, ==, 0);
1520        tt_int_op(event_count_virtual, ==, 0);
1521        tt_int_op(event_count_added, ==, 0);
1522        tt_int_op(event_count_active_virtual, ==, 0);
1523        tt_int_op(event_count_active_added, ==, 0);
1524        tt_int_op(event_count_virtual_added, ==, 0);
1525        tt_int_op(event_count_active_added_virtual, ==, 0);
1526
1527        event_base_add_virtual_(base);
1528        event_count_active = event_base_get_num_events(base,
1529            EVENT_BASE_COUNT_ACTIVE);
1530        event_count_virtual = event_base_get_num_events(base,
1531            EVENT_BASE_COUNT_VIRTUAL);
1532        event_count_added = event_base_get_num_events(base,
1533            EVENT_BASE_COUNT_ADDED);
1534        event_count_active_virtual = event_base_get_num_events(base,
1535            EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_VIRTUAL);
1536        event_count_active_added = event_base_get_num_events(base,
1537            EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_ADDED);
1538        event_count_virtual_added = event_base_get_num_events(base,
1539            EVENT_BASE_COUNT_VIRTUAL|EVENT_BASE_COUNT_ADDED);
1540        event_count_active_added_virtual = event_base_get_num_events(base,
1541            EVENT_BASE_COUNT_ACTIVE|
1542            EVENT_BASE_COUNT_ADDED|
1543            EVENT_BASE_COUNT_VIRTUAL);
1544        tt_int_op(event_count_active, ==, 0);
1545        tt_int_op(event_count_virtual, ==, 1);
1546        tt_int_op(event_count_added, ==, 0);
1547        tt_int_op(event_count_active_virtual, ==, 1);
1548        tt_int_op(event_count_active_added, ==, 0);
1549        tt_int_op(event_count_virtual_added, ==, 1);
1550        tt_int_op(event_count_active_added_virtual, ==, 1);
1551
1552 end:
1553        ;
1554 }
1555
1556 static void
1557 test_event_base_get_max_events(void *ptr)
1558 {
1559         struct basic_test_data *data = ptr;
1560         struct event_base *base = data->base;
1561         struct event ev;
1562         struct event ev2;
1563         int event_count_active;
1564         int event_count_virtual;
1565         int event_count_added;
1566         int event_count_active_virtual;
1567         int event_count_active_added;
1568         int event_count_virtual_added;
1569         int event_count_active_added_virtual;
1570
1571         struct timeval qsec = {0, 100000};
1572
1573         event_assign(&ev, base, -1, EV_READ, event_selfarg_cb,
1574             event_self_cbarg());
1575         event_assign(&ev2, base, -1, EV_READ, event_selfarg_cb,
1576             event_self_cbarg());
1577
1578         event_add(&ev, &qsec);
1579         event_add(&ev2, &qsec);
1580         event_del(&ev2);
1581
1582         event_count_active = event_base_get_max_events(base,
1583             EVENT_BASE_COUNT_ACTIVE, 0);
1584         event_count_virtual = event_base_get_max_events(base,
1585             EVENT_BASE_COUNT_VIRTUAL, 0);
1586         event_count_added = event_base_get_max_events(base,
1587             EVENT_BASE_COUNT_ADDED, 0);
1588         event_count_active_virtual = event_base_get_max_events(base,
1589             EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_VIRTUAL, 0);
1590         event_count_active_added = event_base_get_max_events(base,
1591             EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_ADDED, 0);
1592         event_count_virtual_added = event_base_get_max_events(base,
1593             EVENT_BASE_COUNT_VIRTUAL | EVENT_BASE_COUNT_ADDED, 0);
1594         event_count_active_added_virtual = event_base_get_max_events(base,
1595             EVENT_BASE_COUNT_ACTIVE |
1596             EVENT_BASE_COUNT_ADDED |
1597             EVENT_BASE_COUNT_VIRTUAL, 0);
1598
1599         tt_int_op(event_count_active, ==, 0);
1600         tt_int_op(event_count_virtual, ==, 0);
1601         /* libevent itself adds a timeout event, so the event_count is 4 here */
1602         tt_int_op(event_count_added, ==, 4);
1603         tt_int_op(event_count_active_virtual, ==, 0);
1604         tt_int_op(event_count_active_added, ==, 4);
1605         tt_int_op(event_count_virtual_added, ==, 4);
1606         tt_int_op(event_count_active_added_virtual, ==, 4);
1607
1608         event_active(&ev, EV_READ, 1);
1609         event_count_active = event_base_get_max_events(base,
1610             EVENT_BASE_COUNT_ACTIVE, 0);
1611         event_count_virtual = event_base_get_max_events(base,
1612             EVENT_BASE_COUNT_VIRTUAL, 0);
1613         event_count_added = event_base_get_max_events(base,
1614             EVENT_BASE_COUNT_ADDED, 0);
1615         event_count_active_virtual = event_base_get_max_events(base,
1616             EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_VIRTUAL, 0);
1617         event_count_active_added = event_base_get_max_events(base,
1618             EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_ADDED, 0);
1619         event_count_virtual_added = event_base_get_max_events(base,
1620             EVENT_BASE_COUNT_VIRTUAL | EVENT_BASE_COUNT_ADDED, 0);
1621         event_count_active_added_virtual = event_base_get_max_events(base,
1622             EVENT_BASE_COUNT_ACTIVE |
1623             EVENT_BASE_COUNT_ADDED |
1624             EVENT_BASE_COUNT_VIRTUAL, 0);
1625
1626         tt_int_op(event_count_active, ==, 1);
1627         tt_int_op(event_count_virtual, ==, 0);
1628         tt_int_op(event_count_added, ==, 4);
1629         tt_int_op(event_count_active_virtual, ==, 1);
1630         tt_int_op(event_count_active_added, ==, 5);
1631         tt_int_op(event_count_virtual_added, ==, 4);
1632         tt_int_op(event_count_active_added_virtual, ==, 5);
1633
1634         event_base_loop(base, 0);
1635         event_count_active = event_base_get_max_events(base,
1636             EVENT_BASE_COUNT_ACTIVE, 1);
1637         event_count_virtual = event_base_get_max_events(base,
1638             EVENT_BASE_COUNT_VIRTUAL, 1);
1639         event_count_added = event_base_get_max_events(base,
1640             EVENT_BASE_COUNT_ADDED, 1);
1641         event_count_active_virtual = event_base_get_max_events(base,
1642             EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_VIRTUAL, 0);
1643         event_count_active_added = event_base_get_max_events(base,
1644             EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_ADDED, 0);
1645         event_count_virtual_added = event_base_get_max_events(base,
1646             EVENT_BASE_COUNT_VIRTUAL | EVENT_BASE_COUNT_ADDED, 0);
1647         event_count_active_added_virtual = event_base_get_max_events(base,
1648             EVENT_BASE_COUNT_ACTIVE |
1649             EVENT_BASE_COUNT_ADDED |
1650             EVENT_BASE_COUNT_VIRTUAL, 1);
1651
1652         tt_int_op(event_count_active, ==, 1);
1653         tt_int_op(event_count_virtual, ==, 0);
1654         tt_int_op(event_count_added, ==, 4);
1655         tt_int_op(event_count_active_virtual, ==, 0);
1656         tt_int_op(event_count_active_added, ==, 0);
1657         tt_int_op(event_count_virtual_added, ==, 0);
1658         tt_int_op(event_count_active_added_virtual, ==, 0);
1659
1660         event_count_active = event_base_get_max_events(base,
1661             EVENT_BASE_COUNT_ACTIVE, 0);
1662         event_count_virtual = event_base_get_max_events(base,
1663             EVENT_BASE_COUNT_VIRTUAL, 0);
1664         event_count_added = event_base_get_max_events(base,
1665             EVENT_BASE_COUNT_ADDED, 0);
1666         tt_int_op(event_count_active, ==, 0);
1667         tt_int_op(event_count_virtual, ==, 0);
1668         tt_int_op(event_count_added, ==, 0);
1669
1670         event_base_add_virtual_(base);
1671         event_count_active = event_base_get_max_events(base,
1672             EVENT_BASE_COUNT_ACTIVE, 0);
1673         event_count_virtual = event_base_get_max_events(base,
1674             EVENT_BASE_COUNT_VIRTUAL, 0);
1675         event_count_added = event_base_get_max_events(base,
1676             EVENT_BASE_COUNT_ADDED, 0);
1677         event_count_active_virtual = event_base_get_max_events(base,
1678             EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_VIRTUAL, 0);
1679         event_count_active_added = event_base_get_max_events(base,
1680             EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_ADDED, 0);
1681         event_count_virtual_added = event_base_get_max_events(base,
1682             EVENT_BASE_COUNT_VIRTUAL | EVENT_BASE_COUNT_ADDED, 0);
1683         event_count_active_added_virtual = event_base_get_max_events(base,
1684             EVENT_BASE_COUNT_ACTIVE |
1685             EVENT_BASE_COUNT_ADDED |
1686             EVENT_BASE_COUNT_VIRTUAL, 0);
1687
1688         tt_int_op(event_count_active, ==, 0);
1689         tt_int_op(event_count_virtual, ==, 1);
1690         tt_int_op(event_count_added, ==, 0);
1691         tt_int_op(event_count_active_virtual, ==, 1);
1692         tt_int_op(event_count_active_added, ==, 0);
1693         tt_int_op(event_count_virtual_added, ==, 1);
1694         tt_int_op(event_count_active_added_virtual, ==, 1);
1695
1696 end:
1697        ;
1698 }
1699
1700 static void
1701 test_bad_assign(void *ptr)
1702 {
1703         struct event ev;
1704         int r;
1705         /* READ|SIGNAL is not allowed */
1706         r = event_assign(&ev, NULL, -1, EV_SIGNAL|EV_READ, dummy_read_cb, NULL);
1707         tt_int_op(r,==,-1);
1708
1709 end:
1710         ;
1711 }
1712
1713 static int reentrant_cb_run = 0;
1714
1715 static void
1716 bad_reentrant_run_loop_cb(evutil_socket_t fd, short what, void *ptr)
1717 {
1718         struct event_base *base = ptr;
1719         int r;
1720         reentrant_cb_run = 1;
1721         /* This reentrant call to event_base_loop should be detected and
1722          * should fail */
1723         r = event_base_loop(base, 0);
1724         tt_int_op(r, ==, -1);
1725 end:
1726         ;
1727 }
1728
1729 static void
1730 test_bad_reentrant(void *ptr)
1731 {
1732         struct basic_test_data *data = ptr;
1733         struct event_base *base = data->base;
1734         struct event ev;
1735         int r;
1736         event_assign(&ev, base, -1,
1737             0, bad_reentrant_run_loop_cb, base);
1738
1739         event_active(&ev, EV_WRITE, 1);
1740         r = event_base_loop(base, 0);
1741         tt_int_op(r, ==, 1);
1742         tt_int_op(reentrant_cb_run, ==, 1);
1743 end:
1744         ;
1745 }
1746
1747 static int n_write_a_byte_cb=0;
1748 static int n_read_and_drain_cb=0;
1749 static int n_activate_other_event_cb=0;
1750 static void
1751 write_a_byte_cb(evutil_socket_t fd, short what, void *arg)
1752 {
1753         char buf[] = "x";
1754         if (write(fd, buf, 1) == 1)
1755                 ++n_write_a_byte_cb;
1756 }
1757 static void
1758 read_and_drain_cb(evutil_socket_t fd, short what, void *arg)
1759 {
1760         char buf[128];
1761         int n;
1762         ++n_read_and_drain_cb;
1763         while ((n = read(fd, buf, sizeof(buf))) > 0)
1764                 ;
1765 }
1766
1767 static void
1768 activate_other_event_cb(evutil_socket_t fd, short what, void *other_)
1769 {
1770         struct event *ev_activate = other_;
1771         ++n_activate_other_event_cb;
1772         event_active_later_(ev_activate, EV_READ);
1773 }
1774
1775 static void
1776 test_active_later(void *ptr)
1777 {
1778         struct basic_test_data *data = ptr;
1779         struct event *ev1 = NULL, *ev2 = NULL;
1780         struct event ev3, ev4;
1781         struct timeval qsec = {0, 100000};
1782         ev1 = event_new(data->base, data->pair[0], EV_READ|EV_PERSIST, read_and_drain_cb, NULL);
1783         ev2 = event_new(data->base, data->pair[1], EV_WRITE|EV_PERSIST, write_a_byte_cb, NULL);
1784         event_assign(&ev3, data->base, -1, 0, activate_other_event_cb, &ev4);
1785         event_assign(&ev4, data->base, -1, 0, activate_other_event_cb, &ev3);
1786         event_add(ev1, NULL);
1787         event_add(ev2, NULL);
1788         event_active_later_(&ev3, EV_READ);
1789
1790         event_base_loopexit(data->base, &qsec);
1791
1792         event_base_loop(data->base, 0);
1793
1794         TT_BLATHER(("%d write calls, %d read calls, %d activate-other calls.",
1795                 n_write_a_byte_cb, n_read_and_drain_cb, n_activate_other_event_cb));
1796         event_del(&ev3);
1797         event_del(&ev4);
1798
1799         tt_int_op(n_write_a_byte_cb, ==, n_activate_other_event_cb);
1800         tt_int_op(n_write_a_byte_cb, >, 100);
1801         tt_int_op(n_read_and_drain_cb, >, 100);
1802         tt_int_op(n_activate_other_event_cb, >, 100);
1803
1804         event_active_later_(&ev4, EV_READ);
1805         event_active(&ev4, EV_READ, 1); /* This should make the event
1806                                            active immediately. */
1807         tt_assert((ev4.ev_flags & EVLIST_ACTIVE) != 0);
1808         tt_assert((ev4.ev_flags & EVLIST_ACTIVE_LATER) == 0);
1809
1810         /* Now leave this one around, so that event_free sees it and removes
1811          * it. */
1812         event_active_later_(&ev3, EV_READ);
1813         event_base_assert_ok_(data->base);
1814
1815 end:
1816         if (ev1)
1817                 event_free(ev1);
1818         if (ev2)
1819                 event_free(ev2);
1820
1821         event_base_free(data->base);
1822         data->base = NULL;
1823 }
1824
1825
1826 static void incr_arg_cb(evutil_socket_t fd, short what, void *arg)
1827 {
1828         int *intptr = arg;
1829         (void) fd; (void) what;
1830         ++*intptr;
1831 }
1832 static void remove_timers_cb(evutil_socket_t fd, short what, void *arg)
1833 {
1834         struct event **ep = arg;
1835         (void) fd; (void) what;
1836         event_remove_timer(ep[0]);
1837         event_remove_timer(ep[1]);
1838 }
1839 static void send_a_byte_cb(evutil_socket_t fd, short what, void *arg)
1840 {
1841         evutil_socket_t *sockp = arg;
1842         (void) fd; (void) what;
1843         (void) write(*sockp, "A", 1);
1844 }
1845 struct read_not_timeout_param
1846 {
1847         struct event **ev;
1848         int events;
1849         int count;
1850 };
1851 static void read_not_timeout_cb(evutil_socket_t fd, short what, void *arg)
1852 {
1853         struct read_not_timeout_param *rntp = arg;
1854         char c;
1855         ev_ssize_t n;
1856         (void) fd; (void) what;
1857         n = read(fd, &c, 1);
1858         tt_int_op(n, ==, 1);
1859         rntp->events |= what;
1860         ++rntp->count;
1861         if(2 == rntp->count) event_del(rntp->ev[0]);
1862 end:
1863         ;
1864 }
1865
1866 static void
1867 test_event_remove_timeout(void *ptr)
1868 {
1869         struct basic_test_data *data = ptr;
1870         struct event_base *base = data->base;
1871         struct event *ev[5];
1872         int ev1_fired=0;
1873         struct timeval ms25 = { 0, 25*1000 },
1874                 ms40 = { 0, 40*1000 },
1875                 ms75 = { 0, 75*1000 },
1876                 ms125 = { 0, 125*1000 };
1877         struct read_not_timeout_param rntp = { ev, 0, 0 };
1878
1879         event_base_assert_ok_(base);
1880
1881         ev[0] = event_new(base, data->pair[0], EV_READ|EV_PERSIST,
1882             read_not_timeout_cb, &rntp);
1883         ev[1] = evtimer_new(base, incr_arg_cb, &ev1_fired);
1884         ev[2] = evtimer_new(base, remove_timers_cb, ev);
1885         ev[3] = evtimer_new(base, send_a_byte_cb, &data->pair[1]);
1886         ev[4] = evtimer_new(base, send_a_byte_cb, &data->pair[1]);
1887         tt_assert(base);
1888         event_add(ev[2], &ms25); /* remove timers */
1889         event_add(ev[4], &ms40); /* write to test if timer re-activates */
1890         event_add(ev[0], &ms75); /* read */
1891         event_add(ev[1], &ms75); /* timer */
1892         event_add(ev[3], &ms125); /* timeout. */
1893         event_base_assert_ok_(base);
1894
1895         event_base_dispatch(base);
1896
1897         tt_int_op(ev1_fired, ==, 0);
1898         tt_int_op(rntp.events, ==, EV_READ);
1899
1900         event_base_assert_ok_(base);
1901 end:
1902         event_free(ev[0]);
1903         event_free(ev[1]);
1904         event_free(ev[2]);
1905         event_free(ev[3]);
1906         event_free(ev[4]);
1907 }
1908
1909 static void
1910 test_event_base_new(void *ptr)
1911 {
1912         struct basic_test_data *data = ptr;
1913         struct event_base *base = 0;
1914         struct event ev1;
1915         struct basic_cb_args args;
1916
1917         int towrite = (int)strlen(TEST1)+1;
1918         int len = write(data->pair[0], TEST1, towrite);
1919
1920         if (len < 0)
1921                 tt_abort_perror("initial write");
1922         else if (len != towrite)
1923                 tt_abort_printf(("initial write fell short (%d of %d bytes)",
1924                                  len, towrite));
1925
1926         if (shutdown(data->pair[0], EVUTIL_SHUT_WR))
1927                 tt_abort_perror("initial write shutdown");
1928
1929         base = event_base_new();
1930         if (!base)
1931                 tt_abort_msg("failed to create event base");
1932
1933         args.eb = base;
1934         args.ev = &ev1;
1935         args.callcount = 0;
1936         event_assign(&ev1, base, data->pair[1],
1937                      EV_READ|EV_PERSIST, basic_read_cb, &args);
1938
1939         if (event_add(&ev1, NULL))
1940                 tt_abort_perror("initial event_add");
1941
1942         if (event_base_loop(base, 0))
1943                 tt_abort_msg("unsuccessful exit from event loop");
1944
1945 end:
1946         if (base)
1947                 event_base_free(base);
1948 }
1949
1950 static void
1951 test_loopexit(void)
1952 {
1953         struct timeval tv, tv_start, tv_end;
1954         struct event ev;
1955
1956         setup_test("Loop exit: ");
1957
1958         tv.tv_usec = 0;
1959         tv.tv_sec = 60*60*24;
1960         evtimer_set(&ev, timeout_cb, NULL);
1961         evtimer_add(&ev, &tv);
1962
1963         tv.tv_usec = 300*1000;
1964         tv.tv_sec = 0;
1965         event_loopexit(&tv);
1966
1967         evutil_gettimeofday(&tv_start, NULL);
1968         event_dispatch();
1969         evutil_gettimeofday(&tv_end, NULL);
1970
1971         evtimer_del(&ev);
1972
1973         tt_assert(event_base_got_exit(global_base));
1974         tt_assert(!event_base_got_break(global_base));
1975
1976         test_timeval_diff_eq(&tv_start, &tv_end, 300);
1977
1978         test_ok = 1;
1979 end:
1980         cleanup_test();
1981 }
1982
1983 static void
1984 test_loopexit_multiple(void)
1985 {
1986         struct timeval tv, tv_start, tv_end;
1987         struct event_base *base;
1988
1989         setup_test("Loop Multiple exit: ");
1990
1991         base = event_base_new();
1992
1993         tv.tv_usec = 200*1000;
1994         tv.tv_sec = 0;
1995         event_base_loopexit(base, &tv);
1996
1997         tv.tv_usec = 0;
1998         tv.tv_sec = 3;
1999         event_base_loopexit(base, &tv);
2000
2001         evutil_gettimeofday(&tv_start, NULL);
2002         event_base_dispatch(base);
2003         evutil_gettimeofday(&tv_end, NULL);
2004
2005         tt_assert(event_base_got_exit(base));
2006         tt_assert(!event_base_got_break(base));
2007
2008         event_base_free(base);
2009
2010         test_timeval_diff_eq(&tv_start, &tv_end, 200);
2011
2012         test_ok = 1;
2013
2014 end:
2015         cleanup_test();
2016 }
2017
2018 static void
2019 break_cb(evutil_socket_t fd, short events, void *arg)
2020 {
2021         test_ok = 1;
2022         event_loopbreak();
2023 }
2024
2025 static void
2026 fail_cb(evutil_socket_t fd, short events, void *arg)
2027 {
2028         test_ok = 0;
2029 }
2030
2031 static void
2032 test_loopbreak(void)
2033 {
2034         struct event ev1, ev2;
2035         struct timeval tv;
2036
2037         setup_test("Loop break: ");
2038
2039         tv.tv_sec = 0;
2040         tv.tv_usec = 0;
2041         evtimer_set(&ev1, break_cb, NULL);
2042         evtimer_add(&ev1, &tv);
2043         evtimer_set(&ev2, fail_cb, NULL);
2044         evtimer_add(&ev2, &tv);
2045
2046         event_dispatch();
2047
2048         tt_assert(!event_base_got_exit(global_base));
2049         tt_assert(event_base_got_break(global_base));
2050
2051         evtimer_del(&ev1);
2052         evtimer_del(&ev2);
2053
2054 end:
2055         cleanup_test();
2056 }
2057
2058 static struct event *readd_test_event_last_added = NULL;
2059 static void
2060 re_add_read_cb(evutil_socket_t fd, short event, void *arg)
2061 {
2062         char buf[256];
2063         struct event *ev_other = arg;
2064         ev_ssize_t n_read;
2065
2066         readd_test_event_last_added = ev_other;
2067
2068         n_read = read(fd, buf, sizeof(buf));
2069
2070         if (n_read < 0) {
2071                 tt_fail_perror("read");
2072                 event_base_loopbreak(event_get_base(ev_other));
2073                 return;
2074         } else {
2075                 event_add(ev_other, NULL);
2076                 ++test_ok;
2077         }
2078 }
2079
2080 static void
2081 test_nonpersist_readd(void)
2082 {
2083         struct event ev1, ev2;
2084
2085         setup_test("Re-add nonpersistent events: ");
2086         event_set(&ev1, pair[0], EV_READ, re_add_read_cb, &ev2);
2087         event_set(&ev2, pair[1], EV_READ, re_add_read_cb, &ev1);
2088
2089         if (write(pair[0], "Hello", 5) < 0) {
2090                 tt_fail_perror("write(pair[0])");
2091         }
2092
2093         if (write(pair[1], "Hello", 5) < 0) {
2094                 tt_fail_perror("write(pair[1])\n");
2095         }
2096
2097         if (event_add(&ev1, NULL) == -1 ||
2098             event_add(&ev2, NULL) == -1) {
2099                 test_ok = 0;
2100         }
2101         if (test_ok != 0)
2102                 exit(1);
2103         event_loop(EVLOOP_ONCE);
2104         if (test_ok != 2)
2105                 exit(1);
2106         /* At this point, we executed both callbacks.  Whichever one got
2107          * called first added the second, but the second then immediately got
2108          * deleted before its callback was called.  At this point, though, it
2109          * re-added the first.
2110          */
2111         if (!readd_test_event_last_added) {
2112                 test_ok = 0;
2113         } else if (readd_test_event_last_added == &ev1) {
2114                 if (!event_pending(&ev1, EV_READ, NULL) ||
2115                     event_pending(&ev2, EV_READ, NULL))
2116                         test_ok = 0;
2117         } else {
2118                 if (event_pending(&ev1, EV_READ, NULL) ||
2119                     !event_pending(&ev2, EV_READ, NULL))
2120                         test_ok = 0;
2121         }
2122
2123         event_del(&ev1);
2124         event_del(&ev2);
2125
2126         cleanup_test();
2127 }
2128
2129 struct test_pri_event {
2130         struct event ev;
2131         int count;
2132 };
2133
2134 static void
2135 test_priorities_cb(evutil_socket_t fd, short what, void *arg)
2136 {
2137         struct test_pri_event *pri = arg;
2138         struct timeval tv;
2139
2140         if (pri->count == 3) {
2141                 event_loopexit(NULL);
2142                 return;
2143         }
2144
2145         pri->count++;
2146
2147         evutil_timerclear(&tv);
2148         event_add(&pri->ev, &tv);
2149 }
2150
2151 static void
2152 test_priorities_impl(int npriorities)
2153 {
2154         struct test_pri_event one, two;
2155         struct timeval tv;
2156
2157         TT_BLATHER(("Testing Priorities %d: ", npriorities));
2158
2159         event_base_priority_init(global_base, npriorities);
2160
2161         memset(&one, 0, sizeof(one));
2162         memset(&two, 0, sizeof(two));
2163
2164         timeout_set(&one.ev, test_priorities_cb, &one);
2165         if (event_priority_set(&one.ev, 0) == -1) {
2166                 fprintf(stderr, "%s: failed to set priority", __func__);
2167                 exit(1);
2168         }
2169
2170         timeout_set(&two.ev, test_priorities_cb, &two);
2171         if (event_priority_set(&two.ev, npriorities - 1) == -1) {
2172                 fprintf(stderr, "%s: failed to set priority", __func__);
2173                 exit(1);
2174         }
2175
2176         evutil_timerclear(&tv);
2177
2178         if (event_add(&one.ev, &tv) == -1)
2179                 exit(1);
2180         if (event_add(&two.ev, &tv) == -1)
2181                 exit(1);
2182
2183         event_dispatch();
2184
2185         event_del(&one.ev);
2186         event_del(&two.ev);
2187
2188         if (npriorities == 1) {
2189                 if (one.count == 3 && two.count == 3)
2190                         test_ok = 1;
2191         } else if (npriorities == 2) {
2192                 /* Two is called once because event_loopexit is priority 1 */
2193                 if (one.count == 3 && two.count == 1)
2194                         test_ok = 1;
2195         } else {
2196                 if (one.count == 3 && two.count == 0)
2197                         test_ok = 1;
2198         }
2199 }
2200
2201 static void
2202 test_priorities(void)
2203 {
2204         test_priorities_impl(1);
2205         if (test_ok)
2206                 test_priorities_impl(2);
2207         if (test_ok)
2208                 test_priorities_impl(3);
2209 }
2210
2211 /* priority-active-inversion: activate a higher-priority event, and make sure
2212  * it keeps us from running a lower-priority event first. */
2213 static int n_pai_calls = 0;
2214 static struct event pai_events[3];
2215
2216 static void
2217 prio_active_inversion_cb(evutil_socket_t fd, short what, void *arg)
2218 {
2219         int *call_order = arg;
2220         *call_order = n_pai_calls++;
2221         if (n_pai_calls == 1) {
2222                 /* This should activate later, even though it shares a
2223                    priority with us. */
2224                 event_active(&pai_events[1], EV_READ, 1);
2225                 /* This should activate next, since its priority is higher,
2226                    even though we activated it second. */
2227                 event_active(&pai_events[2], EV_TIMEOUT, 1);
2228         }
2229 }
2230
2231 static void
2232 test_priority_active_inversion(void *data_)
2233 {
2234         struct basic_test_data *data = data_;
2235         struct event_base *base = data->base;
2236         int call_order[3];
2237         int i;
2238         tt_int_op(event_base_priority_init(base, 8), ==, 0);
2239
2240         n_pai_calls = 0;
2241         memset(call_order, 0, sizeof(call_order));
2242
2243         for (i=0;i<3;++i) {
2244                 event_assign(&pai_events[i], data->base, -1, 0,
2245                     prio_active_inversion_cb, &call_order[i]);
2246         }
2247
2248         event_priority_set(&pai_events[0], 4);
2249         event_priority_set(&pai_events[1], 4);
2250         event_priority_set(&pai_events[2], 0);
2251
2252         event_active(&pai_events[0], EV_WRITE, 1);
2253
2254         event_base_dispatch(base);
2255         tt_int_op(n_pai_calls, ==, 3);
2256         tt_int_op(call_order[0], ==, 0);
2257         tt_int_op(call_order[1], ==, 2);
2258         tt_int_op(call_order[2], ==, 1);
2259 end:
2260         ;
2261 }
2262
2263
2264 static void
2265 test_multiple_cb(evutil_socket_t fd, short event, void *arg)
2266 {
2267         if (event & EV_READ)
2268                 test_ok |= 1;
2269         else if (event & EV_WRITE)
2270                 test_ok |= 2;
2271 }
2272
2273 static void
2274 test_multiple_events_for_same_fd(void)
2275 {
2276    struct event e1, e2;
2277
2278    setup_test("Multiple events for same fd: ");
2279
2280    event_set(&e1, pair[0], EV_READ, test_multiple_cb, NULL);
2281    event_add(&e1, NULL);
2282    event_set(&e2, pair[0], EV_WRITE, test_multiple_cb, NULL);
2283    event_add(&e2, NULL);
2284    event_loop(EVLOOP_ONCE);
2285    event_del(&e2);
2286
2287    if (write(pair[1], TEST1, strlen(TEST1)+1) < 0) {
2288            tt_fail_perror("write");
2289    }
2290
2291    event_loop(EVLOOP_ONCE);
2292    event_del(&e1);
2293
2294    if (test_ok != 3)
2295            test_ok = 0;
2296
2297    cleanup_test();
2298 }
2299
2300 int evtag_decode_int(ev_uint32_t *pnumber, struct evbuffer *evbuf);
2301 int evtag_decode_int64(ev_uint64_t *pnumber, struct evbuffer *evbuf);
2302 int evtag_encode_tag(struct evbuffer *evbuf, ev_uint32_t number);
2303 int evtag_decode_tag(ev_uint32_t *pnumber, struct evbuffer *evbuf);
2304
2305 static void
2306 read_once_cb(evutil_socket_t fd, short event, void *arg)
2307 {
2308         char buf[256];
2309         int len;
2310
2311         len = read(fd, buf, sizeof(buf));
2312
2313         if (called) {
2314                 test_ok = 0;
2315         } else if (len) {
2316                 /* Assumes global pair[0] can be used for writing */
2317                 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
2318                         tt_fail_perror("write");
2319                         test_ok = 0;
2320                 } else {
2321                         test_ok = 1;
2322                 }
2323         }
2324
2325         called++;
2326 }
2327
2328 static void
2329 test_want_only_once(void)
2330 {
2331         struct event ev;
2332         struct timeval tv;
2333
2334         /* Very simple read test */
2335         setup_test("Want read only once: ");
2336
2337         if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
2338                 tt_fail_perror("write");
2339         }
2340
2341         /* Setup the loop termination */
2342         evutil_timerclear(&tv);
2343         tv.tv_usec = 300*1000;
2344         event_loopexit(&tv);
2345
2346         event_set(&ev, pair[1], EV_READ, read_once_cb, &ev);
2347         if (event_add(&ev, NULL) == -1)
2348                 exit(1);
2349         event_dispatch();
2350
2351         cleanup_test();
2352 }
2353
2354 #define TEST_MAX_INT    6
2355
2356 static void
2357 evtag_int_test(void *ptr)
2358 {
2359         struct evbuffer *tmp = evbuffer_new();
2360         ev_uint32_t integers[TEST_MAX_INT] = {
2361                 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
2362         };
2363         ev_uint32_t integer;
2364         ev_uint64_t big_int;
2365         int i;
2366
2367         evtag_init();
2368
2369         for (i = 0; i < TEST_MAX_INT; i++) {
2370                 int oldlen, newlen;
2371                 oldlen = (int)EVBUFFER_LENGTH(tmp);
2372                 evtag_encode_int(tmp, integers[i]);
2373                 newlen = (int)EVBUFFER_LENGTH(tmp);
2374                 TT_BLATHER(("encoded 0x%08x with %d bytes",
2375                         (unsigned)integers[i], newlen - oldlen));
2376                 big_int = integers[i];
2377                 big_int *= 1000000000; /* 1 billion */
2378                 evtag_encode_int64(tmp, big_int);
2379         }
2380
2381         for (i = 0; i < TEST_MAX_INT; i++) {
2382                 tt_int_op(evtag_decode_int(&integer, tmp), !=, -1);
2383                 tt_uint_op(integer, ==, integers[i]);
2384                 tt_int_op(evtag_decode_int64(&big_int, tmp), !=, -1);
2385                 tt_assert((big_int / 1000000000) == integers[i]);
2386         }
2387
2388         tt_uint_op(EVBUFFER_LENGTH(tmp), ==, 0);
2389 end:
2390         evbuffer_free(tmp);
2391 }
2392
2393 static void
2394 evtag_fuzz(void *ptr)
2395 {
2396         unsigned char buffer[4096];
2397         struct evbuffer *tmp = evbuffer_new();
2398         struct timeval tv;
2399         int i, j;
2400
2401         int not_failed = 0;
2402
2403         evtag_init();
2404
2405         for (j = 0; j < 100; j++) {
2406                 for (i = 0; i < (int)sizeof(buffer); i++)
2407                         buffer[i] = test_weakrand();
2408                 evbuffer_drain(tmp, -1);
2409                 evbuffer_add(tmp, buffer, sizeof(buffer));
2410
2411                 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1)
2412                         not_failed++;
2413         }
2414
2415         /* The majority of decodes should fail */
2416         tt_int_op(not_failed, <, 10);
2417
2418         /* Now insert some corruption into the tag length field */
2419         evbuffer_drain(tmp, -1);
2420         evutil_timerclear(&tv);
2421         tv.tv_sec = 1;
2422         evtag_marshal_timeval(tmp, 0, &tv);
2423         evbuffer_add(tmp, buffer, sizeof(buffer));
2424
2425         ((char *)EVBUFFER_DATA(tmp))[1] = '\xff';
2426         if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1) {
2427                 tt_abort_msg("evtag_unmarshal_timeval should have failed");
2428         }
2429
2430 end:
2431         evbuffer_free(tmp);
2432 }
2433
2434 static void
2435 evtag_tag_encoding(void *ptr)
2436 {
2437         struct evbuffer *tmp = evbuffer_new();
2438         ev_uint32_t integers[TEST_MAX_INT] = {
2439                 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
2440         };
2441         ev_uint32_t integer;
2442         int i;
2443
2444         evtag_init();
2445
2446         for (i = 0; i < TEST_MAX_INT; i++) {
2447                 int oldlen, newlen;
2448                 oldlen = (int)EVBUFFER_LENGTH(tmp);
2449                 evtag_encode_tag(tmp, integers[i]);
2450                 newlen = (int)EVBUFFER_LENGTH(tmp);
2451                 TT_BLATHER(("encoded 0x%08x with %d bytes",
2452                         (unsigned)integers[i], newlen - oldlen));
2453         }
2454
2455         for (i = 0; i < TEST_MAX_INT; i++) {
2456                 tt_int_op(evtag_decode_tag(&integer, tmp), !=, -1);
2457                 tt_uint_op(integer, ==, integers[i]);
2458         }
2459
2460         tt_uint_op(EVBUFFER_LENGTH(tmp), ==, 0);
2461
2462 end:
2463         evbuffer_free(tmp);
2464 }
2465
2466 static void
2467 evtag_test_peek(void *ptr)
2468 {
2469         struct evbuffer *tmp = evbuffer_new();
2470         ev_uint32_t u32;
2471
2472         evtag_marshal_int(tmp, 30, 0);
2473         evtag_marshal_string(tmp, 40, "Hello world");
2474
2475         tt_int_op(evtag_peek(tmp, &u32), ==, 1);
2476         tt_int_op(u32, ==, 30);
2477         tt_int_op(evtag_peek_length(tmp, &u32), ==, 0);
2478         tt_int_op(u32, ==, 1+1+1);
2479         tt_int_op(evtag_consume(tmp), ==, 0);
2480
2481         tt_int_op(evtag_peek(tmp, &u32), ==, 1);
2482         tt_int_op(u32, ==, 40);
2483         tt_int_op(evtag_peek_length(tmp, &u32), ==, 0);
2484         tt_int_op(u32, ==, 1+1+11);
2485         tt_int_op(evtag_payload_length(tmp, &u32), ==, 0);
2486         tt_int_op(u32, ==, 11);
2487
2488 end:
2489         evbuffer_free(tmp);
2490 }
2491
2492
2493 static void
2494 test_methods(void *ptr)
2495 {
2496         const char **methods = event_get_supported_methods();
2497         struct event_config *cfg = NULL;
2498         struct event_base *base = NULL;
2499         const char *backend;
2500         int n_methods = 0;
2501
2502         tt_assert(methods);
2503
2504         backend = methods[0];
2505         while (*methods != NULL) {
2506                 TT_BLATHER(("Support method: %s", *methods));
2507                 ++methods;
2508                 ++n_methods;
2509         }
2510
2511         cfg = event_config_new();
2512         assert(cfg != NULL);
2513
2514         tt_int_op(event_config_avoid_method(cfg, backend), ==, 0);
2515         event_config_set_flag(cfg, EVENT_BASE_FLAG_IGNORE_ENV);
2516
2517         base = event_base_new_with_config(cfg);
2518         if (n_methods > 1) {
2519                 tt_assert(base);
2520                 tt_str_op(backend, !=, event_base_get_method(base));
2521         } else {
2522                 tt_assert(base == NULL);
2523         }
2524
2525 end:
2526         if (base)
2527                 event_base_free(base);
2528         if (cfg)
2529                 event_config_free(cfg);
2530 }
2531
2532 static void
2533 test_version(void *arg)
2534 {
2535         const char *vstr;
2536         ev_uint32_t vint;
2537         int major, minor, patch, n;
2538
2539         vstr = event_get_version();
2540         vint = event_get_version_number();
2541
2542         tt_assert(vstr);
2543         tt_assert(vint);
2544
2545         tt_str_op(vstr, ==, LIBEVENT_VERSION);
2546         tt_int_op(vint, ==, LIBEVENT_VERSION_NUMBER);
2547
2548         n = sscanf(vstr, "%d.%d.%d", &major, &minor, &patch);
2549         tt_assert(3 == n);
2550         tt_int_op((vint&0xffffff00), ==, ((major<<24)|(minor<<16)|(patch<<8)));
2551 end:
2552         ;
2553 }
2554
2555 static void
2556 test_base_features(void *arg)
2557 {
2558         struct event_base *base = NULL;
2559         struct event_config *cfg = NULL;
2560
2561         cfg = event_config_new();
2562
2563         tt_assert(0 == event_config_require_features(cfg, EV_FEATURE_ET));
2564
2565         base = event_base_new_with_config(cfg);
2566         if (base) {
2567                 tt_int_op(EV_FEATURE_ET, ==,
2568                     event_base_get_features(base) & EV_FEATURE_ET);
2569         } else {
2570                 base = event_base_new();
2571                 tt_int_op(0, ==, event_base_get_features(base) & EV_FEATURE_ET);
2572         }
2573
2574 end:
2575         if (base)
2576                 event_base_free(base);
2577         if (cfg)
2578                 event_config_free(cfg);
2579 }
2580
2581 #ifdef EVENT__HAVE_SETENV
2582 #define SETENV_OK
2583 #elif !defined(EVENT__HAVE_SETENV) && defined(EVENT__HAVE_PUTENV)
2584 static void setenv(const char *k, const char *v, int o_)
2585 {
2586         char b[256];
2587         evutil_snprintf(b, sizeof(b), "%s=%s",k,v);
2588         putenv(b);
2589 }
2590 #define SETENV_OK
2591 #endif
2592
2593 #ifdef EVENT__HAVE_UNSETENV
2594 #define UNSETENV_OK
2595 #elif !defined(EVENT__HAVE_UNSETENV) && defined(EVENT__HAVE_PUTENV)
2596 static void unsetenv(const char *k)
2597 {
2598         char b[256];
2599         evutil_snprintf(b, sizeof(b), "%s=",k);
2600         putenv(b);
2601 }
2602 #define UNSETENV_OK
2603 #endif
2604
2605 #if defined(SETENV_OK) && defined(UNSETENV_OK)
2606 static void
2607 methodname_to_envvar(const char *mname, char *buf, size_t buflen)
2608 {
2609         char *cp;
2610         evutil_snprintf(buf, buflen, "EVENT_NO%s", mname);
2611         for (cp = buf; *cp; ++cp) {
2612                 *cp = EVUTIL_TOUPPER_(*cp);
2613         }
2614 }
2615 #endif
2616
2617 static void
2618 test_base_environ(void *arg)
2619 {
2620         struct event_base *base = NULL;
2621         struct event_config *cfg = NULL;
2622
2623 #if defined(SETENV_OK) && defined(UNSETENV_OK)
2624         const char **basenames;
2625         int i, n_methods=0;
2626         char varbuf[128];
2627         const char *defaultname, *ignoreenvname;
2628
2629         /* See if unsetenv works before we rely on it. */
2630         setenv("EVENT_NOWAFFLES", "1", 1);
2631         unsetenv("EVENT_NOWAFFLES");
2632         if (getenv("EVENT_NOWAFFLES") != NULL) {
2633 #ifndef EVENT__HAVE_UNSETENV
2634                 TT_DECLARE("NOTE", ("Can't fake unsetenv; skipping test"));
2635 #else
2636                 TT_DECLARE("NOTE", ("unsetenv doesn't work; skipping test"));
2637 #endif
2638                 tt_skip();
2639         }
2640
2641         basenames = event_get_supported_methods();
2642         for (i = 0; basenames[i]; ++i) {
2643                 methodname_to_envvar(basenames[i], varbuf, sizeof(varbuf));
2644                 unsetenv(varbuf);
2645                 ++n_methods;
2646         }
2647
2648         base = event_base_new();
2649         tt_assert(base);
2650
2651         defaultname = event_base_get_method(base);
2652         TT_BLATHER(("default is <%s>", defaultname));
2653         event_base_free(base);
2654         base = NULL;
2655
2656         /* Can we disable the method with EVENT_NOfoo ? */
2657         if (!strcmp(defaultname, "epoll (with changelist)")) {
2658                 setenv("EVENT_NOEPOLL", "1", 1);
2659                 ignoreenvname = "epoll";
2660         } else {
2661                 methodname_to_envvar(defaultname, varbuf, sizeof(varbuf));
2662                 setenv(varbuf, "1", 1);
2663                 ignoreenvname = defaultname;
2664         }
2665
2666         /* Use an empty cfg rather than NULL so a failure doesn't exit() */
2667         cfg = event_config_new();
2668         base = event_base_new_with_config(cfg);
2669         event_config_free(cfg);
2670         cfg = NULL;
2671         if (n_methods == 1) {
2672                 tt_assert(!base);
2673         } else {
2674                 tt_assert(base);
2675                 tt_str_op(defaultname, !=, event_base_get_method(base));
2676                 event_base_free(base);
2677                 base = NULL;
2678         }
2679
2680         /* Can we disable looking at the environment with IGNORE_ENV ? */
2681         cfg = event_config_new();
2682         event_config_set_flag(cfg, EVENT_BASE_FLAG_IGNORE_ENV);
2683         base = event_base_new_with_config(cfg);
2684         tt_assert(base);
2685         tt_str_op(ignoreenvname, ==, event_base_get_method(base));
2686 #else
2687         tt_skip();
2688 #endif
2689
2690 end:
2691         if (base)
2692                 event_base_free(base);
2693         if (cfg)
2694                 event_config_free(cfg);
2695 }
2696
2697 static void
2698 read_called_once_cb(evutil_socket_t fd, short event, void *arg)
2699 {
2700         tt_int_op(event, ==, EV_READ);
2701         called += 1;
2702 end:
2703         ;
2704 }
2705
2706 static void
2707 timeout_called_once_cb(evutil_socket_t fd, short event, void *arg)
2708 {
2709         tt_int_op(event, ==, EV_TIMEOUT);
2710         called += 100;
2711 end:
2712         ;
2713 }
2714
2715 static void
2716 immediate_called_twice_cb(evutil_socket_t fd, short event, void *arg)
2717 {
2718         tt_int_op(event, ==, EV_TIMEOUT);
2719         called += 1000;
2720 end:
2721         ;
2722 }
2723
2724 static void
2725 test_event_once(void *ptr)
2726 {
2727         struct basic_test_data *data = ptr;
2728         struct timeval tv;
2729         int r;
2730
2731         tv.tv_sec = 0;
2732         tv.tv_usec = 50*1000;
2733         called = 0;
2734         r = event_base_once(data->base, data->pair[0], EV_READ,
2735             read_called_once_cb, NULL, NULL);
2736         tt_int_op(r, ==, 0);
2737         r = event_base_once(data->base, -1, EV_TIMEOUT,
2738             timeout_called_once_cb, NULL, &tv);
2739         tt_int_op(r, ==, 0);
2740         r = event_base_once(data->base, -1, 0, NULL, NULL, NULL);
2741         tt_int_op(r, <, 0);
2742         r = event_base_once(data->base, -1, EV_TIMEOUT,
2743             immediate_called_twice_cb, NULL, NULL);
2744         tt_int_op(r, ==, 0);
2745         tv.tv_sec = 0;
2746         tv.tv_usec = 0;
2747         r = event_base_once(data->base, -1, EV_TIMEOUT,
2748             immediate_called_twice_cb, NULL, &tv);
2749         tt_int_op(r, ==, 0);
2750
2751         if (write(data->pair[1], TEST1, strlen(TEST1)+1) < 0) {
2752                 tt_fail_perror("write");
2753         }
2754
2755         shutdown(data->pair[1], EVUTIL_SHUT_WR);
2756
2757         event_base_dispatch(data->base);
2758
2759         tt_int_op(called, ==, 2101);
2760 end:
2761         ;
2762 }
2763
2764 static void
2765 test_event_once_never(void *ptr)
2766 {
2767         struct basic_test_data *data = ptr;
2768         struct timeval tv;
2769
2770         /* Have one trigger in 10 seconds (don't worry, because) */
2771         tv.tv_sec = 10;
2772         tv.tv_usec = 0;
2773         called = 0;
2774         event_base_once(data->base, -1, EV_TIMEOUT,
2775             timeout_called_once_cb, NULL, &tv);
2776
2777         /* But shut down the base in 75 msec. */
2778         tv.tv_sec = 0;
2779         tv.tv_usec = 75*1000;
2780         event_base_loopexit(data->base, &tv);
2781
2782         event_base_dispatch(data->base);
2783
2784         tt_int_op(called, ==, 0);
2785 end:
2786         ;
2787 }
2788
2789 static void
2790 test_event_pending(void *ptr)
2791 {
2792         struct basic_test_data *data = ptr;
2793         struct event *r=NULL, *w=NULL, *t=NULL;
2794         struct timeval tv, now, tv2;
2795
2796         tv.tv_sec = 0;
2797         tv.tv_usec = 500 * 1000;
2798         r = event_new(data->base, data->pair[0], EV_READ, simple_read_cb,
2799             NULL);
2800         w = event_new(data->base, data->pair[1], EV_WRITE, simple_write_cb,
2801             NULL);
2802         t = evtimer_new(data->base, timeout_cb, NULL);
2803
2804         tt_assert(r);
2805         tt_assert(w);
2806         tt_assert(t);
2807
2808         evutil_gettimeofday(&now, NULL);
2809         event_add(r, NULL);
2810         event_add(t, &tv);
2811
2812         tt_assert( event_pending(r, EV_READ, NULL));
2813         tt_assert(!event_pending(w, EV_WRITE, NULL));
2814         tt_assert(!event_pending(r, EV_WRITE, NULL));
2815         tt_assert( event_pending(r, EV_READ|EV_WRITE, NULL));
2816         tt_assert(!event_pending(r, EV_TIMEOUT, NULL));
2817         tt_assert( event_pending(t, EV_TIMEOUT, NULL));
2818         tt_assert( event_pending(t, EV_TIMEOUT, &tv2));
2819
2820         tt_assert(evutil_timercmp(&tv2, &now, >));
2821
2822         test_timeval_diff_eq(&now, &tv2, 500);
2823
2824 end:
2825         if (r) {
2826                 event_del(r);
2827                 event_free(r);
2828         }
2829         if (w) {
2830                 event_del(w);
2831                 event_free(w);
2832         }
2833         if (t) {
2834                 event_del(t);
2835                 event_free(t);
2836         }
2837 }
2838
2839 static void
2840 dfd_cb(evutil_socket_t fd, short e, void *data)
2841 {
2842         *(int*)data = (int)e;
2843 }
2844
2845 static void
2846 test_event_closed_fd_poll(void *arg)
2847 {
2848         struct timeval tv;
2849         struct event *e;
2850         struct basic_test_data *data = (struct basic_test_data *)arg;
2851         int i = 0;
2852
2853         if (strcmp(event_base_get_method(data->base), "poll")) {
2854                 tinytest_set_test_skipped_();
2855                 return;
2856         }
2857
2858         e = event_new(data->base, data->pair[0], EV_READ, dfd_cb, &i);
2859         tt_assert(e);
2860
2861         tv.tv_sec = 0;
2862         tv.tv_usec = 500 * 1000;
2863         event_add(e, &tv);
2864         tt_assert(event_pending(e, EV_READ, NULL));
2865         close(data->pair[0]);
2866         data->pair[0] = -1; /** avoids double-close */
2867         event_base_loop(data->base, EVLOOP_ONCE);
2868         tt_int_op(i, ==, EV_READ);
2869
2870 end:
2871         if (e) {
2872                 event_del(e);
2873                 event_free(e);
2874         }
2875 }
2876
2877 #ifndef _WIN32
2878 /* You can't do this test on windows, since dup2 doesn't work on sockets */
2879
2880 /* Regression test for our workaround for a fun epoll/linux related bug
2881  * where fd2 = dup(fd1); add(fd2); close(fd2); dup2(fd1,fd2); add(fd2)
2882  * will get you an EEXIST */
2883 static void
2884 test_dup_fd(void *arg)
2885 {
2886         struct basic_test_data *data = arg;
2887         struct event_base *base = data->base;
2888         struct event *ev1=NULL, *ev2=NULL;
2889         int fd, dfd=-1;
2890         int ev1_got, ev2_got;
2891
2892         tt_int_op(write(data->pair[0], "Hello world",
2893                 strlen("Hello world")), >, 0);
2894         fd = data->pair[1];
2895
2896         dfd = dup(fd);
2897         tt_int_op(dfd, >=, 0);
2898
2899         ev1 = event_new(base, fd, EV_READ|EV_PERSIST, dfd_cb, &ev1_got);
2900         ev2 = event_new(base, dfd, EV_READ|EV_PERSIST, dfd_cb, &ev2_got);
2901         ev1_got = ev2_got = 0;
2902         event_add(ev1, NULL);
2903         event_add(ev2, NULL);
2904         event_base_loop(base, EVLOOP_ONCE);
2905         tt_int_op(ev1_got, ==, EV_READ);
2906         tt_int_op(ev2_got, ==, EV_READ);
2907
2908         /* Now close and delete dfd then dispatch.  We need to do the
2909          * dispatch here so that when we add it later, we think there
2910          * was an intermediate delete. */
2911         close(dfd);
2912         event_del(ev2);
2913         ev1_got = ev2_got = 0;
2914         event_base_loop(base, EVLOOP_ONCE);
2915         tt_want_int_op(ev1_got, ==, EV_READ);
2916         tt_int_op(ev2_got, ==, 0);
2917
2918         /* Re-duplicate the fd.  We need to get the same duplicated
2919          * value that we closed to provoke the epoll quirk.  Also, we
2920          * need to change the events to write, or else the old lingering
2921          * read event will make the test pass whether the change was
2922          * successful or not. */
2923         tt_int_op(dup2(fd, dfd), ==, dfd);
2924         event_free(ev2);
2925         ev2 = event_new(base, dfd, EV_WRITE|EV_PERSIST, dfd_cb, &ev2_got);
2926         event_add(ev2, NULL);
2927         ev1_got = ev2_got = 0;
2928         event_base_loop(base, EVLOOP_ONCE);
2929         tt_want_int_op(ev1_got, ==, EV_READ);
2930         tt_int_op(ev2_got, ==, EV_WRITE);
2931
2932 end:
2933         if (ev1)
2934                 event_free(ev1);
2935         if (ev2)
2936                 event_free(ev2);
2937         if (dfd >= 0)
2938                 close(dfd);
2939 }
2940 #endif
2941
2942 #ifdef EVENT__DISABLE_MM_REPLACEMENT
2943 static void
2944 test_mm_functions(void *arg)
2945 {
2946         tinytest_set_test_skipped_();
2947 }
2948 #else
2949 static int
2950 check_dummy_mem_ok(void *mem_)
2951 {
2952         char *mem = mem_;
2953         mem -= 16;
2954         return !memcmp(mem, "{[<guardedram>]}", 16);
2955 }
2956
2957 static void *
2958 dummy_malloc(size_t len)
2959 {
2960         char *mem = malloc(len+16);
2961         memcpy(mem, "{[<guardedram>]}", 16);
2962         return mem+16;
2963 }
2964
2965 static void *
2966 dummy_realloc(void *mem_, size_t len)
2967 {
2968         char *mem = mem_;
2969         if (!mem)
2970                 return dummy_malloc(len);
2971         tt_want(check_dummy_mem_ok(mem_));
2972         mem -= 16;
2973         mem = realloc(mem, len+16);
2974         return mem+16;
2975 }
2976
2977 static void
2978 dummy_free(void *mem_)
2979 {
2980         char *mem = mem_;
2981         tt_want(check_dummy_mem_ok(mem_));
2982         mem -= 16;
2983         free(mem);
2984 }
2985
2986 static void
2987 test_mm_functions(void *arg)
2988 {
2989         struct event_base *b = NULL;
2990         struct event_config *cfg = NULL;
2991         event_set_mem_functions(dummy_malloc, dummy_realloc, dummy_free);
2992         cfg = event_config_new();
2993         event_config_avoid_method(cfg, "Nonesuch");
2994         b = event_base_new_with_config(cfg);
2995         tt_assert(b);
2996         tt_assert(check_dummy_mem_ok(b));
2997 end:
2998         if (cfg)
2999                 event_config_free(cfg);
3000         if (b)
3001                 event_base_free(b);
3002 }
3003 #endif
3004
3005 static void
3006 many_event_cb(evutil_socket_t fd, short event, void *arg)
3007 {
3008         int *calledp = arg;
3009         *calledp += 1;
3010 }
3011
3012 static void
3013 test_many_events(void *arg)
3014 {
3015         /* Try 70 events that should all be ready at once.  This will
3016          * exercise the "resize" code on most of the backends, and will make
3017          * sure that we can get past the 64-handle limit of some windows
3018          * functions. */
3019 #define MANY 70
3020
3021         struct basic_test_data *data = arg;
3022         struct event_base *base = data->base;
3023         int one_at_a_time = data->setup_data != NULL;
3024         evutil_socket_t sock[MANY];
3025         struct event *ev[MANY];
3026         int called[MANY];
3027         int i;
3028         int loopflags = EVLOOP_NONBLOCK, evflags=0;
3029         if (one_at_a_time) {
3030                 loopflags |= EVLOOP_ONCE;
3031                 evflags = EV_PERSIST;
3032         }
3033
3034         memset(sock, 0xff, sizeof(sock));
3035         memset(ev, 0, sizeof(ev));
3036         memset(called, 0, sizeof(called));
3037
3038         for (i = 0; i < MANY; ++i) {
3039                 /* We need an event that will hit the backend, and that will
3040                  * be ready immediately.  "Send a datagram" is an easy
3041                  * instance of that. */
3042                 sock[i] = socket(AF_INET, SOCK_DGRAM, 0);
3043                 tt_assert(sock[i] >= 0);
3044                 called[i] = 0;
3045                 ev[i] = event_new(base, sock[i], EV_WRITE|evflags,
3046                     many_event_cb, &called[i]);
3047                 event_add(ev[i], NULL);
3048                 if (one_at_a_time)
3049                         event_base_loop(base, EVLOOP_NONBLOCK|EVLOOP_ONCE);
3050         }
3051
3052         event_base_loop(base, loopflags);
3053
3054         for (i = 0; i < MANY; ++i) {
3055                 if (one_at_a_time)
3056                         tt_int_op(called[i], ==, MANY - i + 1);
3057                 else
3058                         tt_int_op(called[i], ==, 1);
3059         }
3060
3061 end:
3062         for (i = 0; i < MANY; ++i) {
3063                 if (ev[i])
3064                         event_free(ev[i]);
3065                 if (sock[i] >= 0)
3066                         evutil_closesocket(sock[i]);
3067         }
3068 #undef MANY
3069 }
3070
3071 static void
3072 test_struct_event_size(void *arg)
3073 {
3074         tt_int_op(event_get_struct_event_size(), <=, sizeof(struct event));
3075 end:
3076         ;
3077 }
3078
3079 static void
3080 test_get_assignment(void *arg)
3081 {
3082         struct basic_test_data *data = arg;
3083         struct event_base *base = data->base;
3084         struct event *ev1 = NULL;
3085         const char *str = "foo";
3086
3087         struct event_base *b;
3088         evutil_socket_t s;
3089         short what;
3090         event_callback_fn cb;
3091         void *cb_arg;
3092
3093         ev1 = event_new(base, data->pair[1], EV_READ, dummy_read_cb, (void*)str);
3094         event_get_assignment(ev1, &b, &s, &what, &cb, &cb_arg);
3095
3096         tt_ptr_op(b, ==, base);
3097         tt_int_op(s, ==, data->pair[1]);
3098         tt_int_op(what, ==, EV_READ);
3099         tt_ptr_op(cb, ==, dummy_read_cb);
3100         tt_ptr_op(cb_arg, ==, str);
3101
3102         /* Now make sure this doesn't crash. */
3103         event_get_assignment(ev1, NULL, NULL, NULL, NULL, NULL);
3104
3105 end:
3106         if (ev1)
3107                 event_free(ev1);
3108 }
3109
3110 struct foreach_helper {
3111         int count;
3112         const struct event *ev;
3113 };
3114
3115 static int
3116 foreach_count_cb(const struct event_base *base, const struct event *ev, void *arg)
3117 {
3118         struct foreach_helper *h = event_get_callback_arg(ev);
3119         struct timeval *tv = arg;
3120         if (event_get_callback(ev) != timeout_cb)
3121                 return 0;
3122         tt_ptr_op(event_get_base(ev), ==, base);
3123         tt_int_op(tv->tv_sec, ==, 10);
3124         h->ev = ev;
3125         h->count++;
3126         return 0;
3127 end:
3128         return -1;
3129 }
3130
3131 static int
3132 foreach_find_cb(const struct event_base *base, const struct event *ev, void *arg)
3133 {
3134         const struct event **ev_out = arg;
3135         struct foreach_helper *h = event_get_callback_arg(ev);
3136         if (event_get_callback(ev) != timeout_cb)
3137                 return 0;
3138         if (h->count == 99) {
3139                 *ev_out = ev;
3140                 return 101;
3141         }
3142         return 0;
3143 }
3144
3145 static void
3146 test_event_foreach(void *arg)
3147 {
3148         struct basic_test_data *data = arg;
3149         struct event_base *base = data->base;
3150         struct event *ev[5];
3151         struct foreach_helper visited[5];
3152         int i;
3153         struct timeval ten_sec = {10,0};
3154         const struct event *ev_found = NULL;
3155
3156         for (i = 0; i < 5; ++i) {
3157                 visited[i].count = 0;
3158                 visited[i].ev = NULL;
3159                 ev[i] = event_new(base, -1, 0, timeout_cb, &visited[i]);
3160         }
3161
3162         tt_int_op(-1, ==, event_base_foreach_event(NULL, foreach_count_cb, NULL));
3163         tt_int_op(-1, ==, event_base_foreach_event(base, NULL, NULL));
3164
3165         event_add(ev[0], &ten_sec);
3166         event_add(ev[1], &ten_sec);
3167         event_active(ev[1], EV_TIMEOUT, 1);
3168         event_active(ev[2], EV_TIMEOUT, 1);
3169         event_add(ev[3], &ten_sec);
3170         /* Don't touch ev[4]. */
3171
3172         tt_int_op(0, ==, event_base_foreach_event(base, foreach_count_cb,
3173                 &ten_sec));
3174         tt_int_op(1, ==, visited[0].count);
3175         tt_int_op(1, ==, visited[1].count);
3176         tt_int_op(1, ==, visited[2].count);
3177         tt_int_op(1, ==, visited[3].count);
3178         tt_ptr_op(ev[0], ==, visited[0].ev);
3179         tt_ptr_op(ev[1], ==, visited[1].ev);
3180         tt_ptr_op(ev[2], ==, visited[2].ev);
3181         tt_ptr_op(ev[3], ==, visited[3].ev);
3182
3183         visited[2].count = 99;
3184         tt_int_op(101, ==, event_base_foreach_event(base, foreach_find_cb,
3185                 &ev_found));
3186         tt_ptr_op(ev_found, ==, ev[2]);
3187
3188 end:
3189         for (i=0; i<5; ++i) {
3190                 event_free(ev[i]);
3191         }
3192 }
3193
3194 static struct event_base *cached_time_base = NULL;
3195 static int cached_time_reset = 0;
3196 static int cached_time_sleep = 0;
3197 static void
3198 cache_time_cb(evutil_socket_t fd, short what, void *arg)
3199 {
3200         struct timeval *tv = arg;
3201         tt_int_op(0, ==, event_base_gettimeofday_cached(cached_time_base, tv));
3202         if (cached_time_sleep) {
3203                 struct timeval delay = { 0, 30*1000 };
3204                 evutil_usleep_(&delay);
3205         }
3206         if (cached_time_reset) {
3207                 event_base_update_cache_time(cached_time_base);
3208         }
3209 end:
3210         ;
3211 }
3212
3213 static void
3214 test_gettimeofday_cached(void *arg)
3215 {
3216         struct basic_test_data *data = arg;
3217         struct event_config *cfg = NULL;
3218         struct event_base *base = NULL;
3219         struct timeval tv1, tv2, tv3, now;
3220         struct event *ev1=NULL, *ev2=NULL, *ev3=NULL;
3221         int cached_time_disable = strstr(data->setup_data, "disable") != NULL;
3222
3223         cfg = event_config_new();
3224         if (cached_time_disable) {
3225                 event_config_set_flag(cfg, EVENT_BASE_FLAG_NO_CACHE_TIME);
3226         }
3227         cached_time_base = base = event_base_new_with_config(cfg);
3228         tt_assert(base);
3229
3230         /* Try gettimeofday_cached outside of an event loop. */
3231         evutil_gettimeofday(&now, NULL);
3232         tt_int_op(0, ==, event_base_gettimeofday_cached(NULL, &tv1));
3233         tt_int_op(0, ==, event_base_gettimeofday_cached(base, &tv2));
3234         tt_int_op(timeval_msec_diff(&tv1, &tv2), <, 10);
3235         tt_int_op(timeval_msec_diff(&tv1, &now), <, 10);
3236
3237         cached_time_reset = strstr(data->setup_data, "reset") != NULL;
3238         cached_time_sleep = strstr(data->setup_data, "sleep") != NULL;
3239
3240         ev1 = event_new(base, -1, 0, cache_time_cb, &tv1);
3241         ev2 = event_new(base, -1, 0, cache_time_cb, &tv2);
3242         ev3 = event_new(base, -1, 0, cache_time_cb, &tv3);
3243
3244         event_active(ev1, EV_TIMEOUT, 1);
3245         event_active(ev2, EV_TIMEOUT, 1);
3246         event_active(ev3, EV_TIMEOUT, 1);
3247
3248         event_base_dispatch(base);
3249
3250         if (cached_time_reset && cached_time_sleep) {
3251                 tt_int_op(labs(timeval_msec_diff(&tv1,&tv2)), >, 10);
3252                 tt_int_op(labs(timeval_msec_diff(&tv2,&tv3)), >, 10);
3253         } else if (cached_time_disable && cached_time_sleep) {
3254                 tt_int_op(labs(timeval_msec_diff(&tv1,&tv2)), >, 10);
3255                 tt_int_op(labs(timeval_msec_diff(&tv2,&tv3)), >, 10);
3256         } else if (! cached_time_disable) {
3257                 tt_assert(evutil_timercmp(&tv1, &tv2, ==));
3258                 tt_assert(evutil_timercmp(&tv2, &tv3, ==));
3259         }
3260
3261 end:
3262         if (ev1)
3263                 event_free(ev1);
3264         if (ev2)
3265                 event_free(ev2);
3266         if (ev3)
3267                 event_free(ev3);
3268         if (base)
3269                 event_base_free(base);
3270         if (cfg)
3271                 event_config_free(cfg);
3272 }
3273
3274 static void
3275 tabf_cb(evutil_socket_t fd, short what, void *arg)
3276 {
3277         int *ptr = arg;
3278         *ptr = what;
3279         *ptr += 0x10000;
3280 }
3281
3282 static void
3283 test_active_by_fd(void *arg)
3284 {
3285         struct basic_test_data *data = arg;
3286         struct event_base *base = data->base;
3287         struct event *ev1 = NULL, *ev2 = NULL, *ev3 = NULL, *ev4 = NULL;
3288         int e1,e2,e3,e4;
3289 #ifndef _WIN32
3290         struct event *evsig = NULL;
3291         int es;
3292 #endif
3293         struct timeval tenmin = { 600, 0 };
3294
3295         /* Ensure no crash on nonexistent FD. */
3296         event_base_active_by_fd(base, 1000, EV_READ);
3297
3298         /* Ensure no crash on bogus FD. */
3299         event_base_active_by_fd(base, -1, EV_READ);
3300
3301         /* Ensure no crash on nonexistent/bogus signal. */
3302         event_base_active_by_signal(base, 1000);
3303         event_base_active_by_signal(base, -1);
3304
3305         event_base_assert_ok_(base);
3306
3307         e1 = e2 = e3 = e4 = 0;
3308         ev1 = event_new(base, data->pair[0], EV_READ, tabf_cb, &e1);
3309         ev2 = event_new(base, data->pair[0], EV_WRITE, tabf_cb, &e2);
3310         ev3 = event_new(base, data->pair[1], EV_READ, tabf_cb, &e3);
3311         ev4 = event_new(base, data->pair[1], EV_READ, tabf_cb, &e4);
3312         tt_assert(ev1);
3313         tt_assert(ev2);
3314         tt_assert(ev3);
3315         tt_assert(ev4);
3316 #ifndef _WIN32
3317         evsig = event_new(base, SIGHUP, EV_SIGNAL, tabf_cb, &es);
3318         tt_assert(evsig);
3319         event_add(evsig, &tenmin);
3320 #endif
3321
3322         event_add(ev1, &tenmin);
3323         event_add(ev2, NULL);
3324         event_add(ev3, NULL);
3325         event_add(ev4, &tenmin);
3326
3327
3328         event_base_assert_ok_(base);
3329
3330         /* Trigger 2, 3, 4 */
3331         event_base_active_by_fd(base, data->pair[0], EV_WRITE);
3332         event_base_active_by_fd(base, data->pair[1], EV_READ);
3333 #ifndef _WIN32
3334         event_base_active_by_signal(base, SIGHUP);
3335 #endif
3336
3337         event_base_assert_ok_(base);
3338
3339         event_base_loop(base, EVLOOP_ONCE);
3340
3341         tt_int_op(e1, ==, 0);
3342         tt_int_op(e2, ==, EV_WRITE | 0x10000);
3343         tt_int_op(e3, ==, EV_READ | 0x10000);
3344         /* Mask out EV_WRITE here, since it could be genuinely writeable. */
3345         tt_int_op((e4 & ~EV_WRITE), ==, EV_READ | 0x10000);
3346 #ifndef _WIN32
3347         tt_int_op(es, ==, EV_SIGNAL | 0x10000);
3348 #endif
3349
3350 end:
3351         if (ev1)
3352                 event_free(ev1);
3353         if (ev2)
3354                 event_free(ev2);
3355         if (ev3)
3356                 event_free(ev3);
3357         if (ev4)
3358                 event_free(ev4);
3359 #ifndef _WIN32
3360         if (evsig)
3361                 event_free(evsig);
3362 #endif
3363 }
3364
3365 struct testcase_t main_testcases[] = {
3366         /* Some converted-over tests */
3367         { "methods", test_methods, TT_FORK, NULL, NULL },
3368         { "version", test_version, 0, NULL, NULL },
3369         BASIC(base_features, TT_FORK|TT_NO_LOGS),
3370         { "base_environ", test_base_environ, TT_FORK, NULL, NULL },
3371
3372         BASIC(event_base_new, TT_FORK|TT_NEED_SOCKETPAIR),
3373         BASIC(free_active_base, TT_FORK|TT_NEED_SOCKETPAIR),
3374
3375         BASIC(manipulate_active_events, TT_FORK|TT_NEED_BASE),
3376         BASIC(event_new_selfarg, TT_FORK|TT_NEED_BASE),
3377         BASIC(event_assign_selfarg, TT_FORK|TT_NEED_BASE),
3378         BASIC(event_base_get_num_events, TT_FORK|TT_NEED_BASE),
3379         BASIC(event_base_get_max_events, TT_FORK|TT_NEED_BASE),
3380
3381         BASIC(bad_assign, TT_FORK|TT_NEED_BASE|TT_NO_LOGS),
3382         BASIC(bad_reentrant, TT_FORK|TT_NEED_BASE|TT_NO_LOGS),
3383         BASIC(active_later, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR),
3384         BASIC(event_remove_timeout, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR),
3385
3386         /* These are still using the old API */
3387         LEGACY(persistent_timeout, TT_FORK|TT_NEED_BASE),
3388         { "persistent_timeout_jump", test_persistent_timeout_jump, TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
3389         { "persistent_active_timeout", test_persistent_active_timeout,
3390           TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
3391         LEGACY(priorities, TT_FORK|TT_NEED_BASE),
3392         BASIC(priority_active_inversion, TT_FORK|TT_NEED_BASE),
3393         { "common_timeout", test_common_timeout, TT_FORK|TT_NEED_BASE,
3394           &basic_setup, NULL },
3395
3396         /* These legacy tests may not all need all of these flags. */
3397         LEGACY(simpleread, TT_ISOLATED),
3398         LEGACY(simpleread_multiple, TT_ISOLATED),
3399         LEGACY(simplewrite, TT_ISOLATED),
3400         { "simpleclose", test_simpleclose, TT_FORK, &basic_setup,
3401           NULL },
3402         LEGACY(multiple, TT_ISOLATED),
3403         LEGACY(persistent, TT_ISOLATED),
3404         LEGACY(combined, TT_ISOLATED),
3405         LEGACY(simpletimeout, TT_ISOLATED),
3406         LEGACY(loopbreak, TT_ISOLATED),
3407         LEGACY(loopexit, TT_ISOLATED),
3408         LEGACY(loopexit_multiple, TT_ISOLATED),
3409         LEGACY(nonpersist_readd, TT_ISOLATED),
3410         LEGACY(multiple_events_for_same_fd, TT_ISOLATED),
3411         LEGACY(want_only_once, TT_ISOLATED),
3412         { "event_once", test_event_once, TT_ISOLATED, &basic_setup, NULL },
3413         { "event_once_never", test_event_once_never, TT_ISOLATED, &basic_setup, NULL },
3414         { "event_pending", test_event_pending, TT_ISOLATED, &basic_setup,
3415           NULL },
3416         { "event_closed_fd_poll", test_event_closed_fd_poll, TT_ISOLATED, &basic_setup,
3417           NULL },
3418
3419 #ifndef _WIN32
3420         { "dup_fd", test_dup_fd, TT_ISOLATED, &basic_setup, NULL },
3421 #endif
3422         { "mm_functions", test_mm_functions, TT_FORK, NULL, NULL },
3423         { "many_events", test_many_events, TT_ISOLATED, &basic_setup, NULL },
3424         { "many_events_slow_add", test_many_events, TT_ISOLATED, &basic_setup, (void*)1 },
3425
3426         { "struct_event_size", test_struct_event_size, 0, NULL, NULL },
3427         BASIC(get_assignment, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR),
3428
3429         BASIC(event_foreach, TT_FORK|TT_NEED_BASE),
3430         { "gettimeofday_cached", test_gettimeofday_cached, TT_FORK, &basic_setup, (void*)"" },
3431         { "gettimeofday_cached_sleep", test_gettimeofday_cached, TT_FORK, &basic_setup, (void*)"sleep" },
3432         { "gettimeofday_cached_reset", test_gettimeofday_cached, TT_FORK, &basic_setup, (void*)"sleep reset" },
3433         { "gettimeofday_cached_disabled", test_gettimeofday_cached, TT_FORK, &basic_setup, (void*)"sleep disable" },
3434         { "gettimeofday_cached_disabled_nosleep", test_gettimeofday_cached, TT_FORK, &basic_setup, (void*)"disable" },
3435
3436         BASIC(active_by_fd, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR),
3437
3438 #ifndef _WIN32
3439         LEGACY(fork, TT_ISOLATED),
3440 #endif
3441 #ifdef EVENT__HAVE_PTHREADS
3442         /** TODO: support win32 */
3443         LEGACY(del_wait, TT_ISOLATED|TT_NEED_THREADS),
3444 #endif
3445
3446         END_OF_TESTCASES
3447 };
3448
3449 struct testcase_t evtag_testcases[] = {
3450         { "int", evtag_int_test, TT_FORK, NULL, NULL },
3451         { "fuzz", evtag_fuzz, TT_FORK, NULL, NULL },
3452         { "encoding", evtag_tag_encoding, TT_FORK, NULL, NULL },
3453         { "peek", evtag_test_peek, 0, NULL, NULL },
3454
3455         END_OF_TESTCASES
3456 };
3457
3458 struct testcase_t signal_testcases[] = {
3459 #ifndef _WIN32
3460         LEGACY(simplestsignal, TT_ISOLATED),
3461         LEGACY(simplesignal, TT_ISOLATED),
3462         LEGACY(multiplesignal, TT_ISOLATED),
3463         LEGACY(immediatesignal, TT_ISOLATED),
3464         LEGACY(signal_dealloc, TT_ISOLATED),
3465         LEGACY(signal_pipeloss, TT_ISOLATED),
3466         LEGACY(signal_switchbase, TT_ISOLATED|TT_NO_LOGS),
3467         LEGACY(signal_restore, TT_ISOLATED),
3468         LEGACY(signal_assert, TT_ISOLATED),
3469         LEGACY(signal_while_processing, TT_ISOLATED),
3470 #endif
3471         END_OF_TESTCASES
3472 };
3473