2 * Copyright (c) 2003-2007 Niels Provos <provos@citi.umich.edu>
3 * Copyright (c) 2007-2010 Niels Provos and Nick Mathewson
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
33 #include "event2/event-config.h"
35 #include <sys/types.h>
37 #ifdef _EVENT_HAVE_SYS_TIME_H
40 #include <sys/queue.h>
42 #include <sys/socket.h>
57 #include "event2/event.h"
58 #include "event2/event_struct.h"
59 #include "event2/event_compat.h"
60 #include "event2/tag.h"
61 #include "event2/buffer.h"
62 #include "event2/buffer_compat.h"
63 #include "event2/util.h"
64 #include "event-internal.h"
65 #include "evthread-internal.h"
66 #include "util-internal.h"
67 #include "log-internal.h"
72 #include "regress.gen.h"
75 evutil_socket_t pair[2];
78 struct event_base *global_base;
80 static char wbuf[4096];
81 static char rbuf[4096];
84 static int usepersist;
85 static struct timeval tset;
86 static struct timeval tcalled;
89 #define TEST1 "this is a test"
97 #define write(fd,buf,len) send((fd),(buf),(int)(len),0)
98 #define read(fd,buf,len) recv((fd),(buf),(int)(len),0)
103 struct event_base *eb;
105 unsigned int callcount;
109 simple_read_cb(evutil_socket_t fd, short event, void *arg)
114 len = read(fd, buf, sizeof(buf));
118 if (event_add(arg, NULL) == -1)
121 } else if (called == 1)
128 basic_read_cb(evutil_socket_t fd, short event, void *data)
132 struct basic_cb_args *arg = data;
134 len = read(fd, buf, sizeof(buf));
137 tt_fail_perror("read (callback)");
139 switch (arg->callcount++) {
140 case 0: /* first call: expect to read data; cycle */
144 tt_fail_msg("EOF before data read");
147 case 1: /* second call: expect EOF; stop */
149 tt_fail_msg("not all data read on first cycle");
152 default: /* third call: should not happen */
153 tt_fail_msg("too many cycles");
158 event_base_loopexit(arg->eb, NULL);
162 dummy_read_cb(evutil_socket_t fd, short event, void *arg)
167 simple_write_cb(evutil_socket_t fd, short event, void *arg)
171 len = write(fd, TEST1, strlen(TEST1) + 1);
179 multiple_write_cb(evutil_socket_t fd, short event, void *arg)
181 struct event *ev = arg;
185 if (woff + len >= (int)sizeof(wbuf))
186 len = sizeof(wbuf) - woff;
188 len = write(fd, wbuf + woff, len);
190 fprintf(stderr, "%s: write\n", __func__);
198 if (woff >= (int)sizeof(wbuf)) {
199 shutdown(fd, SHUT_WR);
206 if (event_add(ev, NULL) == -1)
212 multiple_read_cb(evutil_socket_t fd, short event, void *arg)
214 struct event *ev = arg;
217 len = read(fd, rbuf + roff, sizeof(rbuf) - roff);
219 fprintf(stderr, "%s: read\n", __func__);
228 if (event_add(ev, NULL) == -1)
234 timeout_cb(evutil_socket_t fd, short event, void *arg)
239 evutil_gettimeofday(&tcalled, NULL);
240 if (evutil_timercmp(&tcalled, &tset, >))
241 evutil_timersub(&tcalled, &tset, &tv);
243 evutil_timersub(&tset, &tcalled, &tv);
245 diff = tv.tv_sec*1000 + tv.tv_usec/1000 - SECONDS * 1000;
259 combined_read_cb(evutil_socket_t fd, short event, void *arg)
261 struct both *both = arg;
265 len = read(fd, buf, sizeof(buf));
267 fprintf(stderr, "%s: read\n", __func__);
272 if (event_add(&both->ev, NULL) == -1)
277 combined_write_cb(evutil_socket_t fd, short event, void *arg)
279 struct both *both = arg;
284 if (len > both->nread)
287 memset(buf, 'q', len);
289 len = write(fd, buf, len);
291 fprintf(stderr, "%s: write\n", __func__);
293 shutdown(fd, SHUT_WR);
298 if (event_add(&both->ev, NULL) == -1)
302 /* These macros used to replicate the work of the legacy test wrapper code */
303 #define setup_test(x) do { \
304 if (!in_legacy_test_wrapper) { \
305 TT_FAIL(("Legacy test %s not wrapped properly", x)); \
309 #define cleanup_test() setup_test("cleanup")
312 test_simpleread(void)
316 /* Very simple read test */
317 setup_test("Simple read: ");
319 write(pair[0], TEST1, strlen(TEST1)+1);
320 shutdown(pair[0], SHUT_WR);
322 event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
323 if (event_add(&ev, NULL) == -1)
331 test_simplewrite(void)
335 /* Very simple write test */
336 setup_test("Simple write: ");
338 event_set(&ev, pair[0], EV_WRITE, simple_write_cb, &ev);
339 if (event_add(&ev, NULL) == -1)
347 simpleread_multiple_cb(evutil_socket_t fd, short event, void *arg)
354 test_simpleread_multiple(void)
356 struct event one, two;
358 /* Very simple read test */
359 setup_test("Simple read to multiple evens: ");
361 write(pair[0], TEST1, strlen(TEST1)+1);
362 shutdown(pair[0], SHUT_WR);
364 event_set(&one, pair[1], EV_READ, simpleread_multiple_cb, NULL);
365 if (event_add(&one, NULL) == -1)
367 event_set(&two, pair[1], EV_READ, simpleread_multiple_cb, NULL);
368 if (event_add(&two, NULL) == -1)
375 static int have_closed = 0;
376 static int premature_event = 0;
378 simpleclose_close_fd_cb(evutil_socket_t s, short what, void *ptr)
380 evutil_socket_t **fds = ptr;
381 TT_BLATHER(("Closing"));
382 evutil_closesocket(*fds[0]);
383 evutil_closesocket(*fds[1]);
390 record_event_cb(evutil_socket_t s, short what, void *ptr)
396 TT_BLATHER(("Recorded %d on socket %d", (int)what, (int)s));
400 test_simpleclose(void *ptr)
402 /* Test that a close of FD is detected as a read and as a write. */
403 struct event_base *base = event_base_new();
404 evutil_socket_t pair1[2]={-1,-1}, pair2[2] = {-1, -1};
405 evutil_socket_t *to_close[2];
406 struct event *rev=NULL, *wev=NULL, *closeev=NULL;
408 short got_read_on_close = 0, got_write_on_close = 0;
410 memset(buf, 99, sizeof(buf));
412 #define LOCAL_SOCKETPAIR_AF AF_INET
414 #define LOCAL_SOCKETPAIR_AF AF_UNIX
416 if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0, pair1)<0)
417 TT_DIE(("socketpair: %s", strerror(errno)));
418 if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0, pair2)<0)
419 TT_DIE(("socketpair: %s", strerror(errno)));
420 if (evutil_make_socket_nonblocking(pair1[1]) < 0)
421 TT_DIE(("make_socket_nonblocking"));
422 if (evutil_make_socket_nonblocking(pair2[1]) < 0)
423 TT_DIE(("make_socket_nonblocking"));
425 /** Stuff pair2[1] full of data, until write fails */
427 int r = write(pair2[1], buf, sizeof(buf));
429 int err = evutil_socket_geterror(pair2[1]);
430 if (! EVUTIL_ERR_RW_RETRIABLE(err))
431 TT_DIE(("write failed strangely: %s",
432 evutil_socket_error_to_string(err)));
436 to_close[0] = &pair1[0];
437 to_close[1] = &pair2[0];
439 closeev = event_new(base, -1, EV_TIMEOUT, simpleclose_close_fd_cb,
441 rev = event_new(base, pair1[1], EV_READ, record_event_cb,
443 TT_BLATHER(("Waiting for read on %d", (int)pair1[1]));
444 wev = event_new(base, pair2[1], EV_WRITE, record_event_cb,
445 &got_write_on_close);
446 TT_BLATHER(("Waiting for write on %d", (int)pair2[1]));
448 tv.tv_usec = 100*1000; /* Close pair1[0] after a little while, and make
449 * sure we get a read event. */
450 event_add(closeev, &tv);
451 event_add(rev, NULL);
452 event_add(wev, NULL);
453 /* Don't let the test go on too long. */
455 tv.tv_usec = 200*1000;
456 event_base_loopexit(base, &tv);
457 event_base_loop(base, 0);
459 tt_int_op(got_read_on_close, ==, EV_READ);
460 tt_int_op(got_write_on_close, ==, EV_WRITE);
461 tt_int_op(premature_event, ==, 0);
465 evutil_closesocket(pair1[0]);
467 evutil_closesocket(pair1[1]);
469 evutil_closesocket(pair2[0]);
471 evutil_closesocket(pair2[1]);
479 event_base_free(base);
486 struct event ev, ev2;
489 /* Multiple read and write test */
490 setup_test("Multiple read/write: ");
491 memset(rbuf, 0, sizeof(rbuf));
492 for (i = 0; i < (int)sizeof(wbuf); i++)
498 event_set(&ev, pair[0], EV_WRITE, multiple_write_cb, &ev);
499 if (event_add(&ev, NULL) == -1)
501 event_set(&ev2, pair[1], EV_READ, multiple_read_cb, &ev2);
502 if (event_add(&ev2, NULL) == -1)
507 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
513 test_persistent(void)
515 struct event ev, ev2;
518 /* Multiple read and write test with persist */
519 setup_test("Persist read/write: ");
520 memset(rbuf, 0, sizeof(rbuf));
521 for (i = 0; i < (int)sizeof(wbuf); i++)
527 event_set(&ev, pair[0], EV_WRITE|EV_PERSIST, multiple_write_cb, &ev);
528 if (event_add(&ev, NULL) == -1)
530 event_set(&ev2, pair[1], EV_READ|EV_PERSIST, multiple_read_cb, &ev2);
531 if (event_add(&ev2, NULL) == -1)
536 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
544 struct both r1, r2, w1, w2;
546 setup_test("Combined read/write: ");
547 memset(&r1, 0, sizeof(r1));
548 memset(&r2, 0, sizeof(r2));
549 memset(&w1, 0, sizeof(w1));
550 memset(&w2, 0, sizeof(w2));
555 event_set(&r1.ev, pair[0], EV_READ, combined_read_cb, &r1);
556 event_set(&w1.ev, pair[0], EV_WRITE, combined_write_cb, &w1);
557 event_set(&r2.ev, pair[1], EV_READ, combined_read_cb, &r2);
558 event_set(&w2.ev, pair[1], EV_WRITE, combined_write_cb, &w2);
559 tt_assert(event_add(&r1.ev, NULL) != -1);
560 tt_assert(!event_add(&w1.ev, NULL));
561 tt_assert(!event_add(&r2.ev, NULL));
562 tt_assert(!event_add(&w2.ev, NULL));
565 if (r1.nread == 8192 && r2.nread == 4096)
573 test_simpletimeout(void)
578 setup_test("Simple timeout: ");
582 evtimer_set(&ev, timeout_cb, NULL);
583 evtimer_add(&ev, &tv);
585 evutil_gettimeofday(&tset, NULL);
592 periodic_timeout_cb(evutil_socket_t fd, short event, void *arg)
598 /* call loopexit only once - on slow machines(?), it is
599 * apparently possible for this to get called twice. */
601 event_base_loopexit(global_base, NULL);
606 test_persistent_timeout(void)
612 evutil_timerclear(&tv);
615 event_assign(&ev, global_base, -1, EV_TIMEOUT|EV_PERSIST,
616 periodic_timeout_cb, &count);
624 struct persist_active_timeout_called {
627 struct timeval tvs[16];
631 activate_cb(evutil_socket_t fd, short event, void *arg)
633 struct event *ev = arg;
634 event_active(ev, EV_READ, 1);
638 persist_active_timeout_cb(evutil_socket_t fd, short event, void *arg)
640 struct persist_active_timeout_called *c = arg;
642 c->events[c->n] = event;
643 evutil_gettimeofday(&c->tvs[c->n], NULL);
649 test_persistent_active_timeout(void *ptr)
651 struct timeval tv, tv2, tv_exit, start;
653 struct persist_active_timeout_called res;
655 struct basic_test_data *data = ptr;
656 struct event_base *base = data->base;
658 memset(&res, 0, sizeof(res));
661 tv.tv_usec = 200 * 1000;
662 event_assign(&ev, base, -1, EV_TIMEOUT|EV_PERSIST,
663 persist_active_timeout_cb, &res);
667 tv2.tv_usec = 100 * 1000;
668 event_base_once(base, -1, EV_TIMEOUT, activate_cb, &ev, &tv2);
671 tv_exit.tv_usec = 600 * 1000;
672 event_base_loopexit(base, &tv_exit);
674 evutil_gettimeofday(&start, NULL);
676 event_base_dispatch(base);
678 tt_int_op(res.n, ==, 3);
679 tt_int_op(res.events[0], ==, EV_READ);
680 tt_int_op(res.events[1], ==, EV_TIMEOUT);
681 tt_int_op(res.events[2], ==, EV_TIMEOUT);
682 test_timeval_diff_eq(&start, &res.tvs[0], 100);
683 test_timeval_diff_eq(&start, &res.tvs[1], 300);
684 test_timeval_diff_eq(&start, &res.tvs[2], 500);
689 struct common_timeout_info {
691 struct timeval called_at;
697 common_timeout_cb(evutil_socket_t fd, short event, void *arg)
699 struct common_timeout_info *ti = arg;
701 evutil_gettimeofday(&ti->called_at, NULL);
707 test_common_timeout(void *ptr)
709 struct basic_test_data *data = ptr;
711 struct event_base *base = data->base;
713 struct common_timeout_info info[100];
716 struct timeval tmp_100_ms = { 0, 100*1000 };
717 struct timeval tmp_200_ms = { 0, 200*1000 };
719 const struct timeval *ms_100, *ms_200;
721 ms_100 = event_base_init_common_timeout(base, &tmp_100_ms);
722 ms_200 = event_base_init_common_timeout(base, &tmp_200_ms);
725 tt_ptr_op(event_base_init_common_timeout(base, &tmp_200_ms),
727 tt_int_op(ms_100->tv_sec, ==, 0);
728 tt_int_op(ms_200->tv_sec, ==, 0);
729 tt_int_op(ms_100->tv_usec, ==, 100000|0x50000000);
730 tt_int_op(ms_200->tv_usec, ==, 200000|0x50100000);
732 memset(info, 0, sizeof(info));
734 for (i=0; i<100; ++i) {
736 event_assign(&info[i].ev, base, -1, EV_TIMEOUT|EV_PERSIST,
737 common_timeout_cb, &info[i]);
739 event_add(&info[i].ev, ms_100);
741 event_add(&info[i].ev, ms_200);
745 event_base_dispatch(base);
747 evutil_gettimeofday(&now, NULL);
749 for (i=0; i<10; ++i) {
752 tt_int_op(info[i].count, ==, 6);
753 evutil_timersub(&now, &info[i].called_at, &tmp);
754 ms_diff = tmp.tv_usec/1000 + tmp.tv_sec*1000;
756 tt_int_op(ms_diff, >, 500);
757 tt_int_op(ms_diff, <, 700);
759 tt_int_op(ms_diff, >, -100);
760 tt_int_op(ms_diff, <, 100);
764 /* Make sure we can free the base with some events in. */
765 for (i=0; i<100; ++i) {
767 event_add(&info[i].ev, ms_100);
769 event_add(&info[i].ev, ms_200);
774 event_base_free(data->base); /* need to do this here before info is
780 static void signal_cb(evutil_socket_t fd, short event, void *arg);
782 #define current_base event_global_current_base_
783 extern struct event_base *current_base;
786 child_signal_cb(evutil_socket_t fd, short event, void *arg)
801 int status, got_sigchld = 0;
802 struct event ev, sig_ev;
805 setup_test("After fork: ");
807 tt_assert(current_base);
808 evthread_make_base_notifiable(current_base);
810 write(pair[0], TEST1, strlen(TEST1)+1);
812 event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
813 if (event_add(&ev, NULL) == -1)
816 evsignal_set(&sig_ev, SIGCHLD, child_signal_cb, &got_sigchld);
817 evsignal_add(&sig_ev, NULL);
819 if ((pid = fork()) == 0) {
821 if (event_reinit(current_base) == -1) {
822 fprintf(stdout, "FAILED (reinit)\n");
826 evsignal_del(&sig_ev);
832 event_base_free(current_base);
834 /* we do not send an EOF; simple_read_cb requires an EOF
835 * to set test_ok. we just verify that the callback was
837 exit(test_ok != 0 || called != 2 ? -2 : 76);
840 /* wait for the child to read the data */
843 write(pair[0], TEST1, strlen(TEST1)+1);
845 if (waitpid(pid, &status, 0) == -1) {
846 fprintf(stdout, "FAILED (fork)\n");
850 if (WEXITSTATUS(status) != 76) {
851 fprintf(stdout, "FAILED (exit): %d\n", WEXITSTATUS(status));
855 /* test that the current event loop still works */
856 write(pair[0], TEST1, strlen(TEST1)+1);
857 shutdown(pair[0], SHUT_WR);
862 fprintf(stdout, "FAILED (sigchld)\n");
866 evsignal_del(&sig_ev);
873 signal_cb_sa(int sig)
879 signal_cb(evutil_socket_t fd, short event, void *arg)
881 struct event *ev = arg;
888 test_simplesignal(void)
891 struct itimerval itv;
893 setup_test("Simple signal: ");
894 evsignal_set(&ev, SIGALRM, signal_cb, &ev);
895 evsignal_add(&ev, NULL);
896 /* find bugs in which operations are re-ordered */
898 evsignal_add(&ev, NULL);
900 memset(&itv, 0, sizeof(itv));
901 itv.it_value.tv_sec = 1;
902 if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
903 goto skip_simplesignal;
907 if (evsignal_del(&ev) == -1)
914 test_multiplesignal(void)
916 struct event ev_one, ev_two;
917 struct itimerval itv;
919 setup_test("Multiple signal: ");
921 evsignal_set(&ev_one, SIGALRM, signal_cb, &ev_one);
922 evsignal_add(&ev_one, NULL);
924 evsignal_set(&ev_two, SIGALRM, signal_cb, &ev_two);
925 evsignal_add(&ev_two, NULL);
927 memset(&itv, 0, sizeof(itv));
928 itv.it_value.tv_sec = 1;
929 if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
930 goto skip_simplesignal;
935 if (evsignal_del(&ev_one) == -1)
937 if (evsignal_del(&ev_two) == -1)
944 test_immediatesignal(void)
949 evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
950 evsignal_add(&ev, NULL);
952 event_loop(EVLOOP_NONBLOCK);
958 test_signal_dealloc(void)
960 /* make sure that evsignal_event is event_del'ed and pipe closed */
962 struct event_base *base = event_init();
963 evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
964 evsignal_add(&ev, NULL);
966 event_base_free(base);
967 /* If we got here without asserting, we're fine. */
973 test_signal_pipeloss(void)
975 /* make sure that the base1 pipe is closed correctly. */
976 struct event_base *base1, *base2;
979 base1 = event_init();
980 pipe1 = base1->sig.ev_signal_pair[0];
981 base2 = event_init();
982 event_base_free(base2);
983 event_base_free(base1);
984 if (close(pipe1) != -1 || errno!=EBADF) {
985 /* fd must be closed, so second close gives -1, EBADF */
986 printf("signal pipe not closed. ");
995 * make two bases to catch signals, use both of them. this only works
996 * for event mechanisms that use our signal pipe trick. kqueue handles
997 * signals internally, and all interested kqueues get all the signals.
1000 test_signal_switchbase(void)
1002 struct event ev1, ev2;
1003 struct event_base *base1, *base2;
1006 base1 = event_init();
1007 base2 = event_init();
1008 is_kqueue = !strcmp(event_get_method(),"kqueue");
1009 evsignal_set(&ev1, SIGUSR1, signal_cb, &ev1);
1010 evsignal_set(&ev2, SIGUSR1, signal_cb, &ev2);
1011 if (event_base_set(base1, &ev1) ||
1012 event_base_set(base2, &ev2) ||
1013 event_add(&ev1, NULL) ||
1014 event_add(&ev2, NULL)) {
1015 fprintf(stderr, "%s: cannot set base, add\n", __func__);
1019 tt_ptr_op(event_get_base(&ev1), ==, base1);
1020 tt_ptr_op(event_get_base(&ev2), ==, base2);
1023 /* can handle signal before loop is called */
1025 event_base_loop(base2, EVLOOP_NONBLOCK);
1031 event_base_loop(base1, EVLOOP_NONBLOCK);
1032 if (test_ok && !is_kqueue) {
1035 /* set base1 to handle signals */
1036 event_base_loop(base1, EVLOOP_NONBLOCK);
1038 event_base_loop(base1, EVLOOP_NONBLOCK);
1039 event_base_loop(base2, EVLOOP_NONBLOCK);
1042 event_base_free(base1);
1043 event_base_free(base2);
1048 * assert that a signal event removed from the event queue really is
1049 * removed - with no possibility of it's parent handler being fired.
1052 test_signal_assert(void)
1055 struct event_base *base = event_init();
1057 /* use SIGCONT so we don't kill ourselves when we signal to nowhere */
1058 evsignal_set(&ev, SIGCONT, signal_cb, &ev);
1059 evsignal_add(&ev, NULL);
1061 * if evsignal_del() fails to reset the handler, it's current handler
1062 * will still point to evsig_handler().
1068 /* only way to verify we were in evsig_handler() */
1069 /* XXXX Now there's no longer a good way. */
1070 if (base->sig.evsig_caught)
1078 event_base_free(base);
1084 * assert that we restore our previous signal handler properly.
1087 test_signal_restore(void)
1090 struct event_base *base = event_init();
1091 #ifdef _EVENT_HAVE_SIGACTION
1092 struct sigaction sa;
1096 #ifdef _EVENT_HAVE_SIGACTION
1097 sa.sa_handler = signal_cb_sa;
1099 sigemptyset(&sa.sa_mask);
1100 if (sigaction(SIGUSR1, &sa, NULL) == -1)
1103 if (signal(SIGUSR1, signal_cb_sa) == SIG_ERR)
1106 evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
1107 evsignal_add(&ev, NULL);
1111 /* 1 == signal_cb, 2 == signal_cb_sa, we want our previous handler */
1115 event_base_free(base);
1121 signal_cb_swp(int sig, short event, void *arg)
1127 event_loopexit(NULL);
1130 timeout_cb_swp(evutil_socket_t fd, short event, void *arg)
1133 struct timeval tv = {5, 0};
1136 evtimer_add((struct event *)arg, &tv);
1141 event_loopexit(NULL);
1145 test_signal_while_processing(void)
1147 struct event_base *base = event_init();
1148 struct event ev, ev_timer;
1149 struct timeval tv = {0, 0};
1151 setup_test("Receiving a signal while processing other signal: ");
1155 signal_set(&ev, SIGUSR1, signal_cb_swp, NULL);
1156 signal_add(&ev, NULL);
1157 evtimer_set(&ev_timer, timeout_cb_swp, &ev_timer);
1158 evtimer_add(&ev_timer, &tv);
1161 event_base_free(base);
1168 test_free_active_base(void *ptr)
1170 struct basic_test_data *data = ptr;
1171 struct event_base *base1;
1174 base1 = event_init();
1176 event_assign(&ev1, base1, data->pair[1], EV_READ,
1177 dummy_read_cb, NULL);
1178 event_add(&ev1, NULL);
1179 event_base_free(base1); /* should not crash */
1181 tt_fail_msg("failed to create event_base for test");
1184 base1 = event_init();
1186 event_assign(&ev1, base1, 0, 0, dummy_read_cb, NULL);
1187 event_active(&ev1, EV_READ, 1);
1188 event_base_free(base1);
1194 test_manipulate_active_events(void *ptr)
1196 struct basic_test_data *data = ptr;
1197 struct event_base *base = data->base;
1200 event_assign(&ev1, base, -1, EV_TIMEOUT, dummy_read_cb, NULL);
1202 /* Make sure an active event is pending. */
1203 event_active(&ev1, EV_READ, 1);
1204 tt_int_op(event_pending(&ev1, EV_READ|EV_TIMEOUT|EV_WRITE, NULL),
1207 /* Make sure that activating an event twice works. */
1208 event_active(&ev1, EV_WRITE, 1);
1209 tt_int_op(event_pending(&ev1, EV_READ|EV_TIMEOUT|EV_WRITE, NULL),
1210 ==, EV_READ|EV_WRITE);
1217 test_bad_assign(void *ptr)
1221 /* READ|SIGNAL is not allowed */
1222 r = event_assign(&ev, NULL, -1, EV_SIGNAL|EV_READ, dummy_read_cb, NULL);
1229 static int reentrant_cb_run = 0;
1232 bad_reentrant_run_loop_cb(evutil_socket_t fd, short what, void *ptr)
1234 struct event_base *base = ptr;
1236 reentrant_cb_run = 1;
1237 /* This reentrant call to event_base_loop should be detected and
1239 r = event_base_loop(base, 0);
1240 tt_int_op(r, ==, -1);
1246 test_bad_reentrant(void *ptr)
1248 struct basic_test_data *data = ptr;
1249 struct event_base *base = data->base;
1252 event_assign(&ev, base, -1,
1253 0, bad_reentrant_run_loop_cb, base);
1255 event_active(&ev, EV_WRITE, 1);
1256 r = event_base_loop(base, 0);
1257 tt_int_op(r, ==, 1);
1258 tt_int_op(reentrant_cb_run, ==, 1);
1264 test_event_base_new(void *ptr)
1266 struct basic_test_data *data = ptr;
1267 struct event_base *base = 0;
1269 struct basic_cb_args args;
1271 int towrite = (int)strlen(TEST1)+1;
1272 int len = write(data->pair[0], TEST1, towrite);
1275 tt_abort_perror("initial write");
1276 else if (len != towrite)
1277 tt_abort_printf(("initial write fell short (%d of %d bytes)",
1280 if (shutdown(data->pair[0], SHUT_WR))
1281 tt_abort_perror("initial write shutdown");
1283 base = event_base_new();
1285 tt_abort_msg("failed to create event base");
1290 event_assign(&ev1, base, data->pair[1],
1291 EV_READ|EV_PERSIST, basic_read_cb, &args);
1293 if (event_add(&ev1, NULL))
1294 tt_abort_perror("initial event_add");
1296 if (event_base_loop(base, 0))
1297 tt_abort_msg("unsuccessful exit from event loop");
1301 event_base_free(base);
1307 struct timeval tv, tv_start, tv_end;
1310 setup_test("Loop exit: ");
1313 tv.tv_sec = 60*60*24;
1314 evtimer_set(&ev, timeout_cb, NULL);
1315 evtimer_add(&ev, &tv);
1319 event_loopexit(&tv);
1321 evutil_gettimeofday(&tv_start, NULL);
1323 evutil_gettimeofday(&tv_end, NULL);
1324 evutil_timersub(&tv_end, &tv_start, &tv_end);
1328 tt_assert(event_base_got_exit(global_base));
1329 tt_assert(!event_base_got_break(global_base));
1339 test_loopexit_multiple(void)
1342 struct event_base *base;
1344 setup_test("Loop Multiple exit: ");
1346 base = event_base_new();
1350 event_base_loopexit(base, &tv);
1354 event_base_loopexit(base, &tv);
1356 event_base_dispatch(base);
1358 tt_assert(event_base_got_exit(base));
1359 tt_assert(!event_base_got_break(base));
1361 event_base_free(base);
1370 break_cb(evutil_socket_t fd, short events, void *arg)
1377 fail_cb(evutil_socket_t fd, short events, void *arg)
1383 test_loopbreak(void)
1385 struct event ev1, ev2;
1388 setup_test("Loop break: ");
1392 evtimer_set(&ev1, break_cb, NULL);
1393 evtimer_add(&ev1, &tv);
1394 evtimer_set(&ev2, fail_cb, NULL);
1395 evtimer_add(&ev2, &tv);
1399 tt_assert(!event_base_got_exit(global_base));
1400 tt_assert(event_base_got_break(global_base));
1409 static struct event *readd_test_event_last_added = NULL;
1411 re_add_read_cb(evutil_socket_t fd, short event, void *arg)
1414 struct event *ev_other = arg;
1415 readd_test_event_last_added = ev_other;
1416 (void) read(fd, buf, sizeof(buf));
1417 event_add(ev_other, NULL);
1422 test_nonpersist_readd(void)
1424 struct event ev1, ev2;
1426 setup_test("Re-add nonpersistent events: ");
1427 event_set(&ev1, pair[0], EV_READ, re_add_read_cb, &ev2);
1428 event_set(&ev2, pair[1], EV_READ, re_add_read_cb, &ev1);
1429 (void) write(pair[0], "Hello", 5);
1430 (void) write(pair[1], "Hello", 5);
1431 if (event_add(&ev1, NULL) == -1 ||
1432 event_add(&ev2, NULL) == -1) {
1437 event_loop(EVLOOP_ONCE);
1440 /* At this point, we executed both callbacks. Whichever one got
1441 * called first added the second, but the second then immediately got
1442 * deleted before its callback was called. At this point, though, it
1443 * re-added the first.
1445 if (!readd_test_event_last_added) {
1447 } else if (readd_test_event_last_added == &ev1) {
1448 if (!event_pending(&ev1, EV_READ, NULL) ||
1449 event_pending(&ev2, EV_READ, NULL))
1452 if (event_pending(&ev1, EV_READ, NULL) ||
1453 !event_pending(&ev2, EV_READ, NULL))
1463 struct test_pri_event {
1469 test_priorities_cb(evutil_socket_t fd, short what, void *arg)
1471 struct test_pri_event *pri = arg;
1474 if (pri->count == 3) {
1475 event_loopexit(NULL);
1481 evutil_timerclear(&tv);
1482 event_add(&pri->ev, &tv);
1486 test_priorities_impl(int npriorities)
1488 struct test_pri_event one, two;
1491 TT_BLATHER(("Testing Priorities %d: ", npriorities));
1493 event_base_priority_init(global_base, npriorities);
1495 memset(&one, 0, sizeof(one));
1496 memset(&two, 0, sizeof(two));
1498 timeout_set(&one.ev, test_priorities_cb, &one);
1499 if (event_priority_set(&one.ev, 0) == -1) {
1500 fprintf(stderr, "%s: failed to set priority", __func__);
1504 timeout_set(&two.ev, test_priorities_cb, &two);
1505 if (event_priority_set(&two.ev, npriorities - 1) == -1) {
1506 fprintf(stderr, "%s: failed to set priority", __func__);
1510 evutil_timerclear(&tv);
1512 if (event_add(&one.ev, &tv) == -1)
1514 if (event_add(&two.ev, &tv) == -1)
1522 if (npriorities == 1) {
1523 if (one.count == 3 && two.count == 3)
1525 } else if (npriorities == 2) {
1526 /* Two is called once because event_loopexit is priority 1 */
1527 if (one.count == 3 && two.count == 1)
1530 if (one.count == 3 && two.count == 0)
1536 test_priorities(void)
1538 test_priorities_impl(1);
1540 test_priorities_impl(2);
1542 test_priorities_impl(3);
1547 test_multiple_cb(evutil_socket_t fd, short event, void *arg)
1549 if (event & EV_READ)
1551 else if (event & EV_WRITE)
1556 test_multiple_events_for_same_fd(void)
1558 struct event e1, e2;
1560 setup_test("Multiple events for same fd: ");
1562 event_set(&e1, pair[0], EV_READ, test_multiple_cb, NULL);
1563 event_add(&e1, NULL);
1564 event_set(&e2, pair[0], EV_WRITE, test_multiple_cb, NULL);
1565 event_add(&e2, NULL);
1566 event_loop(EVLOOP_ONCE);
1568 write(pair[1], TEST1, strlen(TEST1)+1);
1569 event_loop(EVLOOP_ONCE);
1578 int evtag_decode_int(ev_uint32_t *pnumber, struct evbuffer *evbuf);
1579 int evtag_decode_int64(ev_uint64_t *pnumber, struct evbuffer *evbuf);
1580 int evtag_encode_tag(struct evbuffer *evbuf, ev_uint32_t number);
1581 int evtag_decode_tag(ev_uint32_t *pnumber, struct evbuffer *evbuf);
1584 read_once_cb(evutil_socket_t fd, short event, void *arg)
1589 len = read(fd, buf, sizeof(buf));
1594 /* Assumes global pair[0] can be used for writing */
1595 write(pair[0], TEST1, strlen(TEST1)+1);
1603 test_want_only_once(void)
1608 /* Very simple read test */
1609 setup_test("Want read only once: ");
1611 write(pair[0], TEST1, strlen(TEST1)+1);
1613 /* Setup the loop termination */
1614 evutil_timerclear(&tv);
1616 event_loopexit(&tv);
1618 event_set(&ev, pair[1], EV_READ, read_once_cb, &ev);
1619 if (event_add(&ev, NULL) == -1)
1626 #define TEST_MAX_INT 6
1629 evtag_int_test(void *ptr)
1631 struct evbuffer *tmp = evbuffer_new();
1632 ev_uint32_t integers[TEST_MAX_INT] = {
1633 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1635 ev_uint32_t integer;
1636 ev_uint64_t big_int;
1641 for (i = 0; i < TEST_MAX_INT; i++) {
1643 oldlen = (int)EVBUFFER_LENGTH(tmp);
1644 evtag_encode_int(tmp, integers[i]);
1645 newlen = (int)EVBUFFER_LENGTH(tmp);
1646 TT_BLATHER(("encoded 0x%08x with %d bytes",
1647 (unsigned)integers[i], newlen - oldlen));
1648 big_int = integers[i];
1649 big_int *= 1000000000; /* 1 billion */
1650 evtag_encode_int64(tmp, big_int);
1653 for (i = 0; i < TEST_MAX_INT; i++) {
1654 tt_int_op(evtag_decode_int(&integer, tmp), !=, -1);
1655 tt_uint_op(integer, ==, integers[i]);
1656 tt_int_op(evtag_decode_int64(&big_int, tmp), !=, -1);
1657 tt_assert((big_int / 1000000000) == integers[i]);
1660 tt_uint_op(EVBUFFER_LENGTH(tmp), ==, 0);
1666 evtag_fuzz(void *ptr)
1668 u_char buffer[4096];
1669 struct evbuffer *tmp = evbuffer_new();
1677 for (j = 0; j < 100; j++) {
1678 for (i = 0; i < (int)sizeof(buffer); i++)
1680 evbuffer_drain(tmp, -1);
1681 evbuffer_add(tmp, buffer, sizeof(buffer));
1683 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1)
1687 /* The majority of decodes should fail */
1688 tt_int_op(not_failed, <, 10);
1690 /* Now insert some corruption into the tag length field */
1691 evbuffer_drain(tmp, -1);
1692 evutil_timerclear(&tv);
1694 evtag_marshal_timeval(tmp, 0, &tv);
1695 evbuffer_add(tmp, buffer, sizeof(buffer));
1697 ((char *)EVBUFFER_DATA(tmp))[1] = '\xff';
1698 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1) {
1699 tt_abort_msg("evtag_unmarshal_timeval should have failed");
1707 evtag_tag_encoding(void *ptr)
1709 struct evbuffer *tmp = evbuffer_new();
1710 ev_uint32_t integers[TEST_MAX_INT] = {
1711 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1713 ev_uint32_t integer;
1718 for (i = 0; i < TEST_MAX_INT; i++) {
1720 oldlen = (int)EVBUFFER_LENGTH(tmp);
1721 evtag_encode_tag(tmp, integers[i]);
1722 newlen = (int)EVBUFFER_LENGTH(tmp);
1723 TT_BLATHER(("encoded 0x%08x with %d bytes",
1724 (unsigned)integers[i], newlen - oldlen));
1727 for (i = 0; i < TEST_MAX_INT; i++) {
1728 tt_int_op(evtag_decode_tag(&integer, tmp), !=, -1);
1729 tt_uint_op(integer, ==, integers[i]);
1732 tt_uint_op(EVBUFFER_LENGTH(tmp), ==, 0);
1739 evtag_test_peek(void *ptr)
1741 struct evbuffer *tmp = evbuffer_new();
1744 evtag_marshal_int(tmp, 30, 0);
1745 evtag_marshal_string(tmp, 40, "Hello world");
1747 tt_int_op(evtag_peek(tmp, &u32), ==, 1);
1748 tt_int_op(u32, ==, 30);
1749 tt_int_op(evtag_peek_length(tmp, &u32), ==, 0);
1750 tt_int_op(u32, ==, 1+1+1);
1751 tt_int_op(evtag_consume(tmp), ==, 0);
1753 tt_int_op(evtag_peek(tmp, &u32), ==, 1);
1754 tt_int_op(u32, ==, 40);
1755 tt_int_op(evtag_peek_length(tmp, &u32), ==, 0);
1756 tt_int_op(u32, ==, 1+1+11);
1757 tt_int_op(evtag_payload_length(tmp, &u32), ==, 0);
1758 tt_int_op(u32, ==, 11);
1766 test_methods(void *ptr)
1768 const char **methods = event_get_supported_methods();
1769 struct event_config *cfg = NULL;
1770 struct event_base *base = NULL;
1771 const char *backend;
1776 backend = methods[0];
1777 while (*methods != NULL) {
1778 TT_BLATHER(("Support method: %s", *methods));
1783 cfg = event_config_new();
1784 assert(cfg != NULL);
1786 tt_int_op(event_config_avoid_method(cfg, backend), ==, 0);
1787 event_config_set_flag(cfg, EVENT_BASE_FLAG_IGNORE_ENV);
1789 base = event_base_new_with_config(cfg);
1790 if (n_methods > 1) {
1792 tt_str_op(backend, !=, event_base_get_method(base));
1794 tt_assert(base == NULL);
1799 event_base_free(base);
1801 event_config_free(cfg);
1805 test_version(void *arg)
1809 int major, minor, patch, n;
1811 vstr = event_get_version();
1812 vint = event_get_version_number();
1817 tt_str_op(vstr, ==, LIBEVENT_VERSION);
1818 tt_int_op(vint, ==, LIBEVENT_VERSION_NUMBER);
1820 n = sscanf(vstr, "%d.%d.%d", &major, &minor, &patch);
1822 tt_int_op((vint&0xffffff00), ==, ((major<<24)|(minor<<16)|(patch<<8)));
1828 test_base_features(void *arg)
1830 struct event_base *base = NULL;
1831 struct event_config *cfg = NULL;
1833 cfg = event_config_new();
1835 tt_assert(0 == event_config_require_features(cfg, EV_FEATURE_ET));
1837 base = event_base_new_with_config(cfg);
1839 tt_int_op(EV_FEATURE_ET, ==,
1840 event_base_get_features(base) & EV_FEATURE_ET);
1842 base = event_base_new();
1843 tt_int_op(0, ==, event_base_get_features(base) & EV_FEATURE_ET);
1848 event_base_free(base);
1850 event_config_free(cfg);
1853 #ifdef _EVENT_HAVE_SETENV
1855 #elif !defined(_EVENT_HAVE_SETENV) && defined(_EVENT_HAVE_PUTENV)
1856 static void setenv(const char *k, const char *v, int _o)
1859 evutil_snprintf(b, sizeof(b), "%s=%s",k,v);
1865 #ifdef _EVENT_HAVE_UNSETENV
1867 #elif !defined(_EVENT_HAVE_UNSETENV) && defined(_EVENT_HAVE_PUTENV)
1868 static void unsetenv(const char *k)
1871 evutil_snprintf(b, sizeof(b), "%s=",k);
1877 #if defined(SETENV_OK) && defined(UNSETENV_OK)
1879 methodname_to_envvar(const char *mname, char *buf, size_t buflen)
1882 evutil_snprintf(buf, buflen, "EVENT_NO%s", mname);
1883 for (cp = buf; *cp; ++cp) {
1884 *cp = EVUTIL_TOUPPER(*cp);
1890 test_base_environ(void *arg)
1892 struct event_base *base = NULL;
1893 struct event_config *cfg = NULL;
1895 #if defined(SETENV_OK) && defined(UNSETENV_OK)
1896 const char **basenames;
1899 const char *defaultname, *ignoreenvname;
1901 /* See if unsetenv works before we rely on it. */
1902 setenv("EVENT_NOWAFFLES", "1", 1);
1903 unsetenv("EVENT_NOWAFFLES");
1904 if (getenv("EVENT_NOWAFFLES") != NULL) {
1905 #ifndef _EVENT_HAVE_UNSETENV
1906 TT_DECLARE("NOTE", ("Can't fake unsetenv; skipping test"));
1908 TT_DECLARE("NOTE", ("unsetenv doesn't work; skipping test"));
1913 basenames = event_get_supported_methods();
1914 for (i = 0; basenames[i]; ++i) {
1915 methodname_to_envvar(basenames[i], varbuf, sizeof(varbuf));
1920 base = event_base_new();
1923 defaultname = event_base_get_method(base);
1924 TT_BLATHER(("default is <%s>", defaultname));
1925 event_base_free(base);
1928 /* Can we disable the method with EVENT_NOfoo ? */
1929 if (!strcmp(defaultname, "epoll (with changelist)")) {
1930 setenv("EVENT_NOEPOLL", "1", 1);
1931 ignoreenvname = "epoll";
1933 methodname_to_envvar(defaultname, varbuf, sizeof(varbuf));
1934 setenv(varbuf, "1", 1);
1935 ignoreenvname = defaultname;
1938 /* Use an empty cfg rather than NULL so a failure doesn't exit() */
1939 cfg = event_config_new();
1940 base = event_base_new_with_config(cfg);
1941 event_config_free(cfg);
1943 if (n_methods == 1) {
1947 tt_str_op(defaultname, !=, event_base_get_method(base));
1948 event_base_free(base);
1952 /* Can we disable looking at the environment with IGNORE_ENV ? */
1953 cfg = event_config_new();
1954 event_config_set_flag(cfg, EVENT_BASE_FLAG_IGNORE_ENV);
1955 base = event_base_new_with_config(cfg);
1957 tt_str_op(ignoreenvname, ==, event_base_get_method(base));
1964 event_base_free(base);
1966 event_config_free(cfg);
1970 read_called_once_cb(evutil_socket_t fd, short event, void *arg)
1972 tt_int_op(event, ==, EV_READ);
1979 timeout_called_once_cb(evutil_socket_t fd, short event, void *arg)
1981 tt_int_op(event, ==, EV_TIMEOUT);
1988 test_event_once(void *ptr)
1990 struct basic_test_data *data = ptr;
1995 tv.tv_usec = 50*1000;
1997 r = event_base_once(data->base, data->pair[0], EV_READ,
1998 read_called_once_cb, NULL, NULL);
1999 tt_int_op(r, ==, 0);
2000 r = event_base_once(data->base, -1, EV_TIMEOUT,
2001 timeout_called_once_cb, NULL, &tv);
2002 tt_int_op(r, ==, 0);
2003 r = event_base_once(data->base, -1, 0, NULL, NULL, NULL);
2006 write(data->pair[1], TEST1, strlen(TEST1)+1);
2007 shutdown(data->pair[1], SHUT_WR);
2009 event_base_dispatch(data->base);
2011 tt_int_op(called, ==, 101);
2017 test_event_pending(void *ptr)
2019 struct basic_test_data *data = ptr;
2020 struct event *r=NULL, *w=NULL, *t=NULL;
2021 struct timeval tv, now, tv2, diff;
2024 tv.tv_usec = 500 * 1000;
2025 r = event_new(data->base, data->pair[0], EV_READ, simple_read_cb,
2027 w = event_new(data->base, data->pair[1], EV_WRITE, simple_write_cb,
2029 t = evtimer_new(data->base, timeout_cb, NULL);
2031 evutil_gettimeofday(&now, NULL);
2035 tt_assert( event_pending(r, EV_READ, NULL));
2036 tt_assert(!event_pending(w, EV_WRITE, NULL));
2037 tt_assert(!event_pending(r, EV_WRITE, NULL));
2038 tt_assert( event_pending(r, EV_READ|EV_WRITE, NULL));
2039 tt_assert(!event_pending(r, EV_TIMEOUT, NULL));
2040 tt_assert( event_pending(t, EV_TIMEOUT, NULL));
2041 tt_assert( event_pending(t, EV_TIMEOUT, &tv2));
2043 tt_assert(evutil_timercmp(&tv2, &now, >));
2044 evutil_timeradd(&now, &tv, &tv);
2045 evutil_timersub(&tv2, &tv, &diff);
2046 tt_int_op(diff.tv_sec, ==, 0);
2047 tt_int_op(labs(diff.tv_usec), <, 1000);
2065 /* You can't do this test on windows, since dup2 doesn't work on sockets */
2068 dfd_cb(evutil_socket_t fd, short e, void *data)
2070 *(int*)data = (int)e;
2073 /* Regression test for our workaround for a fun epoll/linux related bug
2074 * where fd2 = dup(fd1); add(fd2); close(fd2); dup2(fd1,fd2); add(fd2)
2075 * will get you an EEXIST */
2077 test_dup_fd(void *arg)
2079 struct basic_test_data *data = arg;
2080 struct event_base *base = data->base;
2081 struct event *ev1=NULL, *ev2=NULL;
2083 int ev1_got, ev2_got;
2085 tt_int_op(write(data->pair[0], "Hello world",
2086 strlen("Hello world")), >, 0);
2090 tt_int_op(dfd, >=, 0);
2092 ev1 = event_new(base, fd, EV_READ|EV_PERSIST, dfd_cb, &ev1_got);
2093 ev2 = event_new(base, dfd, EV_READ|EV_PERSIST, dfd_cb, &ev2_got);
2094 ev1_got = ev2_got = 0;
2095 event_add(ev1, NULL);
2096 event_add(ev2, NULL);
2097 event_base_loop(base, EVLOOP_ONCE);
2098 tt_int_op(ev1_got, ==, EV_READ);
2099 tt_int_op(ev2_got, ==, EV_READ);
2101 /* Now close and delete dfd then dispatch. We need to do the
2102 * dispatch here so that when we add it later, we think there
2103 * was an intermediate delete. */
2106 ev1_got = ev2_got = 0;
2107 event_base_loop(base, EVLOOP_ONCE);
2108 tt_want_int_op(ev1_got, ==, EV_READ);
2109 tt_int_op(ev2_got, ==, 0);
2111 /* Re-duplicate the fd. We need to get the same duplicated
2112 * value that we closed to provoke the epoll quirk. Also, we
2113 * need to change the events to write, or else the old lingering
2114 * read event will make the test pass whether the change was
2115 * successful or not. */
2116 tt_int_op(dup2(fd, dfd), ==, dfd);
2118 ev2 = event_new(base, dfd, EV_WRITE|EV_PERSIST, dfd_cb, &ev2_got);
2119 event_add(ev2, NULL);
2120 ev1_got = ev2_got = 0;
2121 event_base_loop(base, EVLOOP_ONCE);
2122 tt_want_int_op(ev1_got, ==, EV_READ);
2123 tt_int_op(ev2_got, ==, EV_WRITE);
2134 #ifdef _EVENT_DISABLE_MM_REPLACEMENT
2136 test_mm_functions(void *arg)
2138 _tinytest_set_test_skipped();
2142 check_dummy_mem_ok(void *_mem)
2146 return !memcmp(mem, "{[<guardedram>]}", 16);
2150 dummy_malloc(size_t len)
2152 char *mem = malloc(len+16);
2153 memcpy(mem, "{[<guardedram>]}", 16);
2158 dummy_realloc(void *_mem, size_t len)
2162 return dummy_malloc(len);
2163 tt_want(check_dummy_mem_ok(_mem));
2165 mem = realloc(mem, len+16);
2170 dummy_free(void *_mem)
2173 tt_want(check_dummy_mem_ok(_mem));
2179 test_mm_functions(void *arg)
2181 struct event_base *b = NULL;
2182 struct event_config *cfg = NULL;
2183 event_set_mem_functions(dummy_malloc, dummy_realloc, dummy_free);
2184 cfg = event_config_new();
2185 event_config_avoid_method(cfg, "Nonesuch");
2186 b = event_base_new_with_config(cfg);
2188 tt_assert(check_dummy_mem_ok(b));
2191 event_config_free(cfg);
2198 many_event_cb(evutil_socket_t fd, short event, void *arg)
2205 test_many_events(void *arg)
2207 /* Try 70 events that should all be aready at once. This will
2208 * exercise the "resize" code on most of the backends, and will make
2209 * sure that we can get past the 64-handle limit of some windows
2213 struct basic_test_data *data = arg;
2214 struct event_base *base = data->base;
2215 evutil_socket_t sock[MANY];
2216 struct event *ev[MANY];
2220 memset(sock, 0xff, sizeof(sock));
2221 memset(ev, 0, sizeof(ev));
2222 memset(called, 0, sizeof(called));
2224 for (i = 0; i < MANY; ++i) {
2225 /* We need an event that will hit the backend, and that will
2226 * be ready immediately. "Send a datagram" is an easy
2227 * instance of that. */
2228 sock[i] = socket(AF_INET, SOCK_DGRAM, 0);
2229 tt_assert(sock[i] >= 0);
2231 ev[i] = event_new(base, sock[i], EV_WRITE, many_event_cb,
2233 event_add(ev[i], NULL);
2236 event_base_loop(base, EVLOOP_NONBLOCK);
2238 for (i = 0; i < MANY; ++i) {
2239 tt_int_op(called[i], ==, 1);
2243 for (i = 0; i < MANY; ++i) {
2247 evutil_closesocket(sock[i]);
2253 test_struct_event_size(void *arg)
2255 tt_int_op(event_get_struct_event_size(), <=, sizeof(struct event));
2260 struct testcase_t main_testcases[] = {
2261 /* Some converted-over tests */
2262 { "methods", test_methods, TT_FORK, NULL, NULL },
2263 { "version", test_version, 0, NULL, NULL },
2264 BASIC(base_features, TT_FORK|TT_NO_LOGS),
2265 { "base_environ", test_base_environ, TT_FORK, NULL, NULL },
2267 BASIC(event_base_new, TT_FORK|TT_NEED_SOCKETPAIR),
2268 BASIC(free_active_base, TT_FORK|TT_NEED_SOCKETPAIR),
2270 BASIC(manipulate_active_events, TT_FORK|TT_NEED_BASE),
2272 BASIC(bad_assign, TT_FORK|TT_NEED_BASE|TT_NO_LOGS),
2273 BASIC(bad_reentrant, TT_FORK|TT_NEED_BASE|TT_NO_LOGS),
2275 /* These are still using the old API */
2276 LEGACY(persistent_timeout, TT_FORK|TT_NEED_BASE),
2277 { "persistent_active_timeout", test_persistent_active_timeout,
2278 TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
2279 LEGACY(priorities, TT_FORK|TT_NEED_BASE),
2280 { "common_timeout", test_common_timeout, TT_FORK|TT_NEED_BASE,
2281 &basic_setup, NULL },
2283 /* These legacy tests may not all need all of these flags. */
2284 LEGACY(simpleread, TT_ISOLATED),
2285 LEGACY(simpleread_multiple, TT_ISOLATED),
2286 LEGACY(simplewrite, TT_ISOLATED),
2287 { "simpleclose", test_simpleclose, TT_FORK, &basic_setup,
2289 LEGACY(multiple, TT_ISOLATED),
2290 LEGACY(persistent, TT_ISOLATED),
2291 LEGACY(combined, TT_ISOLATED),
2292 LEGACY(simpletimeout, TT_ISOLATED),
2293 LEGACY(loopbreak, TT_ISOLATED),
2294 LEGACY(loopexit, TT_ISOLATED),
2295 LEGACY(loopexit_multiple, TT_ISOLATED),
2296 LEGACY(nonpersist_readd, TT_ISOLATED),
2297 LEGACY(multiple_events_for_same_fd, TT_ISOLATED),
2298 LEGACY(want_only_once, TT_ISOLATED),
2299 { "event_once", test_event_once, TT_ISOLATED, &basic_setup, NULL },
2300 { "event_pending", test_event_pending, TT_ISOLATED, &basic_setup,
2303 { "dup_fd", test_dup_fd, TT_ISOLATED, &basic_setup, NULL },
2305 { "mm_functions", test_mm_functions, TT_FORK, NULL, NULL },
2306 BASIC(many_events, TT_ISOLATED),
2308 { "struct_event_size", test_struct_event_size, 0, NULL, NULL },
2311 LEGACY(fork, TT_ISOLATED),
2316 struct testcase_t evtag_testcases[] = {
2317 { "int", evtag_int_test, TT_FORK, NULL, NULL },
2318 { "fuzz", evtag_fuzz, TT_FORK, NULL, NULL },
2319 { "encoding", evtag_tag_encoding, TT_FORK, NULL, NULL },
2320 { "peek", evtag_test_peek, 0, NULL, NULL },
2325 struct testcase_t signal_testcases[] = {
2327 LEGACY(simplesignal, TT_ISOLATED),
2328 LEGACY(multiplesignal, TT_ISOLATED),
2329 LEGACY(immediatesignal, TT_ISOLATED),
2330 LEGACY(signal_dealloc, TT_ISOLATED),
2331 LEGACY(signal_pipeloss, TT_ISOLATED),
2332 LEGACY(signal_switchbase, TT_ISOLATED|TT_NO_LOGS),
2333 LEGACY(signal_restore, TT_ISOLATED),
2334 LEGACY(signal_assert, TT_ISOLATED),
2335 LEGACY(signal_while_processing, TT_ISOLATED),