2 * Copyright (c) 2003-2007 Niels Provos <provos@citi.umich.edu>
3 * Copyright (c) 2007-2012 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.
27 #include "util-internal.h"
34 #include "event2/event-config.h"
36 #include <sys/types.h>
38 #ifdef EVENT__HAVE_SYS_TIME_H
41 #include <sys/queue.h>
43 #include <sys/socket.h>
58 #include "event2/event.h"
59 #include "event2/event_struct.h"
60 #include "event2/event_compat.h"
61 #include "event2/tag.h"
62 #include "event2/buffer.h"
63 #include "event2/buffer_compat.h"
64 #include "event2/util.h"
65 #include "event-internal.h"
66 #include "evthread-internal.h"
67 #include "log-internal.h"
68 #include "time-internal.h"
73 #include "regress.gen.h"
76 evutil_socket_t pair[2];
79 struct event_base *global_base;
81 static char wbuf[4096];
82 static char rbuf[4096];
85 static int usepersist;
86 static struct timeval tset;
87 static struct timeval tcalled;
90 #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)
236 evutil_gettimeofday(&tcalled, NULL);
245 combined_read_cb(evutil_socket_t fd, short event, void *arg)
247 struct both *both = arg;
251 len = read(fd, buf, sizeof(buf));
253 fprintf(stderr, "%s: read\n", __func__);
258 if (event_add(&both->ev, NULL) == -1)
263 combined_write_cb(evutil_socket_t fd, short event, void *arg)
265 struct both *both = arg;
270 if (len > both->nread)
273 memset(buf, 'q', len);
275 len = write(fd, buf, len);
277 fprintf(stderr, "%s: write\n", __func__);
279 shutdown(fd, SHUT_WR);
284 if (event_add(&both->ev, NULL) == -1)
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)); \
295 #define cleanup_test() setup_test("cleanup")
298 test_simpleread(void)
302 /* Very simple read test */
303 setup_test("Simple read: ");
305 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
306 tt_fail_perror("write");
309 shutdown(pair[0], SHUT_WR);
311 event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
312 if (event_add(&ev, NULL) == -1)
320 test_simplewrite(void)
324 /* Very simple write test */
325 setup_test("Simple write: ");
327 event_set(&ev, pair[0], EV_WRITE, simple_write_cb, &ev);
328 if (event_add(&ev, NULL) == -1)
336 simpleread_multiple_cb(evutil_socket_t fd, short event, void *arg)
343 test_simpleread_multiple(void)
345 struct event one, two;
347 /* Very simple read test */
348 setup_test("Simple read to multiple evens: ");
350 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
351 tt_fail_perror("write");
354 shutdown(pair[0], SHUT_WR);
356 event_set(&one, pair[1], EV_READ, simpleread_multiple_cb, NULL);
357 if (event_add(&one, NULL) == -1)
359 event_set(&two, pair[1], EV_READ, simpleread_multiple_cb, NULL);
360 if (event_add(&two, NULL) == -1)
367 static int have_closed = 0;
368 static int premature_event = 0;
370 simpleclose_close_fd_cb(evutil_socket_t s, short what, void *ptr)
372 evutil_socket_t **fds = ptr;
373 TT_BLATHER(("Closing"));
374 evutil_closesocket(*fds[0]);
375 evutil_closesocket(*fds[1]);
382 record_event_cb(evutil_socket_t s, short what, void *ptr)
388 TT_BLATHER(("Recorded %d on socket %d", (int)what, (int)s));
392 test_simpleclose(void *ptr)
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;
400 short got_read_on_close = 0, got_write_on_close = 0;
402 memset(buf, 99, sizeof(buf));
404 #define LOCAL_SOCKETPAIR_AF AF_INET
406 #define LOCAL_SOCKETPAIR_AF AF_UNIX
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"));
417 /** Stuff pair2[1] full of data, until write fails */
419 int r = write(pair2[1], buf, sizeof(buf));
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)));
428 to_close[0] = &pair1[0];
429 to_close[1] = &pair2[0];
431 closeev = event_new(base, -1, EV_TIMEOUT, simpleclose_close_fd_cb,
433 rev = event_new(base, pair1[1], EV_READ, record_event_cb,
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]));
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. */
447 tv.tv_usec = 200*1000;
448 event_base_loopexit(base, &tv);
449 event_base_loop(base, 0);
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);
457 evutil_closesocket(pair1[0]);
459 evutil_closesocket(pair1[1]);
461 evutil_closesocket(pair2[0]);
463 evutil_closesocket(pair2[1]);
471 event_base_free(base);
478 struct event ev, ev2;
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++)
490 event_set(&ev, pair[0], EV_WRITE, multiple_write_cb, &ev);
491 if (event_add(&ev, NULL) == -1)
493 event_set(&ev2, pair[1], EV_READ, multiple_read_cb, &ev2);
494 if (event_add(&ev2, NULL) == -1)
499 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
505 test_persistent(void)
507 struct event ev, ev2;
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++)
519 event_set(&ev, pair[0], EV_WRITE|EV_PERSIST, multiple_write_cb, &ev);
520 if (event_add(&ev, NULL) == -1)
522 event_set(&ev2, pair[1], EV_READ|EV_PERSIST, multiple_read_cb, &ev2);
523 if (event_add(&ev2, NULL) == -1)
528 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
536 struct both r1, r2, w1, w2;
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));
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));
557 if (r1.nread == 8192 && r2.nread == 4096)
565 test_simpletimeout(void)
570 setup_test("Simple timeout: ");
572 tv.tv_usec = 200*1000;
574 evutil_timerclear(&tcalled);
575 evtimer_set(&ev, timeout_cb, NULL);
576 evtimer_add(&ev, &tv);
578 evutil_gettimeofday(&tset, NULL);
580 test_timeval_diff_eq(&tset, &tcalled, 200);
588 periodic_timeout_cb(evutil_socket_t fd, short event, void *arg)
594 /* call loopexit only once - on slow machines(?), it is
595 * apparently possible for this to get called twice. */
597 event_base_loopexit(global_base, NULL);
602 test_persistent_timeout(void)
608 evutil_timerclear(&tv);
611 event_assign(&ev, global_base, -1, EV_TIMEOUT|EV_PERSIST,
612 periodic_timeout_cb, &count);
621 test_persistent_timeout_jump(void *ptr)
623 struct basic_test_data *data = ptr;
626 struct timeval msec100 = { 0, 100 * 1000 };
627 struct timeval msec50 = { 0, 50 * 1000 };
628 struct timeval msec300 = { 0, 300 * 1000 };
630 event_assign(&ev, data->base, -1, EV_PERSIST, periodic_timeout_cb, &count);
631 event_add(&ev, &msec100);
633 evutil_usleep_(&msec300);
634 event_base_loopexit(data->base, &msec50);
635 event_base_dispatch(data->base);
636 tt_int_op(count, ==, 1);
642 struct persist_active_timeout_called {
645 struct timeval tvs[16];
649 activate_cb(evutil_socket_t fd, short event, void *arg)
651 struct event *ev = arg;
652 event_active(ev, EV_READ, 1);
656 persist_active_timeout_cb(evutil_socket_t fd, short event, void *arg)
658 struct persist_active_timeout_called *c = arg;
660 c->events[c->n] = event;
661 evutil_gettimeofday(&c->tvs[c->n], NULL);
667 test_persistent_active_timeout(void *ptr)
669 struct timeval tv, tv2, tv_exit, start;
671 struct persist_active_timeout_called res;
673 struct basic_test_data *data = ptr;
674 struct event_base *base = data->base;
676 memset(&res, 0, sizeof(res));
679 tv.tv_usec = 200 * 1000;
680 event_assign(&ev, base, -1, EV_TIMEOUT|EV_PERSIST,
681 persist_active_timeout_cb, &res);
685 tv2.tv_usec = 100 * 1000;
686 event_base_once(base, -1, EV_TIMEOUT, activate_cb, &ev, &tv2);
689 tv_exit.tv_usec = 600 * 1000;
690 event_base_loopexit(base, &tv_exit);
692 event_base_assert_ok_(base);
693 evutil_gettimeofday(&start, NULL);
695 event_base_dispatch(base);
696 event_base_assert_ok_(base);
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);
709 struct common_timeout_info {
711 struct timeval called_at;
717 common_timeout_cb(evutil_socket_t fd, short event, void *arg)
719 struct common_timeout_info *ti = arg;
721 evutil_gettimeofday(&ti->called_at, NULL);
727 test_common_timeout(void *ptr)
729 struct basic_test_data *data = ptr;
731 struct event_base *base = data->base;
733 struct common_timeout_info info[100];
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 };
741 const struct timeval *ms_100, *ms_200, *sec_5;
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);
749 tt_ptr_op(event_base_init_common_timeout(base, &tmp_200_ms),
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);
760 memset(info, 0, sizeof(info));
762 for (i=0; i<100; ++i) {
764 event_assign(&info[i].ev, base, -1, EV_TIMEOUT|EV_PERSIST,
765 common_timeout_cb, &info[i]);
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);
782 event_add(&info[i].ev, ms_100);
785 event_add(&info[i].ev, ms_200);
789 event_base_assert_ok_(base);
790 evutil_gettimeofday(&start, NULL);
791 event_base_dispatch(base);
793 event_base_assert_ok_(base);
795 for (i=0; i<10; ++i) {
796 tt_int_op(info[i].count, ==, 4);
798 test_timeval_diff_eq(&start, &info[i].called_at, 400);
800 test_timeval_diff_eq(&start, &info[i].called_at, 800);
804 /* Make sure we can free the base with some events in. */
805 for (i=0; i<100; ++i) {
807 event_add(&info[i].ev, ms_100);
809 event_add(&info[i].ev, ms_200);
814 event_base_free(data->base); /* need to do this here before info is
820 static void signal_cb(evutil_socket_t fd, short event, void *arg);
822 #define current_base event_global_current_base_
823 extern struct event_base *current_base;
826 child_signal_cb(evutil_socket_t fd, short event, void *arg)
841 int status, got_sigchld = 0;
842 struct event ev, sig_ev;
845 setup_test("After fork: ");
847 tt_assert(current_base);
848 evthread_make_base_notifiable(current_base);
850 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
851 tt_fail_perror("write");
854 event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
855 if (event_add(&ev, NULL) == -1)
858 evsignal_set(&sig_ev, SIGCHLD, child_signal_cb, &got_sigchld);
859 evsignal_add(&sig_ev, NULL);
861 event_base_assert_ok_(current_base);
862 TT_BLATHER(("Before fork"));
863 if ((pid = regress_fork()) == 0) {
865 TT_BLATHER(("In child, before reinit"));
866 event_base_assert_ok_(current_base);
867 if (event_reinit(current_base) == -1) {
868 fprintf(stdout, "FAILED (reinit)\n");
871 TT_BLATHER(("After reinit"));
872 event_base_assert_ok_(current_base);
873 TT_BLATHER(("After assert-ok"));
875 evsignal_del(&sig_ev);
881 event_base_free(current_base);
883 /* we do not send an EOF; simple_read_cb requires an EOF
884 * to set test_ok. we just verify that the callback was
886 exit(test_ok != 0 || called != 2 ? -2 : 76);
889 /* wait for the child to read the data */
891 const struct timeval tv = { 0, 100000 };
895 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
896 tt_fail_perror("write");
899 TT_BLATHER(("Before waitpid"));
900 if (waitpid(pid, &status, 0) == -1) {
901 fprintf(stdout, "FAILED (fork)\n");
904 TT_BLATHER(("After waitpid"));
906 if (WEXITSTATUS(status) != 76) {
907 fprintf(stdout, "FAILED (exit): %d\n", WEXITSTATUS(status));
911 /* test that the current event loop still works */
912 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
913 fprintf(stderr, "%s: write\n", __func__);
916 shutdown(pair[0], SHUT_WR);
921 fprintf(stdout, "FAILED (sigchld)\n");
925 evsignal_del(&sig_ev);
932 signal_cb_sa(int sig)
938 signal_cb(evutil_socket_t fd, short event, void *arg)
940 struct event *ev = arg;
947 test_simplesignal_impl(int find_reorder)
950 struct itimerval itv;
952 evsignal_set(&ev, SIGALRM, signal_cb, &ev);
953 evsignal_add(&ev, NULL);
954 /* find bugs in which operations are re-ordered */
957 evsignal_add(&ev, NULL);
960 memset(&itv, 0, sizeof(itv));
961 itv.it_value.tv_sec = 0;
962 itv.it_value.tv_usec = 100000;
963 if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
964 goto skip_simplesignal;
968 if (evsignal_del(&ev) == -1)
975 test_simplestsignal(void)
977 setup_test("Simplest one signal: ");
978 test_simplesignal_impl(0);
982 test_simplesignal(void)
984 setup_test("Simple signal: ");
985 test_simplesignal_impl(1);
989 test_multiplesignal(void)
991 struct event ev_one, ev_two;
992 struct itimerval itv;
994 setup_test("Multiple signal: ");
996 evsignal_set(&ev_one, SIGALRM, signal_cb, &ev_one);
997 evsignal_add(&ev_one, NULL);
999 evsignal_set(&ev_two, SIGALRM, signal_cb, &ev_two);
1000 evsignal_add(&ev_two, NULL);
1002 memset(&itv, 0, sizeof(itv));
1003 itv.it_value.tv_sec = 0;
1004 itv.it_value.tv_usec = 100000;
1005 if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
1006 goto skip_simplesignal;
1011 if (evsignal_del(&ev_one) == -1)
1013 if (evsignal_del(&ev_two) == -1)
1020 test_immediatesignal(void)
1025 evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
1026 evsignal_add(&ev, NULL);
1028 event_loop(EVLOOP_NONBLOCK);
1034 test_signal_dealloc(void)
1036 /* make sure that evsignal_event is event_del'ed and pipe closed */
1038 struct event_base *base = event_init();
1039 evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
1040 evsignal_add(&ev, NULL);
1042 event_base_free(base);
1043 /* If we got here without asserting, we're fine. */
1049 test_signal_pipeloss(void)
1051 /* make sure that the base1 pipe is closed correctly. */
1052 struct event_base *base1, *base2;
1055 base1 = event_init();
1056 pipe1 = base1->sig.ev_signal_pair[0];
1057 base2 = event_init();
1058 event_base_free(base2);
1059 event_base_free(base1);
1060 if (close(pipe1) != -1 || errno!=EBADF) {
1061 /* fd must be closed, so second close gives -1, EBADF */
1062 printf("signal pipe not closed. ");
1071 * make two bases to catch signals, use both of them. this only works
1072 * for event mechanisms that use our signal pipe trick. kqueue handles
1073 * signals internally, and all interested kqueues get all the signals.
1076 test_signal_switchbase(void)
1078 struct event ev1, ev2;
1079 struct event_base *base1, *base2;
1082 base1 = event_init();
1083 base2 = event_init();
1084 is_kqueue = !strcmp(event_get_method(),"kqueue");
1085 evsignal_set(&ev1, SIGUSR1, signal_cb, &ev1);
1086 evsignal_set(&ev2, SIGUSR1, signal_cb, &ev2);
1087 if (event_base_set(base1, &ev1) ||
1088 event_base_set(base2, &ev2) ||
1089 event_add(&ev1, NULL) ||
1090 event_add(&ev2, NULL)) {
1091 fprintf(stderr, "%s: cannot set base, add\n", __func__);
1095 tt_ptr_op(event_get_base(&ev1), ==, base1);
1096 tt_ptr_op(event_get_base(&ev2), ==, base2);
1099 /* can handle signal before loop is called */
1101 event_base_loop(base2, EVLOOP_NONBLOCK);
1107 event_base_loop(base1, EVLOOP_NONBLOCK);
1108 if (test_ok && !is_kqueue) {
1111 /* set base1 to handle signals */
1112 event_base_loop(base1, EVLOOP_NONBLOCK);
1114 event_base_loop(base1, EVLOOP_NONBLOCK);
1115 event_base_loop(base2, EVLOOP_NONBLOCK);
1118 event_base_free(base1);
1119 event_base_free(base2);
1124 * assert that a signal event removed from the event queue really is
1125 * removed - with no possibility of it's parent handler being fired.
1128 test_signal_assert(void)
1131 struct event_base *base = event_init();
1133 /* use SIGCONT so we don't kill ourselves when we signal to nowhere */
1134 evsignal_set(&ev, SIGCONT, signal_cb, &ev);
1135 evsignal_add(&ev, NULL);
1137 * if evsignal_del() fails to reset the handler, it's current handler
1138 * will still point to evsig_handler().
1144 /* only way to verify we were in evsig_handler() */
1145 /* XXXX Now there's no longer a good way. */
1146 if (base->sig.evsig_caught)
1154 event_base_free(base);
1160 * assert that we restore our previous signal handler properly.
1163 test_signal_restore(void)
1166 struct event_base *base = event_init();
1167 #ifdef EVENT__HAVE_SIGACTION
1168 struct sigaction sa;
1172 #ifdef EVENT__HAVE_SIGACTION
1173 sa.sa_handler = signal_cb_sa;
1175 sigemptyset(&sa.sa_mask);
1176 if (sigaction(SIGUSR1, &sa, NULL) == -1)
1179 if (signal(SIGUSR1, signal_cb_sa) == SIG_ERR)
1182 evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
1183 evsignal_add(&ev, NULL);
1187 /* 1 == signal_cb, 2 == signal_cb_sa, we want our previous handler */
1191 event_base_free(base);
1197 signal_cb_swp(int sig, short event, void *arg)
1203 event_loopexit(NULL);
1206 timeout_cb_swp(evutil_socket_t fd, short event, void *arg)
1209 struct timeval tv = {5, 0};
1212 evtimer_add((struct event *)arg, &tv);
1217 event_loopexit(NULL);
1221 test_signal_while_processing(void)
1223 struct event_base *base = event_init();
1224 struct event ev, ev_timer;
1225 struct timeval tv = {0, 0};
1227 setup_test("Receiving a signal while processing other signal: ");
1231 signal_set(&ev, SIGUSR1, signal_cb_swp, NULL);
1232 signal_add(&ev, NULL);
1233 evtimer_set(&ev_timer, timeout_cb_swp, &ev_timer);
1234 evtimer_add(&ev_timer, &tv);
1237 event_base_free(base);
1244 test_free_active_base(void *ptr)
1246 struct basic_test_data *data = ptr;
1247 struct event_base *base1;
1250 base1 = event_init();
1252 event_assign(&ev1, base1, data->pair[1], EV_READ,
1253 dummy_read_cb, NULL);
1254 event_add(&ev1, NULL);
1255 event_base_free(base1); /* should not crash */
1257 tt_fail_msg("failed to create event_base for test");
1260 base1 = event_init();
1262 event_assign(&ev1, base1, 0, 0, dummy_read_cb, NULL);
1263 event_active(&ev1, EV_READ, 1);
1264 event_base_free(base1);
1270 test_manipulate_active_events(void *ptr)
1272 struct basic_test_data *data = ptr;
1273 struct event_base *base = data->base;
1276 event_assign(&ev1, base, -1, EV_TIMEOUT, dummy_read_cb, NULL);
1278 /* Make sure an active event is pending. */
1279 event_active(&ev1, EV_READ, 1);
1280 tt_int_op(event_pending(&ev1, EV_READ|EV_TIMEOUT|EV_WRITE, NULL),
1283 /* Make sure that activating an event twice works. */
1284 event_active(&ev1, EV_WRITE, 1);
1285 tt_int_op(event_pending(&ev1, EV_READ|EV_TIMEOUT|EV_WRITE, NULL),
1286 ==, EV_READ|EV_WRITE);
1293 event_selfarg_cb(evutil_socket_t fd, short event, void *arg)
1295 struct event *ev = arg;
1296 struct event_base *base = event_get_base(ev);
1297 event_base_assert_ok_(base);
1298 event_base_loopexit(base, NULL);
1299 tt_want(ev == event_base_get_running_event(base));
1303 test_event_new_selfarg(void *ptr)
1305 struct basic_test_data *data = ptr;
1306 struct event_base *base = data->base;
1307 struct event *ev = event_new(base, -1, EV_READ, event_selfarg_cb,
1308 event_self_cbarg());
1310 event_active(ev, EV_READ, 1);
1311 event_base_dispatch(base);
1317 test_event_assign_selfarg(void *ptr)
1319 struct basic_test_data *data = ptr;
1320 struct event_base *base = data->base;
1323 event_assign(&ev, base, -1, EV_READ, event_selfarg_cb,
1324 event_self_cbarg());
1325 event_active(&ev, EV_READ, 1);
1326 event_base_dispatch(base);
1330 test_event_base_get_num_events(void *ptr)
1332 struct basic_test_data *data = ptr;
1333 struct event_base *base = data->base;
1335 int event_count_active;
1336 int event_count_virtual;
1337 int event_count_added;
1338 int event_count_active_virtual;
1339 int event_count_active_added;
1340 int event_count_virtual_added;
1341 int event_count_active_added_virtual;
1343 struct timeval qsec = {0, 100000};
1345 event_assign(&ev, base, -1, EV_READ, event_selfarg_cb,
1346 event_self_cbarg());
1348 event_add(&ev, &qsec);
1349 event_count_active = event_base_get_num_events(base,
1350 EVENT_BASE_COUNT_ACTIVE);
1351 event_count_virtual = event_base_get_num_events(base,
1352 EVENT_BASE_COUNT_VIRTUAL);
1353 event_count_added = event_base_get_num_events(base,
1354 EVENT_BASE_COUNT_ADDED);
1355 event_count_active_virtual = event_base_get_num_events(base,
1356 EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_VIRTUAL);
1357 event_count_active_added = event_base_get_num_events(base,
1358 EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_ADDED);
1359 event_count_virtual_added = event_base_get_num_events(base,
1360 EVENT_BASE_COUNT_VIRTUAL|EVENT_BASE_COUNT_ADDED);
1361 event_count_active_added_virtual = event_base_get_num_events(base,
1362 EVENT_BASE_COUNT_ACTIVE|
1363 EVENT_BASE_COUNT_ADDED|
1364 EVENT_BASE_COUNT_VIRTUAL);
1365 tt_int_op(event_count_active, ==, 0);
1366 tt_int_op(event_count_virtual, ==, 0);
1367 /* libevent itself adds a timeout event, so the event_count is 2 here */
1368 tt_int_op(event_count_added, ==, 2);
1369 tt_int_op(event_count_active_virtual, ==, 0);
1370 tt_int_op(event_count_active_added, ==, 2);
1371 tt_int_op(event_count_virtual_added, ==, 2);
1372 tt_int_op(event_count_active_added_virtual, ==, 2);
1374 event_active(&ev, EV_READ, 1);
1375 event_count_active = event_base_get_num_events(base,
1376 EVENT_BASE_COUNT_ACTIVE);
1377 event_count_virtual = event_base_get_num_events(base,
1378 EVENT_BASE_COUNT_VIRTUAL);
1379 event_count_added = event_base_get_num_events(base,
1380 EVENT_BASE_COUNT_ADDED);
1381 event_count_active_virtual = event_base_get_num_events(base,
1382 EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_VIRTUAL);
1383 event_count_active_added = event_base_get_num_events(base,
1384 EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_ADDED);
1385 event_count_virtual_added = event_base_get_num_events(base,
1386 EVENT_BASE_COUNT_VIRTUAL|EVENT_BASE_COUNT_ADDED);
1387 event_count_active_added_virtual = event_base_get_num_events(base,
1388 EVENT_BASE_COUNT_ACTIVE|
1389 EVENT_BASE_COUNT_ADDED|
1390 EVENT_BASE_COUNT_VIRTUAL);
1391 tt_int_op(event_count_active, ==, 1);
1392 tt_int_op(event_count_virtual, ==, 0);
1393 tt_int_op(event_count_added, ==, 3);
1394 tt_int_op(event_count_active_virtual, ==, 1);
1395 tt_int_op(event_count_active_added, ==, 4);
1396 tt_int_op(event_count_virtual_added, ==, 3);
1397 tt_int_op(event_count_active_added_virtual, ==, 4);
1399 event_base_loop(base, 0);
1400 event_count_active = event_base_get_num_events(base,
1401 EVENT_BASE_COUNT_ACTIVE);
1402 event_count_virtual = event_base_get_num_events(base,
1403 EVENT_BASE_COUNT_VIRTUAL);
1404 event_count_added = event_base_get_num_events(base,
1405 EVENT_BASE_COUNT_ADDED);
1406 event_count_active_virtual = event_base_get_num_events(base,
1407 EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_VIRTUAL);
1408 event_count_active_added = event_base_get_num_events(base,
1409 EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_ADDED);
1410 event_count_virtual_added = event_base_get_num_events(base,
1411 EVENT_BASE_COUNT_VIRTUAL|EVENT_BASE_COUNT_ADDED);
1412 event_count_active_added_virtual = event_base_get_num_events(base,
1413 EVENT_BASE_COUNT_ACTIVE|
1414 EVENT_BASE_COUNT_ADDED|
1415 EVENT_BASE_COUNT_VIRTUAL);
1416 tt_int_op(event_count_active, ==, 0);
1417 tt_int_op(event_count_virtual, ==, 0);
1418 tt_int_op(event_count_added, ==, 0);
1419 tt_int_op(event_count_active_virtual, ==, 0);
1420 tt_int_op(event_count_active_added, ==, 0);
1421 tt_int_op(event_count_virtual_added, ==, 0);
1422 tt_int_op(event_count_active_added_virtual, ==, 0);
1424 event_base_add_virtual_(base);
1425 event_count_active = event_base_get_num_events(base,
1426 EVENT_BASE_COUNT_ACTIVE);
1427 event_count_virtual = event_base_get_num_events(base,
1428 EVENT_BASE_COUNT_VIRTUAL);
1429 event_count_added = event_base_get_num_events(base,
1430 EVENT_BASE_COUNT_ADDED);
1431 event_count_active_virtual = event_base_get_num_events(base,
1432 EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_VIRTUAL);
1433 event_count_active_added = event_base_get_num_events(base,
1434 EVENT_BASE_COUNT_ACTIVE|EVENT_BASE_COUNT_ADDED);
1435 event_count_virtual_added = event_base_get_num_events(base,
1436 EVENT_BASE_COUNT_VIRTUAL|EVENT_BASE_COUNT_ADDED);
1437 event_count_active_added_virtual = event_base_get_num_events(base,
1438 EVENT_BASE_COUNT_ACTIVE|
1439 EVENT_BASE_COUNT_ADDED|
1440 EVENT_BASE_COUNT_VIRTUAL);
1441 tt_int_op(event_count_active, ==, 0);
1442 tt_int_op(event_count_virtual, ==, 1);
1443 tt_int_op(event_count_added, ==, 0);
1444 tt_int_op(event_count_active_virtual, ==, 1);
1445 tt_int_op(event_count_active_added, ==, 0);
1446 tt_int_op(event_count_virtual_added, ==, 1);
1447 tt_int_op(event_count_active_added_virtual, ==, 1);
1454 test_event_base_get_max_events(void *ptr)
1456 struct basic_test_data *data = ptr;
1457 struct event_base *base = data->base;
1460 int event_count_active;
1461 int event_count_virtual;
1462 int event_count_added;
1463 int event_count_active_virtual;
1464 int event_count_active_added;
1465 int event_count_virtual_added;
1466 int event_count_active_added_virtual;
1468 struct timeval qsec = {0, 100000};
1470 event_assign(&ev, base, -1, EV_READ, event_selfarg_cb,
1471 event_self_cbarg());
1472 event_assign(&ev2, base, -1, EV_READ, event_selfarg_cb,
1473 event_self_cbarg());
1475 event_add(&ev, &qsec);
1476 event_add(&ev2, &qsec);
1479 event_count_active = event_base_get_max_events(base,
1480 EVENT_BASE_COUNT_ACTIVE, 0);
1481 event_count_virtual = event_base_get_max_events(base,
1482 EVENT_BASE_COUNT_VIRTUAL, 0);
1483 event_count_added = event_base_get_max_events(base,
1484 EVENT_BASE_COUNT_ADDED, 0);
1485 event_count_active_virtual = event_base_get_max_events(base,
1486 EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_VIRTUAL, 0);
1487 event_count_active_added = event_base_get_max_events(base,
1488 EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_ADDED, 0);
1489 event_count_virtual_added = event_base_get_max_events(base,
1490 EVENT_BASE_COUNT_VIRTUAL | EVENT_BASE_COUNT_ADDED, 0);
1491 event_count_active_added_virtual = event_base_get_max_events(base,
1492 EVENT_BASE_COUNT_ACTIVE |
1493 EVENT_BASE_COUNT_ADDED |
1494 EVENT_BASE_COUNT_VIRTUAL, 0);
1496 tt_int_op(event_count_active, ==, 0);
1497 tt_int_op(event_count_virtual, ==, 0);
1498 /* libevent itself adds a timeout event, so the event_count is 4 here */
1499 tt_int_op(event_count_added, ==, 4);
1500 tt_int_op(event_count_active_virtual, ==, 0);
1501 tt_int_op(event_count_active_added, ==, 4);
1502 tt_int_op(event_count_virtual_added, ==, 4);
1503 tt_int_op(event_count_active_added_virtual, ==, 4);
1505 event_active(&ev, EV_READ, 1);
1506 event_count_active = event_base_get_max_events(base,
1507 EVENT_BASE_COUNT_ACTIVE, 0);
1508 event_count_virtual = event_base_get_max_events(base,
1509 EVENT_BASE_COUNT_VIRTUAL, 0);
1510 event_count_added = event_base_get_max_events(base,
1511 EVENT_BASE_COUNT_ADDED, 0);
1512 event_count_active_virtual = event_base_get_max_events(base,
1513 EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_VIRTUAL, 0);
1514 event_count_active_added = event_base_get_max_events(base,
1515 EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_ADDED, 0);
1516 event_count_virtual_added = event_base_get_max_events(base,
1517 EVENT_BASE_COUNT_VIRTUAL | EVENT_BASE_COUNT_ADDED, 0);
1518 event_count_active_added_virtual = event_base_get_max_events(base,
1519 EVENT_BASE_COUNT_ACTIVE |
1520 EVENT_BASE_COUNT_ADDED |
1521 EVENT_BASE_COUNT_VIRTUAL, 0);
1523 tt_int_op(event_count_active, ==, 1);
1524 tt_int_op(event_count_virtual, ==, 0);
1525 tt_int_op(event_count_added, ==, 4);
1526 tt_int_op(event_count_active_virtual, ==, 1);
1527 tt_int_op(event_count_active_added, ==, 5);
1528 tt_int_op(event_count_virtual_added, ==, 4);
1529 tt_int_op(event_count_active_added_virtual, ==, 5);
1531 event_base_loop(base, 0);
1532 event_count_active = event_base_get_max_events(base,
1533 EVENT_BASE_COUNT_ACTIVE, 1);
1534 event_count_virtual = event_base_get_max_events(base,
1535 EVENT_BASE_COUNT_VIRTUAL, 1);
1536 event_count_added = event_base_get_max_events(base,
1537 EVENT_BASE_COUNT_ADDED, 1);
1538 event_count_active_virtual = event_base_get_max_events(base,
1539 EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_VIRTUAL, 0);
1540 event_count_active_added = event_base_get_max_events(base,
1541 EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_ADDED, 0);
1542 event_count_virtual_added = event_base_get_max_events(base,
1543 EVENT_BASE_COUNT_VIRTUAL | EVENT_BASE_COUNT_ADDED, 0);
1544 event_count_active_added_virtual = event_base_get_max_events(base,
1545 EVENT_BASE_COUNT_ACTIVE |
1546 EVENT_BASE_COUNT_ADDED |
1547 EVENT_BASE_COUNT_VIRTUAL, 1);
1549 tt_int_op(event_count_active, ==, 1);
1550 tt_int_op(event_count_virtual, ==, 0);
1551 tt_int_op(event_count_added, ==, 4);
1552 tt_int_op(event_count_active_virtual, ==, 0);
1553 tt_int_op(event_count_active_added, ==, 0);
1554 tt_int_op(event_count_virtual_added, ==, 0);
1555 tt_int_op(event_count_active_added_virtual, ==, 0);
1557 event_count_active = event_base_get_max_events(base,
1558 EVENT_BASE_COUNT_ACTIVE, 0);
1559 event_count_virtual = event_base_get_max_events(base,
1560 EVENT_BASE_COUNT_VIRTUAL, 0);
1561 event_count_added = event_base_get_max_events(base,
1562 EVENT_BASE_COUNT_ADDED, 0);
1563 tt_int_op(event_count_active, ==, 0);
1564 tt_int_op(event_count_virtual, ==, 0);
1565 tt_int_op(event_count_added, ==, 0);
1567 event_base_add_virtual_(base);
1568 event_count_active = event_base_get_max_events(base,
1569 EVENT_BASE_COUNT_ACTIVE, 0);
1570 event_count_virtual = event_base_get_max_events(base,
1571 EVENT_BASE_COUNT_VIRTUAL, 0);
1572 event_count_added = event_base_get_max_events(base,
1573 EVENT_BASE_COUNT_ADDED, 0);
1574 event_count_active_virtual = event_base_get_max_events(base,
1575 EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_VIRTUAL, 0);
1576 event_count_active_added = event_base_get_max_events(base,
1577 EVENT_BASE_COUNT_ACTIVE | EVENT_BASE_COUNT_ADDED, 0);
1578 event_count_virtual_added = event_base_get_max_events(base,
1579 EVENT_BASE_COUNT_VIRTUAL | EVENT_BASE_COUNT_ADDED, 0);
1580 event_count_active_added_virtual = event_base_get_max_events(base,
1581 EVENT_BASE_COUNT_ACTIVE |
1582 EVENT_BASE_COUNT_ADDED |
1583 EVENT_BASE_COUNT_VIRTUAL, 0);
1585 tt_int_op(event_count_active, ==, 0);
1586 tt_int_op(event_count_virtual, ==, 1);
1587 tt_int_op(event_count_added, ==, 0);
1588 tt_int_op(event_count_active_virtual, ==, 1);
1589 tt_int_op(event_count_active_added, ==, 0);
1590 tt_int_op(event_count_virtual_added, ==, 1);
1591 tt_int_op(event_count_active_added_virtual, ==, 1);
1598 test_bad_assign(void *ptr)
1602 /* READ|SIGNAL is not allowed */
1603 r = event_assign(&ev, NULL, -1, EV_SIGNAL|EV_READ, dummy_read_cb, NULL);
1610 static int reentrant_cb_run = 0;
1613 bad_reentrant_run_loop_cb(evutil_socket_t fd, short what, void *ptr)
1615 struct event_base *base = ptr;
1617 reentrant_cb_run = 1;
1618 /* This reentrant call to event_base_loop should be detected and
1620 r = event_base_loop(base, 0);
1621 tt_int_op(r, ==, -1);
1627 test_bad_reentrant(void *ptr)
1629 struct basic_test_data *data = ptr;
1630 struct event_base *base = data->base;
1633 event_assign(&ev, base, -1,
1634 0, bad_reentrant_run_loop_cb, base);
1636 event_active(&ev, EV_WRITE, 1);
1637 r = event_base_loop(base, 0);
1638 tt_int_op(r, ==, 1);
1639 tt_int_op(reentrant_cb_run, ==, 1);
1644 static int n_write_a_byte_cb=0;
1645 static int n_read_and_drain_cb=0;
1646 static int n_activate_other_event_cb=0;
1648 write_a_byte_cb(evutil_socket_t fd, short what, void *arg)
1651 if (write(fd, buf, 1) == 1)
1652 ++n_write_a_byte_cb;
1655 read_and_drain_cb(evutil_socket_t fd, short what, void *arg)
1659 ++n_read_and_drain_cb;
1660 while ((n = read(fd, buf, sizeof(buf))) > 0)
1665 activate_other_event_cb(evutil_socket_t fd, short what, void *other_)
1667 struct event *ev_activate = other_;
1668 ++n_activate_other_event_cb;
1669 event_active_later_(ev_activate, EV_READ);
1673 test_active_later(void *ptr)
1675 struct basic_test_data *data = ptr;
1676 struct event *ev1 = NULL, *ev2 = NULL;
1677 struct event ev3, ev4;
1678 struct timeval qsec = {0, 100000};
1679 ev1 = event_new(data->base, data->pair[0], EV_READ|EV_PERSIST, read_and_drain_cb, NULL);
1680 ev2 = event_new(data->base, data->pair[1], EV_WRITE|EV_PERSIST, write_a_byte_cb, NULL);
1681 event_assign(&ev3, data->base, -1, 0, activate_other_event_cb, &ev4);
1682 event_assign(&ev4, data->base, -1, 0, activate_other_event_cb, &ev3);
1683 event_add(ev1, NULL);
1684 event_add(ev2, NULL);
1685 event_active_later_(&ev3, EV_READ);
1687 event_base_loopexit(data->base, &qsec);
1689 event_base_loop(data->base, 0);
1691 TT_BLATHER(("%d write calls, %d read calls, %d activate-other calls.",
1692 n_write_a_byte_cb, n_read_and_drain_cb, n_activate_other_event_cb));
1696 tt_int_op(n_write_a_byte_cb, ==, n_activate_other_event_cb);
1697 tt_int_op(n_write_a_byte_cb, >, 100);
1698 tt_int_op(n_read_and_drain_cb, >, 100);
1699 tt_int_op(n_activate_other_event_cb, >, 100);
1701 event_active_later_(&ev4, EV_READ);
1702 event_active(&ev4, EV_READ, 1); /* This should make the event
1703 active immediately. */
1704 tt_assert((ev4.ev_flags & EVLIST_ACTIVE) != 0);
1705 tt_assert((ev4.ev_flags & EVLIST_ACTIVE_LATER) == 0);
1707 /* Now leave this one around, so that event_free sees it and removes
1709 event_active_later_(&ev3, EV_READ);
1710 event_base_assert_ok_(data->base);
1718 event_base_free(data->base);
1723 static void incr_arg_cb(evutil_socket_t fd, short what, void *arg)
1726 (void) fd; (void) what;
1729 static void remove_timers_cb(evutil_socket_t fd, short what, void *arg)
1731 struct event **ep = arg;
1732 (void) fd; (void) what;
1733 event_remove_timer(ep[0]);
1734 event_remove_timer(ep[1]);
1736 static void send_a_byte_cb(evutil_socket_t fd, short what, void *arg)
1738 evutil_socket_t *sockp = arg;
1739 (void) fd; (void) what;
1740 (void) write(*sockp, "A", 1);
1742 struct read_not_timeout_param
1748 static void read_not_timeout_cb(evutil_socket_t fd, short what, void *arg)
1750 struct read_not_timeout_param *rntp = arg;
1753 (void) fd; (void) what;
1754 n = read(fd, &c, 1);
1755 tt_int_op(n, ==, 1);
1756 rntp->events |= what;
1758 if(2 == rntp->count) event_del(rntp->ev[0]);
1764 test_event_remove_timeout(void *ptr)
1766 struct basic_test_data *data = ptr;
1767 struct event_base *base = data->base;
1768 struct event *ev[5];
1770 struct timeval ms25 = { 0, 25*1000 },
1771 ms40 = { 0, 40*1000 },
1772 ms75 = { 0, 75*1000 },
1773 ms125 = { 0, 125*1000 };
1774 struct read_not_timeout_param rntp = { ev, 0, 0 };
1776 event_base_assert_ok_(base);
1778 ev[0] = event_new(base, data->pair[0], EV_READ|EV_PERSIST,
1779 read_not_timeout_cb, &rntp);
1780 ev[1] = evtimer_new(base, incr_arg_cb, &ev1_fired);
1781 ev[2] = evtimer_new(base, remove_timers_cb, ev);
1782 ev[3] = evtimer_new(base, send_a_byte_cb, &data->pair[1]);
1783 ev[4] = evtimer_new(base, send_a_byte_cb, &data->pair[1]);
1785 event_add(ev[2], &ms25); /* remove timers */
1786 event_add(ev[4], &ms40); /* write to test if timer re-activates */
1787 event_add(ev[0], &ms75); /* read */
1788 event_add(ev[1], &ms75); /* timer */
1789 event_add(ev[3], &ms125); /* timeout. */
1790 event_base_assert_ok_(base);
1792 event_base_dispatch(base);
1794 tt_int_op(ev1_fired, ==, 0);
1795 tt_int_op(rntp.events, ==, EV_READ);
1797 event_base_assert_ok_(base);
1807 test_event_base_new(void *ptr)
1809 struct basic_test_data *data = ptr;
1810 struct event_base *base = 0;
1812 struct basic_cb_args args;
1814 int towrite = (int)strlen(TEST1)+1;
1815 int len = write(data->pair[0], TEST1, towrite);
1818 tt_abort_perror("initial write");
1819 else if (len != towrite)
1820 tt_abort_printf(("initial write fell short (%d of %d bytes)",
1823 if (shutdown(data->pair[0], SHUT_WR))
1824 tt_abort_perror("initial write shutdown");
1826 base = event_base_new();
1828 tt_abort_msg("failed to create event base");
1833 event_assign(&ev1, base, data->pair[1],
1834 EV_READ|EV_PERSIST, basic_read_cb, &args);
1836 if (event_add(&ev1, NULL))
1837 tt_abort_perror("initial event_add");
1839 if (event_base_loop(base, 0))
1840 tt_abort_msg("unsuccessful exit from event loop");
1844 event_base_free(base);
1850 struct timeval tv, tv_start, tv_end;
1853 setup_test("Loop exit: ");
1856 tv.tv_sec = 60*60*24;
1857 evtimer_set(&ev, timeout_cb, NULL);
1858 evtimer_add(&ev, &tv);
1860 tv.tv_usec = 300*1000;
1862 event_loopexit(&tv);
1864 evutil_gettimeofday(&tv_start, NULL);
1866 evutil_gettimeofday(&tv_end, NULL);
1870 tt_assert(event_base_got_exit(global_base));
1871 tt_assert(!event_base_got_break(global_base));
1873 test_timeval_diff_eq(&tv_start, &tv_end, 300);
1881 test_loopexit_multiple(void)
1883 struct timeval tv, tv_start, tv_end;
1884 struct event_base *base;
1886 setup_test("Loop Multiple exit: ");
1888 base = event_base_new();
1890 tv.tv_usec = 200*1000;
1892 event_base_loopexit(base, &tv);
1896 event_base_loopexit(base, &tv);
1898 evutil_gettimeofday(&tv_start, NULL);
1899 event_base_dispatch(base);
1900 evutil_gettimeofday(&tv_end, NULL);
1902 tt_assert(event_base_got_exit(base));
1903 tt_assert(!event_base_got_break(base));
1905 event_base_free(base);
1907 test_timeval_diff_eq(&tv_start, &tv_end, 200);
1916 break_cb(evutil_socket_t fd, short events, void *arg)
1923 fail_cb(evutil_socket_t fd, short events, void *arg)
1929 test_loopbreak(void)
1931 struct event ev1, ev2;
1934 setup_test("Loop break: ");
1938 evtimer_set(&ev1, break_cb, NULL);
1939 evtimer_add(&ev1, &tv);
1940 evtimer_set(&ev2, fail_cb, NULL);
1941 evtimer_add(&ev2, &tv);
1945 tt_assert(!event_base_got_exit(global_base));
1946 tt_assert(event_base_got_break(global_base));
1955 static struct event *readd_test_event_last_added = NULL;
1957 re_add_read_cb(evutil_socket_t fd, short event, void *arg)
1960 struct event *ev_other = arg;
1963 readd_test_event_last_added = ev_other;
1965 n_read = read(fd, buf, sizeof(buf));
1968 tt_fail_perror("read");
1969 event_base_loopbreak(event_get_base(ev_other));
1972 event_add(ev_other, NULL);
1978 test_nonpersist_readd(void)
1980 struct event ev1, ev2;
1982 setup_test("Re-add nonpersistent events: ");
1983 event_set(&ev1, pair[0], EV_READ, re_add_read_cb, &ev2);
1984 event_set(&ev2, pair[1], EV_READ, re_add_read_cb, &ev1);
1986 if (write(pair[0], "Hello", 5) < 0) {
1987 tt_fail_perror("write(pair[0])");
1990 if (write(pair[1], "Hello", 5) < 0) {
1991 tt_fail_perror("write(pair[1])\n");
1994 if (event_add(&ev1, NULL) == -1 ||
1995 event_add(&ev2, NULL) == -1) {
2000 event_loop(EVLOOP_ONCE);
2003 /* At this point, we executed both callbacks. Whichever one got
2004 * called first added the second, but the second then immediately got
2005 * deleted before its callback was called. At this point, though, it
2006 * re-added the first.
2008 if (!readd_test_event_last_added) {
2010 } else if (readd_test_event_last_added == &ev1) {
2011 if (!event_pending(&ev1, EV_READ, NULL) ||
2012 event_pending(&ev2, EV_READ, NULL))
2015 if (event_pending(&ev1, EV_READ, NULL) ||
2016 !event_pending(&ev2, EV_READ, NULL))
2026 struct test_pri_event {
2032 test_priorities_cb(evutil_socket_t fd, short what, void *arg)
2034 struct test_pri_event *pri = arg;
2037 if (pri->count == 3) {
2038 event_loopexit(NULL);
2044 evutil_timerclear(&tv);
2045 event_add(&pri->ev, &tv);
2049 test_priorities_impl(int npriorities)
2051 struct test_pri_event one, two;
2054 TT_BLATHER(("Testing Priorities %d: ", npriorities));
2056 event_base_priority_init(global_base, npriorities);
2058 memset(&one, 0, sizeof(one));
2059 memset(&two, 0, sizeof(two));
2061 timeout_set(&one.ev, test_priorities_cb, &one);
2062 if (event_priority_set(&one.ev, 0) == -1) {
2063 fprintf(stderr, "%s: failed to set priority", __func__);
2067 timeout_set(&two.ev, test_priorities_cb, &two);
2068 if (event_priority_set(&two.ev, npriorities - 1) == -1) {
2069 fprintf(stderr, "%s: failed to set priority", __func__);
2073 evutil_timerclear(&tv);
2075 if (event_add(&one.ev, &tv) == -1)
2077 if (event_add(&two.ev, &tv) == -1)
2085 if (npriorities == 1) {
2086 if (one.count == 3 && two.count == 3)
2088 } else if (npriorities == 2) {
2089 /* Two is called once because event_loopexit is priority 1 */
2090 if (one.count == 3 && two.count == 1)
2093 if (one.count == 3 && two.count == 0)
2099 test_priorities(void)
2101 test_priorities_impl(1);
2103 test_priorities_impl(2);
2105 test_priorities_impl(3);
2108 /* priority-active-inversion: activate a higher-priority event, and make sure
2109 * it keeps us from running a lower-priority event first. */
2110 static int n_pai_calls = 0;
2111 static struct event pai_events[3];
2114 prio_active_inversion_cb(evutil_socket_t fd, short what, void *arg)
2116 int *call_order = arg;
2117 *call_order = n_pai_calls++;
2118 if (n_pai_calls == 1) {
2119 /* This should activate later, even though it shares a
2120 priority with us. */
2121 event_active(&pai_events[1], EV_READ, 1);
2122 /* This should activate next, since its priority is higher,
2123 even though we activated it second. */
2124 event_active(&pai_events[2], EV_TIMEOUT, 1);
2129 test_priority_active_inversion(void *data_)
2131 struct basic_test_data *data = data_;
2132 struct event_base *base = data->base;
2135 tt_int_op(event_base_priority_init(base, 8), ==, 0);
2138 memset(call_order, 0, sizeof(call_order));
2141 event_assign(&pai_events[i], data->base, -1, 0,
2142 prio_active_inversion_cb, &call_order[i]);
2145 event_priority_set(&pai_events[0], 4);
2146 event_priority_set(&pai_events[1], 4);
2147 event_priority_set(&pai_events[2], 0);
2149 event_active(&pai_events[0], EV_WRITE, 1);
2151 event_base_dispatch(base);
2152 tt_int_op(n_pai_calls, ==, 3);
2153 tt_int_op(call_order[0], ==, 0);
2154 tt_int_op(call_order[1], ==, 2);
2155 tt_int_op(call_order[2], ==, 1);
2162 test_multiple_cb(evutil_socket_t fd, short event, void *arg)
2164 if (event & EV_READ)
2166 else if (event & EV_WRITE)
2171 test_multiple_events_for_same_fd(void)
2173 struct event e1, e2;
2175 setup_test("Multiple events for same fd: ");
2177 event_set(&e1, pair[0], EV_READ, test_multiple_cb, NULL);
2178 event_add(&e1, NULL);
2179 event_set(&e2, pair[0], EV_WRITE, test_multiple_cb, NULL);
2180 event_add(&e2, NULL);
2181 event_loop(EVLOOP_ONCE);
2184 if (write(pair[1], TEST1, strlen(TEST1)+1) < 0) {
2185 tt_fail_perror("write");
2188 event_loop(EVLOOP_ONCE);
2197 int evtag_decode_int(ev_uint32_t *pnumber, struct evbuffer *evbuf);
2198 int evtag_decode_int64(ev_uint64_t *pnumber, struct evbuffer *evbuf);
2199 int evtag_encode_tag(struct evbuffer *evbuf, ev_uint32_t number);
2200 int evtag_decode_tag(ev_uint32_t *pnumber, struct evbuffer *evbuf);
2203 read_once_cb(evutil_socket_t fd, short event, void *arg)
2208 len = read(fd, buf, sizeof(buf));
2213 /* Assumes global pair[0] can be used for writing */
2214 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
2215 tt_fail_perror("write");
2226 test_want_only_once(void)
2231 /* Very simple read test */
2232 setup_test("Want read only once: ");
2234 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
2235 tt_fail_perror("write");
2238 /* Setup the loop termination */
2239 evutil_timerclear(&tv);
2240 tv.tv_usec = 300*1000;
2241 event_loopexit(&tv);
2243 event_set(&ev, pair[1], EV_READ, read_once_cb, &ev);
2244 if (event_add(&ev, NULL) == -1)
2251 #define TEST_MAX_INT 6
2254 evtag_int_test(void *ptr)
2256 struct evbuffer *tmp = evbuffer_new();
2257 ev_uint32_t integers[TEST_MAX_INT] = {
2258 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
2260 ev_uint32_t integer;
2261 ev_uint64_t big_int;
2266 for (i = 0; i < TEST_MAX_INT; i++) {
2268 oldlen = (int)EVBUFFER_LENGTH(tmp);
2269 evtag_encode_int(tmp, integers[i]);
2270 newlen = (int)EVBUFFER_LENGTH(tmp);
2271 TT_BLATHER(("encoded 0x%08x with %d bytes",
2272 (unsigned)integers[i], newlen - oldlen));
2273 big_int = integers[i];
2274 big_int *= 1000000000; /* 1 billion */
2275 evtag_encode_int64(tmp, big_int);
2278 for (i = 0; i < TEST_MAX_INT; i++) {
2279 tt_int_op(evtag_decode_int(&integer, tmp), !=, -1);
2280 tt_uint_op(integer, ==, integers[i]);
2281 tt_int_op(evtag_decode_int64(&big_int, tmp), !=, -1);
2282 tt_assert((big_int / 1000000000) == integers[i]);
2285 tt_uint_op(EVBUFFER_LENGTH(tmp), ==, 0);
2291 evtag_fuzz(void *ptr)
2293 u_char buffer[4096];
2294 struct evbuffer *tmp = evbuffer_new();
2302 for (j = 0; j < 100; j++) {
2303 for (i = 0; i < (int)sizeof(buffer); i++)
2304 buffer[i] = test_weakrand();
2305 evbuffer_drain(tmp, -1);
2306 evbuffer_add(tmp, buffer, sizeof(buffer));
2308 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1)
2312 /* The majority of decodes should fail */
2313 tt_int_op(not_failed, <, 10);
2315 /* Now insert some corruption into the tag length field */
2316 evbuffer_drain(tmp, -1);
2317 evutil_timerclear(&tv);
2319 evtag_marshal_timeval(tmp, 0, &tv);
2320 evbuffer_add(tmp, buffer, sizeof(buffer));
2322 ((char *)EVBUFFER_DATA(tmp))[1] = '\xff';
2323 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1) {
2324 tt_abort_msg("evtag_unmarshal_timeval should have failed");
2332 evtag_tag_encoding(void *ptr)
2334 struct evbuffer *tmp = evbuffer_new();
2335 ev_uint32_t integers[TEST_MAX_INT] = {
2336 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
2338 ev_uint32_t integer;
2343 for (i = 0; i < TEST_MAX_INT; i++) {
2345 oldlen = (int)EVBUFFER_LENGTH(tmp);
2346 evtag_encode_tag(tmp, integers[i]);
2347 newlen = (int)EVBUFFER_LENGTH(tmp);
2348 TT_BLATHER(("encoded 0x%08x with %d bytes",
2349 (unsigned)integers[i], newlen - oldlen));
2352 for (i = 0; i < TEST_MAX_INT; i++) {
2353 tt_int_op(evtag_decode_tag(&integer, tmp), !=, -1);
2354 tt_uint_op(integer, ==, integers[i]);
2357 tt_uint_op(EVBUFFER_LENGTH(tmp), ==, 0);
2364 evtag_test_peek(void *ptr)
2366 struct evbuffer *tmp = evbuffer_new();
2369 evtag_marshal_int(tmp, 30, 0);
2370 evtag_marshal_string(tmp, 40, "Hello world");
2372 tt_int_op(evtag_peek(tmp, &u32), ==, 1);
2373 tt_int_op(u32, ==, 30);
2374 tt_int_op(evtag_peek_length(tmp, &u32), ==, 0);
2375 tt_int_op(u32, ==, 1+1+1);
2376 tt_int_op(evtag_consume(tmp), ==, 0);
2378 tt_int_op(evtag_peek(tmp, &u32), ==, 1);
2379 tt_int_op(u32, ==, 40);
2380 tt_int_op(evtag_peek_length(tmp, &u32), ==, 0);
2381 tt_int_op(u32, ==, 1+1+11);
2382 tt_int_op(evtag_payload_length(tmp, &u32), ==, 0);
2383 tt_int_op(u32, ==, 11);
2391 test_methods(void *ptr)
2393 const char **methods = event_get_supported_methods();
2394 struct event_config *cfg = NULL;
2395 struct event_base *base = NULL;
2396 const char *backend;
2401 backend = methods[0];
2402 while (*methods != NULL) {
2403 TT_BLATHER(("Support method: %s", *methods));
2408 cfg = event_config_new();
2409 assert(cfg != NULL);
2411 tt_int_op(event_config_avoid_method(cfg, backend), ==, 0);
2412 event_config_set_flag(cfg, EVENT_BASE_FLAG_IGNORE_ENV);
2414 base = event_base_new_with_config(cfg);
2415 if (n_methods > 1) {
2417 tt_str_op(backend, !=, event_base_get_method(base));
2419 tt_assert(base == NULL);
2424 event_base_free(base);
2426 event_config_free(cfg);
2430 test_version(void *arg)
2434 int major, minor, patch, n;
2436 vstr = event_get_version();
2437 vint = event_get_version_number();
2442 tt_str_op(vstr, ==, LIBEVENT_VERSION);
2443 tt_int_op(vint, ==, LIBEVENT_VERSION_NUMBER);
2445 n = sscanf(vstr, "%d.%d.%d", &major, &minor, &patch);
2447 tt_int_op((vint&0xffffff00), ==, ((major<<24)|(minor<<16)|(patch<<8)));
2453 test_base_features(void *arg)
2455 struct event_base *base = NULL;
2456 struct event_config *cfg = NULL;
2458 cfg = event_config_new();
2460 tt_assert(0 == event_config_require_features(cfg, EV_FEATURE_ET));
2462 base = event_base_new_with_config(cfg);
2464 tt_int_op(EV_FEATURE_ET, ==,
2465 event_base_get_features(base) & EV_FEATURE_ET);
2467 base = event_base_new();
2468 tt_int_op(0, ==, event_base_get_features(base) & EV_FEATURE_ET);
2473 event_base_free(base);
2475 event_config_free(cfg);
2478 #ifdef EVENT__HAVE_SETENV
2480 #elif !defined(EVENT__HAVE_SETENV) && defined(EVENT__HAVE_PUTENV)
2481 static void setenv(const char *k, const char *v, int o_)
2484 evutil_snprintf(b, sizeof(b), "%s=%s",k,v);
2490 #ifdef EVENT__HAVE_UNSETENV
2492 #elif !defined(EVENT__HAVE_UNSETENV) && defined(EVENT__HAVE_PUTENV)
2493 static void unsetenv(const char *k)
2496 evutil_snprintf(b, sizeof(b), "%s=",k);
2502 #if defined(SETENV_OK) && defined(UNSETENV_OK)
2504 methodname_to_envvar(const char *mname, char *buf, size_t buflen)
2507 evutil_snprintf(buf, buflen, "EVENT_NO%s", mname);
2508 for (cp = buf; *cp; ++cp) {
2509 *cp = EVUTIL_TOUPPER_(*cp);
2515 test_base_environ(void *arg)
2517 struct event_base *base = NULL;
2518 struct event_config *cfg = NULL;
2520 #if defined(SETENV_OK) && defined(UNSETENV_OK)
2521 const char **basenames;
2524 const char *defaultname, *ignoreenvname;
2526 /* See if unsetenv works before we rely on it. */
2527 setenv("EVENT_NOWAFFLES", "1", 1);
2528 unsetenv("EVENT_NOWAFFLES");
2529 if (getenv("EVENT_NOWAFFLES") != NULL) {
2530 #ifndef EVENT__HAVE_UNSETENV
2531 TT_DECLARE("NOTE", ("Can't fake unsetenv; skipping test"));
2533 TT_DECLARE("NOTE", ("unsetenv doesn't work; skipping test"));
2538 basenames = event_get_supported_methods();
2539 for (i = 0; basenames[i]; ++i) {
2540 methodname_to_envvar(basenames[i], varbuf, sizeof(varbuf));
2545 base = event_base_new();
2548 defaultname = event_base_get_method(base);
2549 TT_BLATHER(("default is <%s>", defaultname));
2550 event_base_free(base);
2553 /* Can we disable the method with EVENT_NOfoo ? */
2554 if (!strcmp(defaultname, "epoll (with changelist)")) {
2555 setenv("EVENT_NOEPOLL", "1", 1);
2556 ignoreenvname = "epoll";
2558 methodname_to_envvar(defaultname, varbuf, sizeof(varbuf));
2559 setenv(varbuf, "1", 1);
2560 ignoreenvname = defaultname;
2563 /* Use an empty cfg rather than NULL so a failure doesn't exit() */
2564 cfg = event_config_new();
2565 base = event_base_new_with_config(cfg);
2566 event_config_free(cfg);
2568 if (n_methods == 1) {
2572 tt_str_op(defaultname, !=, event_base_get_method(base));
2573 event_base_free(base);
2577 /* Can we disable looking at the environment with IGNORE_ENV ? */
2578 cfg = event_config_new();
2579 event_config_set_flag(cfg, EVENT_BASE_FLAG_IGNORE_ENV);
2580 base = event_base_new_with_config(cfg);
2582 tt_str_op(ignoreenvname, ==, event_base_get_method(base));
2589 event_base_free(base);
2591 event_config_free(cfg);
2595 read_called_once_cb(evutil_socket_t fd, short event, void *arg)
2597 tt_int_op(event, ==, EV_READ);
2604 timeout_called_once_cb(evutil_socket_t fd, short event, void *arg)
2606 tt_int_op(event, ==, EV_TIMEOUT);
2613 immediate_called_twice_cb(evutil_socket_t fd, short event, void *arg)
2615 tt_int_op(event, ==, EV_TIMEOUT);
2622 test_event_once(void *ptr)
2624 struct basic_test_data *data = ptr;
2629 tv.tv_usec = 50*1000;
2631 r = event_base_once(data->base, data->pair[0], EV_READ,
2632 read_called_once_cb, NULL, NULL);
2633 tt_int_op(r, ==, 0);
2634 r = event_base_once(data->base, -1, EV_TIMEOUT,
2635 timeout_called_once_cb, NULL, &tv);
2636 tt_int_op(r, ==, 0);
2637 r = event_base_once(data->base, -1, 0, NULL, NULL, NULL);
2639 r = event_base_once(data->base, -1, EV_TIMEOUT,
2640 immediate_called_twice_cb, NULL, NULL);
2641 tt_int_op(r, ==, 0);
2644 r = event_base_once(data->base, -1, EV_TIMEOUT,
2645 immediate_called_twice_cb, NULL, &tv);
2646 tt_int_op(r, ==, 0);
2648 if (write(data->pair[1], TEST1, strlen(TEST1)+1) < 0) {
2649 tt_fail_perror("write");
2652 shutdown(data->pair[1], SHUT_WR);
2654 event_base_dispatch(data->base);
2656 tt_int_op(called, ==, 2101);
2662 test_event_once_never(void *ptr)
2664 struct basic_test_data *data = ptr;
2667 /* Have one trigger in 10 seconds (don't worry, because) */
2671 event_base_once(data->base, -1, EV_TIMEOUT,
2672 timeout_called_once_cb, NULL, &tv);
2674 /* But shut down the base in 75 msec. */
2676 tv.tv_usec = 75*1000;
2677 event_base_loopexit(data->base, &tv);
2679 event_base_dispatch(data->base);
2681 tt_int_op(called, ==, 0);
2687 test_event_pending(void *ptr)
2689 struct basic_test_data *data = ptr;
2690 struct event *r=NULL, *w=NULL, *t=NULL;
2691 struct timeval tv, now, tv2;
2694 tv.tv_usec = 500 * 1000;
2695 r = event_new(data->base, data->pair[0], EV_READ, simple_read_cb,
2697 w = event_new(data->base, data->pair[1], EV_WRITE, simple_write_cb,
2699 t = evtimer_new(data->base, timeout_cb, NULL);
2705 evutil_gettimeofday(&now, NULL);
2709 tt_assert( event_pending(r, EV_READ, NULL));
2710 tt_assert(!event_pending(w, EV_WRITE, NULL));
2711 tt_assert(!event_pending(r, EV_WRITE, NULL));
2712 tt_assert( event_pending(r, EV_READ|EV_WRITE, NULL));
2713 tt_assert(!event_pending(r, EV_TIMEOUT, NULL));
2714 tt_assert( event_pending(t, EV_TIMEOUT, NULL));
2715 tt_assert( event_pending(t, EV_TIMEOUT, &tv2));
2717 tt_assert(evutil_timercmp(&tv2, &now, >));
2719 test_timeval_diff_eq(&now, &tv2, 500);
2737 /* You can't do this test on windows, since dup2 doesn't work on sockets */
2740 dfd_cb(evutil_socket_t fd, short e, void *data)
2742 *(int*)data = (int)e;
2745 /* Regression test for our workaround for a fun epoll/linux related bug
2746 * where fd2 = dup(fd1); add(fd2); close(fd2); dup2(fd1,fd2); add(fd2)
2747 * will get you an EEXIST */
2749 test_dup_fd(void *arg)
2751 struct basic_test_data *data = arg;
2752 struct event_base *base = data->base;
2753 struct event *ev1=NULL, *ev2=NULL;
2755 int ev1_got, ev2_got;
2757 tt_int_op(write(data->pair[0], "Hello world",
2758 strlen("Hello world")), >, 0);
2762 tt_int_op(dfd, >=, 0);
2764 ev1 = event_new(base, fd, EV_READ|EV_PERSIST, dfd_cb, &ev1_got);
2765 ev2 = event_new(base, dfd, EV_READ|EV_PERSIST, dfd_cb, &ev2_got);
2766 ev1_got = ev2_got = 0;
2767 event_add(ev1, NULL);
2768 event_add(ev2, NULL);
2769 event_base_loop(base, EVLOOP_ONCE);
2770 tt_int_op(ev1_got, ==, EV_READ);
2771 tt_int_op(ev2_got, ==, EV_READ);
2773 /* Now close and delete dfd then dispatch. We need to do the
2774 * dispatch here so that when we add it later, we think there
2775 * was an intermediate delete. */
2778 ev1_got = ev2_got = 0;
2779 event_base_loop(base, EVLOOP_ONCE);
2780 tt_want_int_op(ev1_got, ==, EV_READ);
2781 tt_int_op(ev2_got, ==, 0);
2783 /* Re-duplicate the fd. We need to get the same duplicated
2784 * value that we closed to provoke the epoll quirk. Also, we
2785 * need to change the events to write, or else the old lingering
2786 * read event will make the test pass whether the change was
2787 * successful or not. */
2788 tt_int_op(dup2(fd, dfd), ==, dfd);
2790 ev2 = event_new(base, dfd, EV_WRITE|EV_PERSIST, dfd_cb, &ev2_got);
2791 event_add(ev2, NULL);
2792 ev1_got = ev2_got = 0;
2793 event_base_loop(base, EVLOOP_ONCE);
2794 tt_want_int_op(ev1_got, ==, EV_READ);
2795 tt_int_op(ev2_got, ==, EV_WRITE);
2807 #ifdef EVENT__DISABLE_MM_REPLACEMENT
2809 test_mm_functions(void *arg)
2811 tinytest_set_test_skipped_();
2815 check_dummy_mem_ok(void *mem_)
2819 return !memcmp(mem, "{[<guardedram>]}", 16);
2823 dummy_malloc(size_t len)
2825 char *mem = malloc(len+16);
2827 fprintf(stderr, "Unable to allocate memory in dummy_malloc()\n");
2830 memcpy(mem, "{[<guardedram>]}", 16);
2835 dummy_realloc(void *mem_, size_t len)
2839 return dummy_malloc(len);
2840 tt_want(check_dummy_mem_ok(mem_));
2842 mem = realloc(mem, len+16);
2847 dummy_free(void *mem_)
2850 tt_want(check_dummy_mem_ok(mem_));
2856 test_mm_functions(void *arg)
2858 struct event_base *b = NULL;
2859 struct event_config *cfg = NULL;
2860 event_set_mem_functions(dummy_malloc, dummy_realloc, dummy_free);
2861 cfg = event_config_new();
2862 event_config_avoid_method(cfg, "Nonesuch");
2863 b = event_base_new_with_config(cfg);
2865 tt_assert(check_dummy_mem_ok(b));
2868 event_config_free(cfg);
2875 many_event_cb(evutil_socket_t fd, short event, void *arg)
2882 test_many_events(void *arg)
2884 /* Try 70 events that should all be ready at once. This will
2885 * exercise the "resize" code on most of the backends, and will make
2886 * sure that we can get past the 64-handle limit of some windows
2890 struct basic_test_data *data = arg;
2891 struct event_base *base = data->base;
2892 int one_at_a_time = data->setup_data != NULL;
2893 evutil_socket_t sock[MANY];
2894 struct event *ev[MANY];
2897 int loopflags = EVLOOP_NONBLOCK, evflags=0;
2898 if (one_at_a_time) {
2899 loopflags |= EVLOOP_ONCE;
2900 evflags = EV_PERSIST;
2903 memset(sock, 0xff, sizeof(sock));
2904 memset(ev, 0, sizeof(ev));
2905 memset(called, 0, sizeof(called));
2907 for (i = 0; i < MANY; ++i) {
2908 /* We need an event that will hit the backend, and that will
2909 * be ready immediately. "Send a datagram" is an easy
2910 * instance of that. */
2911 sock[i] = socket(AF_INET, SOCK_DGRAM, 0);
2912 tt_assert(sock[i] >= 0);
2914 ev[i] = event_new(base, sock[i], EV_WRITE|evflags,
2915 many_event_cb, &called[i]);
2916 event_add(ev[i], NULL);
2918 event_base_loop(base, EVLOOP_NONBLOCK|EVLOOP_ONCE);
2921 event_base_loop(base, loopflags);
2923 for (i = 0; i < MANY; ++i) {
2925 tt_int_op(called[i], ==, MANY - i + 1);
2927 tt_int_op(called[i], ==, 1);
2931 for (i = 0; i < MANY; ++i) {
2935 evutil_closesocket(sock[i]);
2941 test_struct_event_size(void *arg)
2943 tt_int_op(event_get_struct_event_size(), <=, sizeof(struct event));
2949 test_get_assignment(void *arg)
2951 struct basic_test_data *data = arg;
2952 struct event_base *base = data->base;
2953 struct event *ev1 = NULL;
2954 const char *str = "foo";
2956 struct event_base *b;
2959 event_callback_fn cb;
2962 ev1 = event_new(base, data->pair[1], EV_READ, dummy_read_cb, (void*)str);
2963 event_get_assignment(ev1, &b, &s, &what, &cb, &cb_arg);
2965 tt_ptr_op(b, ==, base);
2966 tt_int_op(s, ==, data->pair[1]);
2967 tt_int_op(what, ==, EV_READ);
2968 tt_ptr_op(cb, ==, dummy_read_cb);
2969 tt_ptr_op(cb_arg, ==, str);
2971 /* Now make sure this doesn't crash. */
2972 event_get_assignment(ev1, NULL, NULL, NULL, NULL, NULL);
2979 struct foreach_helper {
2981 const struct event *ev;
2985 foreach_count_cb(const struct event_base *base, const struct event *ev, void *arg)
2987 struct foreach_helper *h = event_get_callback_arg(ev);
2988 struct timeval *tv = arg;
2989 if (event_get_callback(ev) != timeout_cb)
2991 tt_ptr_op(event_get_base(ev), ==, base);
2992 tt_int_op(tv->tv_sec, ==, 10);
3001 foreach_find_cb(const struct event_base *base, const struct event *ev, void *arg)
3003 const struct event **ev_out = arg;
3004 struct foreach_helper *h = event_get_callback_arg(ev);
3005 if (event_get_callback(ev) != timeout_cb)
3007 if (h->count == 99) {
3015 test_event_foreach(void *arg)
3017 struct basic_test_data *data = arg;
3018 struct event_base *base = data->base;
3019 struct event *ev[5];
3020 struct foreach_helper visited[5];
3022 struct timeval ten_sec = {10,0};
3023 const struct event *ev_found = NULL;
3025 for (i = 0; i < 5; ++i) {
3026 visited[i].count = 0;
3027 visited[i].ev = NULL;
3028 ev[i] = event_new(base, -1, 0, timeout_cb, &visited[i]);
3031 tt_int_op(-1, ==, event_base_foreach_event(NULL, foreach_count_cb, NULL));
3032 tt_int_op(-1, ==, event_base_foreach_event(base, NULL, NULL));
3034 event_add(ev[0], &ten_sec);
3035 event_add(ev[1], &ten_sec);
3036 event_active(ev[1], EV_TIMEOUT, 1);
3037 event_active(ev[2], EV_TIMEOUT, 1);
3038 event_add(ev[3], &ten_sec);
3039 /* Don't touch ev[4]. */
3041 tt_int_op(0, ==, event_base_foreach_event(base, foreach_count_cb,
3043 tt_int_op(1, ==, visited[0].count);
3044 tt_int_op(1, ==, visited[1].count);
3045 tt_int_op(1, ==, visited[2].count);
3046 tt_int_op(1, ==, visited[3].count);
3047 tt_ptr_op(ev[0], ==, visited[0].ev);
3048 tt_ptr_op(ev[1], ==, visited[1].ev);
3049 tt_ptr_op(ev[2], ==, visited[2].ev);
3050 tt_ptr_op(ev[3], ==, visited[3].ev);
3052 visited[2].count = 99;
3053 tt_int_op(101, ==, event_base_foreach_event(base, foreach_find_cb,
3055 tt_ptr_op(ev_found, ==, ev[2]);
3058 for (i=0; i<5; ++i) {
3063 static struct event_base *cached_time_base = NULL;
3064 static int cached_time_reset = 0;
3065 static int cached_time_sleep = 0;
3067 cache_time_cb(evutil_socket_t fd, short what, void *arg)
3069 struct timeval *tv = arg;
3070 tt_int_op(0, ==, event_base_gettimeofday_cached(cached_time_base, tv));
3071 if (cached_time_sleep) {
3072 struct timeval delay = { 0, 30*1000 };
3073 evutil_usleep_(&delay);
3075 if (cached_time_reset) {
3076 event_base_update_cache_time(cached_time_base);
3083 test_gettimeofday_cached(void *arg)
3085 struct basic_test_data *data = arg;
3086 struct event_config *cfg = NULL;
3087 struct event_base *base = NULL;
3088 struct timeval tv1, tv2, tv3, now;
3089 struct event *ev1=NULL, *ev2=NULL, *ev3=NULL;
3090 int cached_time_disable = strstr(data->setup_data, "disable") != NULL;
3092 cfg = event_config_new();
3093 if (cached_time_disable) {
3094 event_config_set_flag(cfg, EVENT_BASE_FLAG_NO_CACHE_TIME);
3096 cached_time_base = base = event_base_new_with_config(cfg);
3099 /* Try gettimeofday_cached outside of an event loop. */
3100 evutil_gettimeofday(&now, NULL);
3101 tt_int_op(0, ==, event_base_gettimeofday_cached(NULL, &tv1));
3102 tt_int_op(0, ==, event_base_gettimeofday_cached(base, &tv2));
3103 tt_int_op(timeval_msec_diff(&tv1, &tv2), <, 10);
3104 tt_int_op(timeval_msec_diff(&tv1, &now), <, 10);
3106 cached_time_reset = strstr(data->setup_data, "reset") != NULL;
3107 cached_time_sleep = strstr(data->setup_data, "sleep") != NULL;
3109 ev1 = event_new(base, -1, 0, cache_time_cb, &tv1);
3110 ev2 = event_new(base, -1, 0, cache_time_cb, &tv2);
3111 ev3 = event_new(base, -1, 0, cache_time_cb, &tv3);
3113 event_active(ev1, EV_TIMEOUT, 1);
3114 event_active(ev2, EV_TIMEOUT, 1);
3115 event_active(ev3, EV_TIMEOUT, 1);
3117 event_base_dispatch(base);
3119 if (cached_time_reset && cached_time_sleep) {
3120 tt_int_op(labs(timeval_msec_diff(&tv1,&tv2)), >, 10);
3121 tt_int_op(labs(timeval_msec_diff(&tv2,&tv3)), >, 10);
3122 } else if (cached_time_disable && cached_time_sleep) {
3123 tt_int_op(labs(timeval_msec_diff(&tv1,&tv2)), >, 10);
3124 tt_int_op(labs(timeval_msec_diff(&tv2,&tv3)), >, 10);
3125 } else if (! cached_time_disable) {
3126 tt_assert(evutil_timercmp(&tv1, &tv2, ==));
3127 tt_assert(evutil_timercmp(&tv2, &tv3, ==));
3138 event_base_free(base);
3140 event_config_free(cfg);
3144 tabf_cb(evutil_socket_t fd, short what, void *arg)
3152 test_active_by_fd(void *arg)
3154 struct basic_test_data *data = arg;
3155 struct event_base *base = data->base;
3156 struct event *ev1 = NULL, *ev2 = NULL, *ev3 = NULL, *ev4 = NULL;
3159 struct event *evsig = NULL;
3162 struct timeval tenmin = { 600, 0 };
3164 /* Ensure no crash on nonexistent FD. */
3165 event_base_active_by_fd(base, 1000, EV_READ);
3167 /* Ensure no crash on bogus FD. */
3168 event_base_active_by_fd(base, -1, EV_READ);
3170 /* Ensure no crash on nonexistent/bogus signal. */
3171 event_base_active_by_signal(base, 1000);
3172 event_base_active_by_signal(base, -1);
3174 event_base_assert_ok_(base);
3176 e1 = e2 = e3 = e4 = 0;
3177 ev1 = event_new(base, data->pair[0], EV_READ, tabf_cb, &e1);
3178 ev2 = event_new(base, data->pair[0], EV_WRITE, tabf_cb, &e2);
3179 ev3 = event_new(base, data->pair[1], EV_READ, tabf_cb, &e3);
3180 ev4 = event_new(base, data->pair[1], EV_READ, tabf_cb, &e4);
3186 evsig = event_new(base, SIGHUP, EV_SIGNAL, tabf_cb, &es);
3188 event_add(evsig, &tenmin);
3191 event_add(ev1, &tenmin);
3192 event_add(ev2, NULL);
3193 event_add(ev3, NULL);
3194 event_add(ev4, &tenmin);
3197 event_base_assert_ok_(base);
3199 /* Trigger 2, 3, 4 */
3200 event_base_active_by_fd(base, data->pair[0], EV_WRITE);
3201 event_base_active_by_fd(base, data->pair[1], EV_READ);
3203 event_base_active_by_signal(base, SIGHUP);
3206 event_base_assert_ok_(base);
3208 event_base_loop(base, EVLOOP_ONCE);
3210 tt_int_op(e1, ==, 0);
3211 tt_int_op(e2, ==, EV_WRITE | 0x10000);
3212 tt_int_op(e3, ==, EV_READ | 0x10000);
3213 /* Mask out EV_WRITE here, since it could be genuinely writeable. */
3214 tt_int_op((e4 & ~EV_WRITE), ==, EV_READ | 0x10000);
3216 tt_int_op(es, ==, EV_SIGNAL | 0x10000);
3234 struct testcase_t main_testcases[] = {
3235 /* Some converted-over tests */
3236 { "methods", test_methods, TT_FORK, NULL, NULL },
3237 { "version", test_version, 0, NULL, NULL },
3238 BASIC(base_features, TT_FORK|TT_NO_LOGS),
3239 { "base_environ", test_base_environ, TT_FORK, NULL, NULL },
3241 BASIC(event_base_new, TT_FORK|TT_NEED_SOCKETPAIR),
3242 BASIC(free_active_base, TT_FORK|TT_NEED_SOCKETPAIR),
3244 BASIC(manipulate_active_events, TT_FORK|TT_NEED_BASE),
3245 BASIC(event_new_selfarg, TT_FORK|TT_NEED_BASE),
3246 BASIC(event_assign_selfarg, TT_FORK|TT_NEED_BASE),
3247 BASIC(event_base_get_num_events, TT_FORK|TT_NEED_BASE),
3248 BASIC(event_base_get_max_events, TT_FORK|TT_NEED_BASE),
3250 BASIC(bad_assign, TT_FORK|TT_NEED_BASE|TT_NO_LOGS),
3251 BASIC(bad_reentrant, TT_FORK|TT_NEED_BASE|TT_NO_LOGS),
3252 BASIC(active_later, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR),
3253 BASIC(event_remove_timeout, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR),
3255 /* These are still using the old API */
3256 LEGACY(persistent_timeout, TT_FORK|TT_NEED_BASE),
3257 { "persistent_timeout_jump", test_persistent_timeout_jump, TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
3258 { "persistent_active_timeout", test_persistent_active_timeout,
3259 TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
3260 LEGACY(priorities, TT_FORK|TT_NEED_BASE),
3261 BASIC(priority_active_inversion, TT_FORK|TT_NEED_BASE),
3262 { "common_timeout", test_common_timeout, TT_FORK|TT_NEED_BASE,
3263 &basic_setup, NULL },
3265 /* These legacy tests may not all need all of these flags. */
3266 LEGACY(simpleread, TT_ISOLATED),
3267 LEGACY(simpleread_multiple, TT_ISOLATED),
3268 LEGACY(simplewrite, TT_ISOLATED),
3269 { "simpleclose", test_simpleclose, TT_FORK, &basic_setup,
3271 LEGACY(multiple, TT_ISOLATED),
3272 LEGACY(persistent, TT_ISOLATED),
3273 LEGACY(combined, TT_ISOLATED),
3274 LEGACY(simpletimeout, TT_ISOLATED),
3275 LEGACY(loopbreak, TT_ISOLATED),
3276 LEGACY(loopexit, TT_ISOLATED),
3277 LEGACY(loopexit_multiple, TT_ISOLATED),
3278 LEGACY(nonpersist_readd, TT_ISOLATED),
3279 LEGACY(multiple_events_for_same_fd, TT_ISOLATED),
3280 LEGACY(want_only_once, TT_ISOLATED),
3281 { "event_once", test_event_once, TT_ISOLATED, &basic_setup, NULL },
3282 { "event_once_never", test_event_once_never, TT_ISOLATED, &basic_setup, NULL },
3283 { "event_pending", test_event_pending, TT_ISOLATED, &basic_setup,
3286 { "dup_fd", test_dup_fd, TT_ISOLATED, &basic_setup, NULL },
3288 { "mm_functions", test_mm_functions, TT_FORK, NULL, NULL },
3289 { "many_events", test_many_events, TT_ISOLATED, &basic_setup, NULL },
3290 { "many_events_slow_add", test_many_events, TT_ISOLATED, &basic_setup, (void*)1 },
3292 { "struct_event_size", test_struct_event_size, 0, NULL, NULL },
3293 BASIC(get_assignment, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR),
3295 BASIC(event_foreach, TT_FORK|TT_NEED_BASE),
3296 { "gettimeofday_cached", test_gettimeofday_cached, TT_FORK, &basic_setup, (void*)"" },
3297 { "gettimeofday_cached_sleep", test_gettimeofday_cached, TT_FORK, &basic_setup, (void*)"sleep" },
3298 { "gettimeofday_cached_reset", test_gettimeofday_cached, TT_FORK, &basic_setup, (void*)"sleep reset" },
3299 { "gettimeofday_cached_disabled", test_gettimeofday_cached, TT_FORK, &basic_setup, (void*)"sleep disable" },
3300 { "gettimeofday_cached_disabled_nosleep", test_gettimeofday_cached, TT_FORK, &basic_setup, (void*)"disable" },
3302 BASIC(active_by_fd, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR),
3305 LEGACY(fork, TT_ISOLATED),
3310 struct testcase_t evtag_testcases[] = {
3311 { "int", evtag_int_test, TT_FORK, NULL, NULL },
3312 { "fuzz", evtag_fuzz, TT_FORK, NULL, NULL },
3313 { "encoding", evtag_tag_encoding, TT_FORK, NULL, NULL },
3314 { "peek", evtag_test_peek, 0, NULL, NULL },
3319 struct testcase_t signal_testcases[] = {
3321 LEGACY(simplestsignal, TT_ISOLATED),
3322 LEGACY(simplesignal, TT_ISOLATED),
3323 LEGACY(multiplesignal, TT_ISOLATED),
3324 LEGACY(immediatesignal, TT_ISOLATED),
3325 LEGACY(signal_dealloc, TT_ISOLATED),
3326 LEGACY(signal_pipeloss, TT_ISOLATED),
3327 LEGACY(signal_switchbase, TT_ISOLATED|TT_NO_LOGS),
3328 LEGACY(signal_restore, TT_ISOLATED),
3329 LEGACY(signal_assert, TT_ISOLATED),
3330 LEGACY(signal_while_processing, TT_ISOLATED),