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.
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 if (write(pair
[0], TEST1
, strlen(TEST1
)+1) < 0) {
320 tt_fail_perror("write");
323 shutdown(pair
[0], SHUT_WR
);
325 event_set(&ev
, pair
[1], EV_READ
, simple_read_cb
, &ev
);
326 if (event_add(&ev
, NULL
) == -1)
334 test_simplewrite(void)
338 /* Very simple write test */
339 setup_test("Simple write: ");
341 event_set(&ev
, pair
[0], EV_WRITE
, simple_write_cb
, &ev
);
342 if (event_add(&ev
, NULL
) == -1)
350 simpleread_multiple_cb(evutil_socket_t fd
, short event
, void *arg
)
357 test_simpleread_multiple(void)
359 struct event one
, two
;
361 /* Very simple read test */
362 setup_test("Simple read to multiple evens: ");
364 if (write(pair
[0], TEST1
, strlen(TEST1
)+1) < 0) {
365 tt_fail_perror("write");
368 shutdown(pair
[0], SHUT_WR
);
370 event_set(&one
, pair
[1], EV_READ
, simpleread_multiple_cb
, NULL
);
371 if (event_add(&one
, NULL
) == -1)
373 event_set(&two
, pair
[1], EV_READ
, simpleread_multiple_cb
, NULL
);
374 if (event_add(&two
, NULL
) == -1)
381 static int have_closed
= 0;
382 static int premature_event
= 0;
384 simpleclose_close_fd_cb(evutil_socket_t s
, short what
, void *ptr
)
386 evutil_socket_t
**fds
= ptr
;
387 TT_BLATHER(("Closing"));
388 evutil_closesocket(*fds
[0]);
389 evutil_closesocket(*fds
[1]);
396 record_event_cb(evutil_socket_t s
, short what
, void *ptr
)
402 TT_BLATHER(("Recorded %d on socket %d", (int)what
, (int)s
));
406 test_simpleclose(void *ptr
)
408 /* Test that a close of FD is detected as a read and as a write. */
409 struct event_base
*base
= event_base_new();
410 evutil_socket_t pair1
[2]={-1,-1}, pair2
[2] = {-1, -1};
411 evutil_socket_t
*to_close
[2];
412 struct event
*rev
=NULL
, *wev
=NULL
, *closeev
=NULL
;
414 short got_read_on_close
= 0, got_write_on_close
= 0;
416 memset(buf
, 99, sizeof(buf
));
418 #define LOCAL_SOCKETPAIR_AF AF_INET
420 #define LOCAL_SOCKETPAIR_AF AF_UNIX
422 if (evutil_socketpair(LOCAL_SOCKETPAIR_AF
, SOCK_STREAM
, 0, pair1
)<0)
423 TT_DIE(("socketpair: %s", strerror(errno
)));
424 if (evutil_socketpair(LOCAL_SOCKETPAIR_AF
, SOCK_STREAM
, 0, pair2
)<0)
425 TT_DIE(("socketpair: %s", strerror(errno
)));
426 if (evutil_make_socket_nonblocking(pair1
[1]) < 0)
427 TT_DIE(("make_socket_nonblocking"));
428 if (evutil_make_socket_nonblocking(pair2
[1]) < 0)
429 TT_DIE(("make_socket_nonblocking"));
431 /** Stuff pair2[1] full of data, until write fails */
433 int r
= write(pair2
[1], buf
, sizeof(buf
));
435 int err
= evutil_socket_geterror(pair2
[1]);
436 if (! EVUTIL_ERR_RW_RETRIABLE(err
))
437 TT_DIE(("write failed strangely: %s",
438 evutil_socket_error_to_string(err
)));
442 to_close
[0] = &pair1
[0];
443 to_close
[1] = &pair2
[0];
445 closeev
= event_new(base
, -1, EV_TIMEOUT
, simpleclose_close_fd_cb
,
447 rev
= event_new(base
, pair1
[1], EV_READ
, record_event_cb
,
449 TT_BLATHER(("Waiting for read on %d", (int)pair1
[1]));
450 wev
= event_new(base
, pair2
[1], EV_WRITE
, record_event_cb
,
451 &got_write_on_close
);
452 TT_BLATHER(("Waiting for write on %d", (int)pair2
[1]));
454 tv
.tv_usec
= 100*1000; /* Close pair1[0] after a little while, and make
455 * sure we get a read event. */
456 event_add(closeev
, &tv
);
457 event_add(rev
, NULL
);
458 event_add(wev
, NULL
);
459 /* Don't let the test go on too long. */
461 tv
.tv_usec
= 200*1000;
462 event_base_loopexit(base
, &tv
);
463 event_base_loop(base
, 0);
465 tt_int_op(got_read_on_close
, ==, EV_READ
);
466 tt_int_op(got_write_on_close
, ==, EV_WRITE
);
467 tt_int_op(premature_event
, ==, 0);
471 evutil_closesocket(pair1
[0]);
473 evutil_closesocket(pair1
[1]);
475 evutil_closesocket(pair2
[0]);
477 evutil_closesocket(pair2
[1]);
485 event_base_free(base
);
492 struct event ev
, ev2
;
495 /* Multiple read and write test */
496 setup_test("Multiple read/write: ");
497 memset(rbuf
, 0, sizeof(rbuf
));
498 for (i
= 0; i
< (int)sizeof(wbuf
); i
++)
504 event_set(&ev
, pair
[0], EV_WRITE
, multiple_write_cb
, &ev
);
505 if (event_add(&ev
, NULL
) == -1)
507 event_set(&ev2
, pair
[1], EV_READ
, multiple_read_cb
, &ev2
);
508 if (event_add(&ev2
, NULL
) == -1)
513 test_ok
= memcmp(rbuf
, wbuf
, sizeof(wbuf
)) == 0;
519 test_persistent(void)
521 struct event ev
, ev2
;
524 /* Multiple read and write test with persist */
525 setup_test("Persist read/write: ");
526 memset(rbuf
, 0, sizeof(rbuf
));
527 for (i
= 0; i
< (int)sizeof(wbuf
); i
++)
533 event_set(&ev
, pair
[0], EV_WRITE
|EV_PERSIST
, multiple_write_cb
, &ev
);
534 if (event_add(&ev
, NULL
) == -1)
536 event_set(&ev2
, pair
[1], EV_READ
|EV_PERSIST
, multiple_read_cb
, &ev2
);
537 if (event_add(&ev2
, NULL
) == -1)
542 test_ok
= memcmp(rbuf
, wbuf
, sizeof(wbuf
)) == 0;
550 struct both r1
, r2
, w1
, w2
;
552 setup_test("Combined read/write: ");
553 memset(&r1
, 0, sizeof(r1
));
554 memset(&r2
, 0, sizeof(r2
));
555 memset(&w1
, 0, sizeof(w1
));
556 memset(&w2
, 0, sizeof(w2
));
561 event_set(&r1
.ev
, pair
[0], EV_READ
, combined_read_cb
, &r1
);
562 event_set(&w1
.ev
, pair
[0], EV_WRITE
, combined_write_cb
, &w1
);
563 event_set(&r2
.ev
, pair
[1], EV_READ
, combined_read_cb
, &r2
);
564 event_set(&w2
.ev
, pair
[1], EV_WRITE
, combined_write_cb
, &w2
);
565 tt_assert(event_add(&r1
.ev
, NULL
) != -1);
566 tt_assert(!event_add(&w1
.ev
, NULL
));
567 tt_assert(!event_add(&r2
.ev
, NULL
));
568 tt_assert(!event_add(&w2
.ev
, NULL
));
571 if (r1
.nread
== 8192 && r2
.nread
== 4096)
579 test_simpletimeout(void)
584 setup_test("Simple timeout: ");
588 evtimer_set(&ev
, timeout_cb
, NULL
);
589 evtimer_add(&ev
, &tv
);
591 evutil_gettimeofday(&tset
, NULL
);
598 periodic_timeout_cb(evutil_socket_t fd
, short event
, void *arg
)
604 /* call loopexit only once - on slow machines(?), it is
605 * apparently possible for this to get called twice. */
607 event_base_loopexit(global_base
, NULL
);
612 test_persistent_timeout(void)
618 evutil_timerclear(&tv
);
621 event_assign(&ev
, global_base
, -1, EV_TIMEOUT
|EV_PERSIST
,
622 periodic_timeout_cb
, &count
);
631 test_persistent_timeout_jump(void *ptr
)
633 struct basic_test_data
*data
= ptr
;
636 struct timeval msec100
= { 0, 100 * 1000 };
637 struct timeval msec50
= { 0, 50 * 1000 };
639 event_assign(&ev
, data
->base
, -1, EV_PERSIST
, periodic_timeout_cb
, &count
);
640 event_add(&ev
, &msec100
);
647 event_base_loopexit(data
->base
, &msec50
);
648 event_base_dispatch(data
->base
);
649 tt_int_op(count
, ==, 1);
655 struct persist_active_timeout_called
{
658 struct timeval tvs
[16];
662 activate_cb(evutil_socket_t fd
, short event
, void *arg
)
664 struct event
*ev
= arg
;
665 event_active(ev
, EV_READ
, 1);
669 persist_active_timeout_cb(evutil_socket_t fd
, short event
, void *arg
)
671 struct persist_active_timeout_called
*c
= arg
;
673 c
->events
[c
->n
] = event
;
674 evutil_gettimeofday(&c
->tvs
[c
->n
], NULL
);
680 test_persistent_active_timeout(void *ptr
)
682 struct timeval tv
, tv2
, tv_exit
, start
;
684 struct persist_active_timeout_called res
;
686 struct basic_test_data
*data
= ptr
;
687 struct event_base
*base
= data
->base
;
689 memset(&res
, 0, sizeof(res
));
692 tv
.tv_usec
= 200 * 1000;
693 event_assign(&ev
, base
, -1, EV_TIMEOUT
|EV_PERSIST
,
694 persist_active_timeout_cb
, &res
);
698 tv2
.tv_usec
= 100 * 1000;
699 event_base_once(base
, -1, EV_TIMEOUT
, activate_cb
, &ev
, &tv2
);
702 tv_exit
.tv_usec
= 600 * 1000;
703 event_base_loopexit(base
, &tv_exit
);
705 event_base_assert_ok(base
);
706 evutil_gettimeofday(&start
, NULL
);
708 event_base_dispatch(base
);
709 event_base_assert_ok(base
);
711 tt_int_op(res
.n
, ==, 3);
712 tt_int_op(res
.events
[0], ==, EV_READ
);
713 tt_int_op(res
.events
[1], ==, EV_TIMEOUT
);
714 tt_int_op(res
.events
[2], ==, EV_TIMEOUT
);
715 test_timeval_diff_eq(&start
, &res
.tvs
[0], 100);
716 test_timeval_diff_eq(&start
, &res
.tvs
[1], 300);
717 test_timeval_diff_eq(&start
, &res
.tvs
[2], 500);
722 struct common_timeout_info
{
724 struct timeval called_at
;
730 common_timeout_cb(evutil_socket_t fd
, short event
, void *arg
)
732 struct common_timeout_info
*ti
= arg
;
734 evutil_gettimeofday(&ti
->called_at
, NULL
);
740 test_common_timeout(void *ptr
)
742 struct basic_test_data
*data
= ptr
;
744 struct event_base
*base
= data
->base
;
746 struct common_timeout_info info
[100];
749 struct timeval tmp_100_ms
= { 0, 100*1000 };
750 struct timeval tmp_200_ms
= { 0, 200*1000 };
752 const struct timeval
*ms_100
, *ms_200
;
754 ms_100
= event_base_init_common_timeout(base
, &tmp_100_ms
);
755 ms_200
= event_base_init_common_timeout(base
, &tmp_200_ms
);
758 tt_ptr_op(event_base_init_common_timeout(base
, &tmp_200_ms
),
760 tt_int_op(ms_100
->tv_sec
, ==, 0);
761 tt_int_op(ms_200
->tv_sec
, ==, 0);
762 tt_int_op(ms_100
->tv_usec
, ==, 100000|0x50000000);
763 tt_int_op(ms_200
->tv_usec
, ==, 200000|0x50100000);
765 memset(info
, 0, sizeof(info
));
767 for (i
=0; i
<100; ++i
) {
769 event_assign(&info
[i
].ev
, base
, -1, EV_TIMEOUT
|EV_PERSIST
,
770 common_timeout_cb
, &info
[i
]);
772 event_add(&info
[i
].ev
, ms_100
);
774 event_add(&info
[i
].ev
, ms_200
);
778 event_base_assert_ok(base
);
779 event_base_dispatch(base
);
781 evutil_gettimeofday(&now
, NULL
);
782 event_base_assert_ok(base
);
784 for (i
=0; i
<10; ++i
) {
787 tt_int_op(info
[i
].count
, ==, 6);
788 evutil_timersub(&now
, &info
[i
].called_at
, &tmp
);
789 ms_diff
= tmp
.tv_usec
/1000 + tmp
.tv_sec
*1000;
791 tt_int_op(ms_diff
, >, 500);
792 tt_int_op(ms_diff
, <, 700);
794 tt_int_op(ms_diff
, >, -100);
795 tt_int_op(ms_diff
, <, 100);
799 /* Make sure we can free the base with some events in. */
800 for (i
=0; i
<100; ++i
) {
802 event_add(&info
[i
].ev
, ms_100
);
804 event_add(&info
[i
].ev
, ms_200
);
809 event_base_free(data
->base
); /* need to do this here before info is
815 static void signal_cb(evutil_socket_t fd
, short event
, void *arg
);
817 #define current_base event_global_current_base_
818 extern struct event_base
*current_base
;
821 child_signal_cb(evutil_socket_t fd
, short event
, void *arg
)
836 int status
, got_sigchld
= 0;
837 struct event ev
, sig_ev
;
840 setup_test("After fork: ");
842 tt_assert(current_base
);
843 evthread_make_base_notifiable(current_base
);
845 if (write(pair
[0], TEST1
, strlen(TEST1
)+1) < 0) {
846 tt_fail_perror("write");
849 event_set(&ev
, pair
[1], EV_READ
, simple_read_cb
, &ev
);
850 if (event_add(&ev
, NULL
) == -1)
853 evsignal_set(&sig_ev
, SIGCHLD
, child_signal_cb
, &got_sigchld
);
854 evsignal_add(&sig_ev
, NULL
);
856 event_base_assert_ok(current_base
);
857 TT_BLATHER(("Before fork"));
858 if ((pid
= regress_fork()) == 0) {
860 TT_BLATHER(("In child, before reinit"));
861 event_base_assert_ok(current_base
);
862 if (event_reinit(current_base
) == -1) {
863 fprintf(stdout
, "FAILED (reinit)\n");
866 TT_BLATHER(("After reinit"));
867 event_base_assert_ok(current_base
);
868 TT_BLATHER(("After assert-ok"));
870 evsignal_del(&sig_ev
);
876 event_base_free(current_base
);
878 /* we do not send an EOF; simple_read_cb requires an EOF
879 * to set test_ok. we just verify that the callback was
881 exit(test_ok
!= 0 || called
!= 2 ? -2 : 76);
884 /* wait for the child to read the data */
887 if (write(pair
[0], TEST1
, strlen(TEST1
)+1) < 0) {
888 tt_fail_perror("write");
891 TT_BLATHER(("Before waitpid"));
892 if (waitpid(pid
, &status
, 0) == -1) {
893 fprintf(stdout
, "FAILED (fork)\n");
896 TT_BLATHER(("After waitpid"));
898 if (WEXITSTATUS(status
) != 76) {
899 fprintf(stdout
, "FAILED (exit): %d\n", WEXITSTATUS(status
));
903 /* test that the current event loop still works */
904 if (write(pair
[0], TEST1
, strlen(TEST1
)+1) < 0) {
905 fprintf(stderr
, "%s: write\n", __func__
);
908 shutdown(pair
[0], SHUT_WR
);
913 fprintf(stdout
, "FAILED (sigchld)\n");
917 evsignal_del(&sig_ev
);
924 signal_cb_sa(int sig
)
930 signal_cb(evutil_socket_t fd
, short event
, void *arg
)
932 struct event
*ev
= arg
;
939 test_simplesignal(void)
942 struct itimerval itv
;
944 setup_test("Simple signal: ");
945 evsignal_set(&ev
, SIGALRM
, signal_cb
, &ev
);
946 evsignal_add(&ev
, NULL
);
947 /* find bugs in which operations are re-ordered */
949 evsignal_add(&ev
, NULL
);
951 memset(&itv
, 0, sizeof(itv
));
952 itv
.it_value
.tv_sec
= 1;
953 if (setitimer(ITIMER_REAL
, &itv
, NULL
) == -1)
954 goto skip_simplesignal
;
958 if (evsignal_del(&ev
) == -1)
965 test_multiplesignal(void)
967 struct event ev_one
, ev_two
;
968 struct itimerval itv
;
970 setup_test("Multiple signal: ");
972 evsignal_set(&ev_one
, SIGALRM
, signal_cb
, &ev_one
);
973 evsignal_add(&ev_one
, NULL
);
975 evsignal_set(&ev_two
, SIGALRM
, signal_cb
, &ev_two
);
976 evsignal_add(&ev_two
, NULL
);
978 memset(&itv
, 0, sizeof(itv
));
979 itv
.it_value
.tv_sec
= 1;
980 if (setitimer(ITIMER_REAL
, &itv
, NULL
) == -1)
981 goto skip_simplesignal
;
986 if (evsignal_del(&ev_one
) == -1)
988 if (evsignal_del(&ev_two
) == -1)
995 test_immediatesignal(void)
1000 evsignal_set(&ev
, SIGUSR1
, signal_cb
, &ev
);
1001 evsignal_add(&ev
, NULL
);
1003 event_loop(EVLOOP_NONBLOCK
);
1009 test_signal_dealloc(void)
1011 /* make sure that evsignal_event is event_del'ed and pipe closed */
1013 struct event_base
*base
= event_init();
1014 evsignal_set(&ev
, SIGUSR1
, signal_cb
, &ev
);
1015 evsignal_add(&ev
, NULL
);
1017 event_base_free(base
);
1018 /* If we got here without asserting, we're fine. */
1024 test_signal_pipeloss(void)
1026 /* make sure that the base1 pipe is closed correctly. */
1027 struct event_base
*base1
, *base2
;
1030 base1
= event_init();
1031 pipe1
= base1
->sig
.ev_signal_pair
[0];
1032 base2
= event_init();
1033 event_base_free(base2
);
1034 event_base_free(base1
);
1035 if (close(pipe1
) != -1 || errno
!=EBADF
) {
1036 /* fd must be closed, so second close gives -1, EBADF */
1037 printf("signal pipe not closed. ");
1046 * make two bases to catch signals, use both of them. this only works
1047 * for event mechanisms that use our signal pipe trick. kqueue handles
1048 * signals internally, and all interested kqueues get all the signals.
1051 test_signal_switchbase(void)
1053 struct event ev1
, ev2
;
1054 struct event_base
*base1
, *base2
;
1057 base1
= event_init();
1058 base2
= event_init();
1059 is_kqueue
= !strcmp(event_get_method(),"kqueue");
1060 evsignal_set(&ev1
, SIGUSR1
, signal_cb
, &ev1
);
1061 evsignal_set(&ev2
, SIGUSR1
, signal_cb
, &ev2
);
1062 if (event_base_set(base1
, &ev1
) ||
1063 event_base_set(base2
, &ev2
) ||
1064 event_add(&ev1
, NULL
) ||
1065 event_add(&ev2
, NULL
)) {
1066 fprintf(stderr
, "%s: cannot set base, add\n", __func__
);
1070 tt_ptr_op(event_get_base(&ev1
), ==, base1
);
1071 tt_ptr_op(event_get_base(&ev2
), ==, base2
);
1074 /* can handle signal before loop is called */
1076 event_base_loop(base2
, EVLOOP_NONBLOCK
);
1082 event_base_loop(base1
, EVLOOP_NONBLOCK
);
1083 if (test_ok
&& !is_kqueue
) {
1086 /* set base1 to handle signals */
1087 event_base_loop(base1
, EVLOOP_NONBLOCK
);
1089 event_base_loop(base1
, EVLOOP_NONBLOCK
);
1090 event_base_loop(base2
, EVLOOP_NONBLOCK
);
1093 event_base_free(base1
);
1094 event_base_free(base2
);
1099 * assert that a signal event removed from the event queue really is
1100 * removed - with no possibility of it's parent handler being fired.
1103 test_signal_assert(void)
1106 struct event_base
*base
= event_init();
1108 /* use SIGCONT so we don't kill ourselves when we signal to nowhere */
1109 evsignal_set(&ev
, SIGCONT
, signal_cb
, &ev
);
1110 evsignal_add(&ev
, NULL
);
1112 * if evsignal_del() fails to reset the handler, it's current handler
1113 * will still point to evsig_handler().
1119 /* only way to verify we were in evsig_handler() */
1120 /* XXXX Now there's no longer a good way. */
1121 if (base
->sig
.evsig_caught
)
1129 event_base_free(base
);
1135 * assert that we restore our previous signal handler properly.
1138 test_signal_restore(void)
1141 struct event_base
*base
= event_init();
1142 #ifdef _EVENT_HAVE_SIGACTION
1143 struct sigaction sa
;
1147 #ifdef _EVENT_HAVE_SIGACTION
1148 sa
.sa_handler
= signal_cb_sa
;
1150 sigemptyset(&sa
.sa_mask
);
1151 if (sigaction(SIGUSR1
, &sa
, NULL
) == -1)
1154 if (signal(SIGUSR1
, signal_cb_sa
) == SIG_ERR
)
1157 evsignal_set(&ev
, SIGUSR1
, signal_cb
, &ev
);
1158 evsignal_add(&ev
, NULL
);
1162 /* 1 == signal_cb, 2 == signal_cb_sa, we want our previous handler */
1166 event_base_free(base
);
1172 signal_cb_swp(int sig
, short event
, void *arg
)
1178 event_loopexit(NULL
);
1181 timeout_cb_swp(evutil_socket_t fd
, short event
, void *arg
)
1184 struct timeval tv
= {5, 0};
1187 evtimer_add((struct event
*)arg
, &tv
);
1192 event_loopexit(NULL
);
1196 test_signal_while_processing(void)
1198 struct event_base
*base
= event_init();
1199 struct event ev
, ev_timer
;
1200 struct timeval tv
= {0, 0};
1202 setup_test("Receiving a signal while processing other signal: ");
1206 signal_set(&ev
, SIGUSR1
, signal_cb_swp
, NULL
);
1207 signal_add(&ev
, NULL
);
1208 evtimer_set(&ev_timer
, timeout_cb_swp
, &ev_timer
);
1209 evtimer_add(&ev_timer
, &tv
);
1212 event_base_free(base
);
1219 test_free_active_base(void *ptr
)
1221 struct basic_test_data
*data
= ptr
;
1222 struct event_base
*base1
;
1225 base1
= event_init();
1227 event_assign(&ev1
, base1
, data
->pair
[1], EV_READ
,
1228 dummy_read_cb
, NULL
);
1229 event_add(&ev1
, NULL
);
1230 event_base_free(base1
); /* should not crash */
1232 tt_fail_msg("failed to create event_base for test");
1235 base1
= event_init();
1237 event_assign(&ev1
, base1
, 0, 0, dummy_read_cb
, NULL
);
1238 event_active(&ev1
, EV_READ
, 1);
1239 event_base_free(base1
);
1245 test_manipulate_active_events(void *ptr
)
1247 struct basic_test_data
*data
= ptr
;
1248 struct event_base
*base
= data
->base
;
1251 event_assign(&ev1
, base
, -1, EV_TIMEOUT
, dummy_read_cb
, NULL
);
1253 /* Make sure an active event is pending. */
1254 event_active(&ev1
, EV_READ
, 1);
1255 tt_int_op(event_pending(&ev1
, EV_READ
|EV_TIMEOUT
|EV_WRITE
, NULL
),
1258 /* Make sure that activating an event twice works. */
1259 event_active(&ev1
, EV_WRITE
, 1);
1260 tt_int_op(event_pending(&ev1
, EV_READ
|EV_TIMEOUT
|EV_WRITE
, NULL
),
1261 ==, EV_READ
|EV_WRITE
);
1268 test_bad_assign(void *ptr
)
1272 /* READ|SIGNAL is not allowed */
1273 r
= event_assign(&ev
, NULL
, -1, EV_SIGNAL
|EV_READ
, dummy_read_cb
, NULL
);
1280 static int reentrant_cb_run
= 0;
1283 bad_reentrant_run_loop_cb(evutil_socket_t fd
, short what
, void *ptr
)
1285 struct event_base
*base
= ptr
;
1287 reentrant_cb_run
= 1;
1288 /* This reentrant call to event_base_loop should be detected and
1290 r
= event_base_loop(base
, 0);
1291 tt_int_op(r
, ==, -1);
1297 test_bad_reentrant(void *ptr
)
1299 struct basic_test_data
*data
= ptr
;
1300 struct event_base
*base
= data
->base
;
1303 event_assign(&ev
, base
, -1,
1304 0, bad_reentrant_run_loop_cb
, base
);
1306 event_active(&ev
, EV_WRITE
, 1);
1307 r
= event_base_loop(base
, 0);
1308 tt_int_op(r
, ==, 1);
1309 tt_int_op(reentrant_cb_run
, ==, 1);
1315 test_event_base_new(void *ptr
)
1317 struct basic_test_data
*data
= ptr
;
1318 struct event_base
*base
= 0;
1320 struct basic_cb_args args
;
1322 int towrite
= (int)strlen(TEST1
)+1;
1323 int len
= write(data
->pair
[0], TEST1
, towrite
);
1326 tt_abort_perror("initial write");
1327 else if (len
!= towrite
)
1328 tt_abort_printf(("initial write fell short (%d of %d bytes)",
1331 if (shutdown(data
->pair
[0], SHUT_WR
))
1332 tt_abort_perror("initial write shutdown");
1334 base
= event_base_new();
1336 tt_abort_msg("failed to create event base");
1341 event_assign(&ev1
, base
, data
->pair
[1],
1342 EV_READ
|EV_PERSIST
, basic_read_cb
, &args
);
1344 if (event_add(&ev1
, NULL
))
1345 tt_abort_perror("initial event_add");
1347 if (event_base_loop(base
, 0))
1348 tt_abort_msg("unsuccessful exit from event loop");
1352 event_base_free(base
);
1358 struct timeval tv
, tv_start
, tv_end
;
1361 setup_test("Loop exit: ");
1364 tv
.tv_sec
= 60*60*24;
1365 evtimer_set(&ev
, timeout_cb
, NULL
);
1366 evtimer_add(&ev
, &tv
);
1370 event_loopexit(&tv
);
1372 evutil_gettimeofday(&tv_start
, NULL
);
1374 evutil_gettimeofday(&tv_end
, NULL
);
1375 evutil_timersub(&tv_end
, &tv_start
, &tv_end
);
1379 tt_assert(event_base_got_exit(global_base
));
1380 tt_assert(!event_base_got_break(global_base
));
1390 test_loopexit_multiple(void)
1393 struct event_base
*base
;
1395 setup_test("Loop Multiple exit: ");
1397 base
= event_base_new();
1401 event_base_loopexit(base
, &tv
);
1405 event_base_loopexit(base
, &tv
);
1407 event_base_dispatch(base
);
1409 tt_assert(event_base_got_exit(base
));
1410 tt_assert(!event_base_got_break(base
));
1412 event_base_free(base
);
1421 break_cb(evutil_socket_t fd
, short events
, void *arg
)
1428 fail_cb(evutil_socket_t fd
, short events
, void *arg
)
1434 test_loopbreak(void)
1436 struct event ev1
, ev2
;
1439 setup_test("Loop break: ");
1443 evtimer_set(&ev1
, break_cb
, NULL
);
1444 evtimer_add(&ev1
, &tv
);
1445 evtimer_set(&ev2
, fail_cb
, NULL
);
1446 evtimer_add(&ev2
, &tv
);
1450 tt_assert(!event_base_got_exit(global_base
));
1451 tt_assert(event_base_got_break(global_base
));
1460 static struct event
*readd_test_event_last_added
= NULL
;
1462 re_add_read_cb(evutil_socket_t fd
, short event
, void *arg
)
1465 struct event
*ev_other
= arg
;
1466 readd_test_event_last_added
= ev_other
;
1468 if (read(fd
, buf
, sizeof(buf
)) < 0) {
1469 tt_fail_perror("read");
1472 event_add(ev_other
, NULL
);
1477 test_nonpersist_readd(void)
1479 struct event ev1
, ev2
;
1481 setup_test("Re-add nonpersistent events: ");
1482 event_set(&ev1
, pair
[0], EV_READ
, re_add_read_cb
, &ev2
);
1483 event_set(&ev2
, pair
[1], EV_READ
, re_add_read_cb
, &ev1
);
1485 if (write(pair
[0], "Hello", 5) < 0) {
1486 tt_fail_perror("write(pair[0])");
1489 if (write(pair
[1], "Hello", 5) < 0) {
1490 tt_fail_perror("write(pair[1])\n");
1493 if (event_add(&ev1
, NULL
) == -1 ||
1494 event_add(&ev2
, NULL
) == -1) {
1499 event_loop(EVLOOP_ONCE
);
1502 /* At this point, we executed both callbacks. Whichever one got
1503 * called first added the second, but the second then immediately got
1504 * deleted before its callback was called. At this point, though, it
1505 * re-added the first.
1507 if (!readd_test_event_last_added
) {
1509 } else if (readd_test_event_last_added
== &ev1
) {
1510 if (!event_pending(&ev1
, EV_READ
, NULL
) ||
1511 event_pending(&ev2
, EV_READ
, NULL
))
1514 if (event_pending(&ev1
, EV_READ
, NULL
) ||
1515 !event_pending(&ev2
, EV_READ
, NULL
))
1525 struct test_pri_event
{
1531 test_priorities_cb(evutil_socket_t fd
, short what
, void *arg
)
1533 struct test_pri_event
*pri
= arg
;
1536 if (pri
->count
== 3) {
1537 event_loopexit(NULL
);
1543 evutil_timerclear(&tv
);
1544 event_add(&pri
->ev
, &tv
);
1548 test_priorities_impl(int npriorities
)
1550 struct test_pri_event one
, two
;
1553 TT_BLATHER(("Testing Priorities %d: ", npriorities
));
1555 event_base_priority_init(global_base
, npriorities
);
1557 memset(&one
, 0, sizeof(one
));
1558 memset(&two
, 0, sizeof(two
));
1560 timeout_set(&one
.ev
, test_priorities_cb
, &one
);
1561 if (event_priority_set(&one
.ev
, 0) == -1) {
1562 fprintf(stderr
, "%s: failed to set priority", __func__
);
1566 timeout_set(&two
.ev
, test_priorities_cb
, &two
);
1567 if (event_priority_set(&two
.ev
, npriorities
- 1) == -1) {
1568 fprintf(stderr
, "%s: failed to set priority", __func__
);
1572 evutil_timerclear(&tv
);
1574 if (event_add(&one
.ev
, &tv
) == -1)
1576 if (event_add(&two
.ev
, &tv
) == -1)
1584 if (npriorities
== 1) {
1585 if (one
.count
== 3 && two
.count
== 3)
1587 } else if (npriorities
== 2) {
1588 /* Two is called once because event_loopexit is priority 1 */
1589 if (one
.count
== 3 && two
.count
== 1)
1592 if (one
.count
== 3 && two
.count
== 0)
1598 test_priorities(void)
1600 test_priorities_impl(1);
1602 test_priorities_impl(2);
1604 test_priorities_impl(3);
1607 /* priority-active-inversion: activate a higher-priority event, and make sure
1608 * it keeps us from running a lower-priority event first. */
1609 static int n_pai_calls
= 0;
1610 static struct event pai_events
[3];
1613 prio_active_inversion_cb(evutil_socket_t fd
, short what
, void *arg
)
1615 int *call_order
= arg
;
1616 *call_order
= n_pai_calls
++;
1617 if (n_pai_calls
== 1) {
1618 /* This should activate later, even though it shares a
1619 priority with us. */
1620 event_active(&pai_events
[1], EV_READ
, 1);
1621 /* This should activate next, since its priority is higher,
1622 even though we activated it second. */
1623 event_active(&pai_events
[2], EV_TIMEOUT
, 1);
1628 test_priority_active_inversion(void *data_
)
1630 struct basic_test_data
*data
= data_
;
1631 struct event_base
*base
= data
->base
;
1634 tt_int_op(event_base_priority_init(base
, 8), ==, 0);
1637 memset(call_order
, 0, sizeof(call_order
));
1640 event_assign(&pai_events
[i
], data
->base
, -1, 0,
1641 prio_active_inversion_cb
, &call_order
[i
]);
1644 event_priority_set(&pai_events
[0], 4);
1645 event_priority_set(&pai_events
[1], 4);
1646 event_priority_set(&pai_events
[2], 0);
1648 event_active(&pai_events
[0], EV_WRITE
, 1);
1650 event_base_dispatch(base
);
1651 tt_int_op(n_pai_calls
, ==, 3);
1652 tt_int_op(call_order
[0], ==, 0);
1653 tt_int_op(call_order
[1], ==, 2);
1654 tt_int_op(call_order
[2], ==, 1);
1661 test_multiple_cb(evutil_socket_t fd
, short event
, void *arg
)
1663 if (event
& EV_READ
)
1665 else if (event
& EV_WRITE
)
1670 test_multiple_events_for_same_fd(void)
1672 struct event e1
, e2
;
1674 setup_test("Multiple events for same fd: ");
1676 event_set(&e1
, pair
[0], EV_READ
, test_multiple_cb
, NULL
);
1677 event_add(&e1
, NULL
);
1678 event_set(&e2
, pair
[0], EV_WRITE
, test_multiple_cb
, NULL
);
1679 event_add(&e2
, NULL
);
1680 event_loop(EVLOOP_ONCE
);
1683 if (write(pair
[1], TEST1
, strlen(TEST1
)+1) < 0) {
1684 tt_fail_perror("write");
1687 event_loop(EVLOOP_ONCE
);
1696 int evtag_decode_int(ev_uint32_t
*pnumber
, struct evbuffer
*evbuf
);
1697 int evtag_decode_int64(ev_uint64_t
*pnumber
, struct evbuffer
*evbuf
);
1698 int evtag_encode_tag(struct evbuffer
*evbuf
, ev_uint32_t number
);
1699 int evtag_decode_tag(ev_uint32_t
*pnumber
, struct evbuffer
*evbuf
);
1702 read_once_cb(evutil_socket_t fd
, short event
, void *arg
)
1707 len
= read(fd
, buf
, sizeof(buf
));
1712 /* Assumes global pair[0] can be used for writing */
1713 if (write(pair
[0], TEST1
, strlen(TEST1
)+1) < 0) {
1714 tt_fail_perror("write");
1725 test_want_only_once(void)
1730 /* Very simple read test */
1731 setup_test("Want read only once: ");
1733 if (write(pair
[0], TEST1
, strlen(TEST1
)+1) < 0) {
1734 tt_fail_perror("write");
1737 /* Setup the loop termination */
1738 evutil_timerclear(&tv
);
1740 event_loopexit(&tv
);
1742 event_set(&ev
, pair
[1], EV_READ
, read_once_cb
, &ev
);
1743 if (event_add(&ev
, NULL
) == -1)
1750 #define TEST_MAX_INT 6
1753 evtag_int_test(void *ptr
)
1755 struct evbuffer
*tmp
= evbuffer_new();
1756 ev_uint32_t integers
[TEST_MAX_INT
] = {
1757 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1759 ev_uint32_t integer
;
1760 ev_uint64_t big_int
;
1765 for (i
= 0; i
< TEST_MAX_INT
; i
++) {
1767 oldlen
= (int)EVBUFFER_LENGTH(tmp
);
1768 evtag_encode_int(tmp
, integers
[i
]);
1769 newlen
= (int)EVBUFFER_LENGTH(tmp
);
1770 TT_BLATHER(("encoded 0x%08x with %d bytes",
1771 (unsigned)integers
[i
], newlen
- oldlen
));
1772 big_int
= integers
[i
];
1773 big_int
*= 1000000000; /* 1 billion */
1774 evtag_encode_int64(tmp
, big_int
);
1777 for (i
= 0; i
< TEST_MAX_INT
; i
++) {
1778 tt_int_op(evtag_decode_int(&integer
, tmp
), !=, -1);
1779 tt_uint_op(integer
, ==, integers
[i
]);
1780 tt_int_op(evtag_decode_int64(&big_int
, tmp
), !=, -1);
1781 tt_assert((big_int
/ 1000000000) == integers
[i
]);
1784 tt_uint_op(EVBUFFER_LENGTH(tmp
), ==, 0);
1790 evtag_fuzz(void *ptr
)
1792 u_char buffer
[4096];
1793 struct evbuffer
*tmp
= evbuffer_new();
1801 for (j
= 0; j
< 100; j
++) {
1802 for (i
= 0; i
< (int)sizeof(buffer
); i
++)
1804 evbuffer_drain(tmp
, -1);
1805 evbuffer_add(tmp
, buffer
, sizeof(buffer
));
1807 if (evtag_unmarshal_timeval(tmp
, 0, &tv
) != -1)
1811 /* The majority of decodes should fail */
1812 tt_int_op(not_failed
, <, 10);
1814 /* Now insert some corruption into the tag length field */
1815 evbuffer_drain(tmp
, -1);
1816 evutil_timerclear(&tv
);
1818 evtag_marshal_timeval(tmp
, 0, &tv
);
1819 evbuffer_add(tmp
, buffer
, sizeof(buffer
));
1821 ((char *)EVBUFFER_DATA(tmp
))[1] = '\xff';
1822 if (evtag_unmarshal_timeval(tmp
, 0, &tv
) != -1) {
1823 tt_abort_msg("evtag_unmarshal_timeval should have failed");
1831 evtag_tag_encoding(void *ptr
)
1833 struct evbuffer
*tmp
= evbuffer_new();
1834 ev_uint32_t integers
[TEST_MAX_INT
] = {
1835 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1837 ev_uint32_t integer
;
1842 for (i
= 0; i
< TEST_MAX_INT
; i
++) {
1844 oldlen
= (int)EVBUFFER_LENGTH(tmp
);
1845 evtag_encode_tag(tmp
, integers
[i
]);
1846 newlen
= (int)EVBUFFER_LENGTH(tmp
);
1847 TT_BLATHER(("encoded 0x%08x with %d bytes",
1848 (unsigned)integers
[i
], newlen
- oldlen
));
1851 for (i
= 0; i
< TEST_MAX_INT
; i
++) {
1852 tt_int_op(evtag_decode_tag(&integer
, tmp
), !=, -1);
1853 tt_uint_op(integer
, ==, integers
[i
]);
1856 tt_uint_op(EVBUFFER_LENGTH(tmp
), ==, 0);
1863 evtag_test_peek(void *ptr
)
1865 struct evbuffer
*tmp
= evbuffer_new();
1868 evtag_marshal_int(tmp
, 30, 0);
1869 evtag_marshal_string(tmp
, 40, "Hello world");
1871 tt_int_op(evtag_peek(tmp
, &u32
), ==, 1);
1872 tt_int_op(u32
, ==, 30);
1873 tt_int_op(evtag_peek_length(tmp
, &u32
), ==, 0);
1874 tt_int_op(u32
, ==, 1+1+1);
1875 tt_int_op(evtag_consume(tmp
), ==, 0);
1877 tt_int_op(evtag_peek(tmp
, &u32
), ==, 1);
1878 tt_int_op(u32
, ==, 40);
1879 tt_int_op(evtag_peek_length(tmp
, &u32
), ==, 0);
1880 tt_int_op(u32
, ==, 1+1+11);
1881 tt_int_op(evtag_payload_length(tmp
, &u32
), ==, 0);
1882 tt_int_op(u32
, ==, 11);
1890 test_methods(void *ptr
)
1892 const char **methods
= event_get_supported_methods();
1893 struct event_config
*cfg
= NULL
;
1894 struct event_base
*base
= NULL
;
1895 const char *backend
;
1900 backend
= methods
[0];
1901 while (*methods
!= NULL
) {
1902 TT_BLATHER(("Support method: %s", *methods
));
1907 cfg
= event_config_new();
1908 assert(cfg
!= NULL
);
1910 tt_int_op(event_config_avoid_method(cfg
, backend
), ==, 0);
1911 event_config_set_flag(cfg
, EVENT_BASE_FLAG_IGNORE_ENV
);
1913 base
= event_base_new_with_config(cfg
);
1914 if (n_methods
> 1) {
1916 tt_str_op(backend
, !=, event_base_get_method(base
));
1918 tt_assert(base
== NULL
);
1923 event_base_free(base
);
1925 event_config_free(cfg
);
1929 test_version(void *arg
)
1933 int major
, minor
, patch
, n
;
1935 vstr
= event_get_version();
1936 vint
= event_get_version_number();
1941 tt_str_op(vstr
, ==, LIBEVENT_VERSION
);
1942 tt_int_op(vint
, ==, LIBEVENT_VERSION_NUMBER
);
1944 n
= sscanf(vstr
, "%d.%d.%d", &major
, &minor
, &patch
);
1946 tt_int_op((vint
&0xffffff00), ==, ((major
<<24)|(minor
<<16)|(patch
<<8)));
1952 test_base_features(void *arg
)
1954 struct event_base
*base
= NULL
;
1955 struct event_config
*cfg
= NULL
;
1957 cfg
= event_config_new();
1959 tt_assert(0 == event_config_require_features(cfg
, EV_FEATURE_ET
));
1961 base
= event_base_new_with_config(cfg
);
1963 tt_int_op(EV_FEATURE_ET
, ==,
1964 event_base_get_features(base
) & EV_FEATURE_ET
);
1966 base
= event_base_new();
1967 tt_int_op(0, ==, event_base_get_features(base
) & EV_FEATURE_ET
);
1972 event_base_free(base
);
1974 event_config_free(cfg
);
1977 #ifdef _EVENT_HAVE_SETENV
1979 #elif !defined(_EVENT_HAVE_SETENV) && defined(_EVENT_HAVE_PUTENV)
1980 static void setenv(const char *k
, const char *v
, int _o
)
1983 evutil_snprintf(b
, sizeof(b
), "%s=%s",k
,v
);
1989 #ifdef _EVENT_HAVE_UNSETENV
1991 #elif !defined(_EVENT_HAVE_UNSETENV) && defined(_EVENT_HAVE_PUTENV)
1992 static void unsetenv(const char *k
)
1995 evutil_snprintf(b
, sizeof(b
), "%s=",k
);
2001 #if defined(SETENV_OK) && defined(UNSETENV_OK)
2003 methodname_to_envvar(const char *mname
, char *buf
, size_t buflen
)
2006 evutil_snprintf(buf
, buflen
, "EVENT_NO%s", mname
);
2007 for (cp
= buf
; *cp
; ++cp
) {
2008 *cp
= EVUTIL_TOUPPER(*cp
);
2014 test_base_environ(void *arg
)
2016 struct event_base
*base
= NULL
;
2017 struct event_config
*cfg
= NULL
;
2019 #if defined(SETENV_OK) && defined(UNSETENV_OK)
2020 const char **basenames
;
2023 const char *defaultname
, *ignoreenvname
;
2025 /* See if unsetenv works before we rely on it. */
2026 setenv("EVENT_NOWAFFLES", "1", 1);
2027 unsetenv("EVENT_NOWAFFLES");
2028 if (getenv("EVENT_NOWAFFLES") != NULL
) {
2029 #ifndef _EVENT_HAVE_UNSETENV
2030 TT_DECLARE("NOTE", ("Can't fake unsetenv; skipping test"));
2032 TT_DECLARE("NOTE", ("unsetenv doesn't work; skipping test"));
2037 basenames
= event_get_supported_methods();
2038 for (i
= 0; basenames
[i
]; ++i
) {
2039 methodname_to_envvar(basenames
[i
], varbuf
, sizeof(varbuf
));
2044 base
= event_base_new();
2047 defaultname
= event_base_get_method(base
);
2048 TT_BLATHER(("default is <%s>", defaultname
));
2049 event_base_free(base
);
2052 /* Can we disable the method with EVENT_NOfoo ? */
2053 if (!strcmp(defaultname
, "epoll (with changelist)")) {
2054 setenv("EVENT_NOEPOLL", "1", 1);
2055 ignoreenvname
= "epoll";
2057 methodname_to_envvar(defaultname
, varbuf
, sizeof(varbuf
));
2058 setenv(varbuf
, "1", 1);
2059 ignoreenvname
= defaultname
;
2062 /* Use an empty cfg rather than NULL so a failure doesn't exit() */
2063 cfg
= event_config_new();
2064 base
= event_base_new_with_config(cfg
);
2065 event_config_free(cfg
);
2067 if (n_methods
== 1) {
2071 tt_str_op(defaultname
, !=, event_base_get_method(base
));
2072 event_base_free(base
);
2076 /* Can we disable looking at the environment with IGNORE_ENV ? */
2077 cfg
= event_config_new();
2078 event_config_set_flag(cfg
, EVENT_BASE_FLAG_IGNORE_ENV
);
2079 base
= event_base_new_with_config(cfg
);
2081 tt_str_op(ignoreenvname
, ==, event_base_get_method(base
));
2088 event_base_free(base
);
2090 event_config_free(cfg
);
2094 read_called_once_cb(evutil_socket_t fd
, short event
, void *arg
)
2096 tt_int_op(event
, ==, EV_READ
);
2103 timeout_called_once_cb(evutil_socket_t fd
, short event
, void *arg
)
2105 tt_int_op(event
, ==, EV_TIMEOUT
);
2112 test_event_once(void *ptr
)
2114 struct basic_test_data
*data
= ptr
;
2119 tv
.tv_usec
= 50*1000;
2121 r
= event_base_once(data
->base
, data
->pair
[0], EV_READ
,
2122 read_called_once_cb
, NULL
, NULL
);
2123 tt_int_op(r
, ==, 0);
2124 r
= event_base_once(data
->base
, -1, EV_TIMEOUT
,
2125 timeout_called_once_cb
, NULL
, &tv
);
2126 tt_int_op(r
, ==, 0);
2127 r
= event_base_once(data
->base
, -1, 0, NULL
, NULL
, NULL
);
2130 if (write(data
->pair
[1], TEST1
, strlen(TEST1
)+1) < 0) {
2131 tt_fail_perror("write");
2134 shutdown(data
->pair
[1], SHUT_WR
);
2136 event_base_dispatch(data
->base
);
2138 tt_int_op(called
, ==, 101);
2144 test_event_pending(void *ptr
)
2146 struct basic_test_data
*data
= ptr
;
2147 struct event
*r
=NULL
, *w
=NULL
, *t
=NULL
;
2148 struct timeval tv
, now
, tv2
, diff
;
2151 tv
.tv_usec
= 500 * 1000;
2152 r
= event_new(data
->base
, data
->pair
[0], EV_READ
, simple_read_cb
,
2154 w
= event_new(data
->base
, data
->pair
[1], EV_WRITE
, simple_write_cb
,
2156 t
= evtimer_new(data
->base
, timeout_cb
, NULL
);
2158 evutil_gettimeofday(&now
, NULL
);
2162 tt_assert( event_pending(r
, EV_READ
, NULL
));
2163 tt_assert(!event_pending(w
, EV_WRITE
, NULL
));
2164 tt_assert(!event_pending(r
, EV_WRITE
, NULL
));
2165 tt_assert( event_pending(r
, EV_READ
|EV_WRITE
, NULL
));
2166 tt_assert(!event_pending(r
, EV_TIMEOUT
, NULL
));
2167 tt_assert( event_pending(t
, EV_TIMEOUT
, NULL
));
2168 tt_assert( event_pending(t
, EV_TIMEOUT
, &tv2
));
2170 tt_assert(evutil_timercmp(&tv2
, &now
, >));
2171 evutil_timeradd(&now
, &tv
, &tv
);
2172 evutil_timersub(&tv2
, &tv
, &diff
);
2173 tt_int_op(diff
.tv_sec
, ==, 0);
2174 tt_int_op(labs(diff
.tv_usec
), <, 1000);
2192 /* You can't do this test on windows, since dup2 doesn't work on sockets */
2195 dfd_cb(evutil_socket_t fd
, short e
, void *data
)
2197 *(int*)data
= (int)e
;
2200 /* Regression test for our workaround for a fun epoll/linux related bug
2201 * where fd2 = dup(fd1); add(fd2); close(fd2); dup2(fd1,fd2); add(fd2)
2202 * will get you an EEXIST */
2204 test_dup_fd(void *arg
)
2206 struct basic_test_data
*data
= arg
;
2207 struct event_base
*base
= data
->base
;
2208 struct event
*ev1
=NULL
, *ev2
=NULL
;
2210 int ev1_got
, ev2_got
;
2212 tt_int_op(write(data
->pair
[0], "Hello world",
2213 strlen("Hello world")), >, 0);
2217 tt_int_op(dfd
, >=, 0);
2219 ev1
= event_new(base
, fd
, EV_READ
|EV_PERSIST
, dfd_cb
, &ev1_got
);
2220 ev2
= event_new(base
, dfd
, EV_READ
|EV_PERSIST
, dfd_cb
, &ev2_got
);
2221 ev1_got
= ev2_got
= 0;
2222 event_add(ev1
, NULL
);
2223 event_add(ev2
, NULL
);
2224 event_base_loop(base
, EVLOOP_ONCE
);
2225 tt_int_op(ev1_got
, ==, EV_READ
);
2226 tt_int_op(ev2_got
, ==, EV_READ
);
2228 /* Now close and delete dfd then dispatch. We need to do the
2229 * dispatch here so that when we add it later, we think there
2230 * was an intermediate delete. */
2233 ev1_got
= ev2_got
= 0;
2234 event_base_loop(base
, EVLOOP_ONCE
);
2235 tt_want_int_op(ev1_got
, ==, EV_READ
);
2236 tt_int_op(ev2_got
, ==, 0);
2238 /* Re-duplicate the fd. We need to get the same duplicated
2239 * value that we closed to provoke the epoll quirk. Also, we
2240 * need to change the events to write, or else the old lingering
2241 * read event will make the test pass whether the change was
2242 * successful or not. */
2243 tt_int_op(dup2(fd
, dfd
), ==, dfd
);
2245 ev2
= event_new(base
, dfd
, EV_WRITE
|EV_PERSIST
, dfd_cb
, &ev2_got
);
2246 event_add(ev2
, NULL
);
2247 ev1_got
= ev2_got
= 0;
2248 event_base_loop(base
, EVLOOP_ONCE
);
2249 tt_want_int_op(ev1_got
, ==, EV_READ
);
2250 tt_int_op(ev2_got
, ==, EV_WRITE
);
2261 #ifdef _EVENT_DISABLE_MM_REPLACEMENT
2263 test_mm_functions(void *arg
)
2265 _tinytest_set_test_skipped();
2269 check_dummy_mem_ok(void *_mem
)
2273 return !memcmp(mem
, "{[<guardedram>]}", 16);
2277 dummy_malloc(size_t len
)
2279 char *mem
= malloc(len
+16);
2280 memcpy(mem
, "{[<guardedram>]}", 16);
2285 dummy_realloc(void *_mem
, size_t len
)
2289 return dummy_malloc(len
);
2290 tt_want(check_dummy_mem_ok(_mem
));
2292 mem
= realloc(mem
, len
+16);
2297 dummy_free(void *_mem
)
2300 tt_want(check_dummy_mem_ok(_mem
));
2306 test_mm_functions(void *arg
)
2308 struct event_base
*b
= NULL
;
2309 struct event_config
*cfg
= NULL
;
2310 event_set_mem_functions(dummy_malloc
, dummy_realloc
, dummy_free
);
2311 cfg
= event_config_new();
2312 event_config_avoid_method(cfg
, "Nonesuch");
2313 b
= event_base_new_with_config(cfg
);
2315 tt_assert(check_dummy_mem_ok(b
));
2318 event_config_free(cfg
);
2325 many_event_cb(evutil_socket_t fd
, short event
, void *arg
)
2332 test_many_events(void *arg
)
2334 /* Try 70 events that should all be ready at once. This will
2335 * exercise the "resize" code on most of the backends, and will make
2336 * sure that we can get past the 64-handle limit of some windows
2340 struct basic_test_data
*data
= arg
;
2341 struct event_base
*base
= data
->base
;
2342 int one_at_a_time
= data
->setup_data
!= NULL
;
2343 evutil_socket_t sock
[MANY
];
2344 struct event
*ev
[MANY
];
2347 int loopflags
= EVLOOP_NONBLOCK
, evflags
=0;
2348 const int is_evport
= !strcmp(event_base_get_method(base
),"evport");
2349 if (one_at_a_time
) {
2350 loopflags
|= EVLOOP_ONCE
;
2351 evflags
= EV_PERSIST
;
2354 memset(sock
, 0xff, sizeof(sock
));
2355 memset(ev
, 0, sizeof(ev
));
2356 memset(called
, 0, sizeof(called
));
2357 if (is_evport
&& one_at_a_time
) {
2358 TT_DECLARE("NOTE", ("evport can't pass this in 2.0; skipping\n"));
2362 for (i
= 0; i
< MANY
; ++i
) {
2363 /* We need an event that will hit the backend, and that will
2364 * be ready immediately. "Send a datagram" is an easy
2365 * instance of that. */
2366 sock
[i
] = socket(AF_INET
, SOCK_DGRAM
, 0);
2367 tt_assert(sock
[i
] >= 0);
2369 ev
[i
] = event_new(base
, sock
[i
], EV_WRITE
|evflags
,
2370 many_event_cb
, &called
[i
]);
2371 event_add(ev
[i
], NULL
);
2373 event_base_loop(base
, EVLOOP_NONBLOCK
|EVLOOP_ONCE
);
2376 event_base_loop(base
, loopflags
);
2378 for (i
= 0; i
< MANY
; ++i
) {
2380 tt_int_op(called
[i
], ==, MANY
- i
+ 1);
2382 tt_int_op(called
[i
], ==, 1);
2386 for (i
= 0; i
< MANY
; ++i
) {
2390 evutil_closesocket(sock
[i
]);
2396 test_struct_event_size(void *arg
)
2398 tt_int_op(event_get_struct_event_size(), <=, sizeof(struct event
));
2403 struct testcase_t main_testcases
[] = {
2404 /* Some converted-over tests */
2405 { "methods", test_methods
, TT_FORK
, NULL
, NULL
},
2406 { "version", test_version
, 0, NULL
, NULL
},
2407 BASIC(base_features
, TT_FORK
|TT_NO_LOGS
),
2408 { "base_environ", test_base_environ
, TT_FORK
, NULL
, NULL
},
2410 BASIC(event_base_new
, TT_FORK
|TT_NEED_SOCKETPAIR
),
2411 BASIC(free_active_base
, TT_FORK
|TT_NEED_SOCKETPAIR
),
2413 BASIC(manipulate_active_events
, TT_FORK
|TT_NEED_BASE
),
2415 BASIC(bad_assign
, TT_FORK
|TT_NEED_BASE
|TT_NO_LOGS
),
2416 BASIC(bad_reentrant
, TT_FORK
|TT_NEED_BASE
|TT_NO_LOGS
),
2418 LEGACY(persistent_timeout
, TT_FORK
|TT_NEED_BASE
),
2419 { "persistent_timeout_jump", test_persistent_timeout_jump
, TT_FORK
|TT_NEED_BASE
, &basic_setup
, NULL
},
2420 { "persistent_active_timeout", test_persistent_active_timeout
,
2421 TT_FORK
|TT_NEED_BASE
, &basic_setup
, NULL
},
2422 LEGACY(priorities
, TT_FORK
|TT_NEED_BASE
),
2423 BASIC(priority_active_inversion
, TT_FORK
|TT_NEED_BASE
),
2424 { "common_timeout", test_common_timeout
, TT_FORK
|TT_NEED_BASE
,
2425 &basic_setup
, NULL
},
2427 /* These legacy tests may not all need all of these flags. */
2428 LEGACY(simpleread
, TT_ISOLATED
),
2429 LEGACY(simpleread_multiple
, TT_ISOLATED
),
2430 LEGACY(simplewrite
, TT_ISOLATED
),
2431 { "simpleclose", test_simpleclose
, TT_FORK
, &basic_setup
,
2433 LEGACY(multiple
, TT_ISOLATED
),
2434 LEGACY(persistent
, TT_ISOLATED
),
2435 LEGACY(combined
, TT_ISOLATED
),
2436 LEGACY(simpletimeout
, TT_ISOLATED
),
2437 LEGACY(loopbreak
, TT_ISOLATED
),
2438 LEGACY(loopexit
, TT_ISOLATED
),
2439 LEGACY(loopexit_multiple
, TT_ISOLATED
),
2440 LEGACY(nonpersist_readd
, TT_ISOLATED
),
2441 LEGACY(multiple_events_for_same_fd
, TT_ISOLATED
),
2442 LEGACY(want_only_once
, TT_ISOLATED
),
2443 { "event_once", test_event_once
, TT_ISOLATED
, &basic_setup
, NULL
},
2444 { "event_pending", test_event_pending
, TT_ISOLATED
, &basic_setup
,
2447 { "dup_fd", test_dup_fd
, TT_ISOLATED
, &basic_setup
, NULL
},
2449 { "mm_functions", test_mm_functions
, TT_FORK
, NULL
, NULL
},
2450 { "many_events", test_many_events
, TT_ISOLATED
, &basic_setup
, NULL
},
2451 { "many_events_slow_add", test_many_events
, TT_ISOLATED
, &basic_setup
, (void*)1 },
2453 { "struct_event_size", test_struct_event_size
, 0, NULL
, NULL
},
2456 LEGACY(fork
, TT_ISOLATED
),
2461 struct testcase_t evtag_testcases
[] = {
2462 { "int", evtag_int_test
, TT_FORK
, NULL
, NULL
},
2463 { "fuzz", evtag_fuzz
, TT_FORK
, NULL
, NULL
},
2464 { "encoding", evtag_tag_encoding
, TT_FORK
, NULL
, NULL
},
2465 { "peek", evtag_test_peek
, 0, NULL
, NULL
},
2470 struct testcase_t signal_testcases
[] = {
2472 LEGACY(simplesignal
, TT_ISOLATED
),
2473 LEGACY(multiplesignal
, TT_ISOLATED
),
2474 LEGACY(immediatesignal
, TT_ISOLATED
),
2475 LEGACY(signal_dealloc
, TT_ISOLATED
),
2476 LEGACY(signal_pipeloss
, TT_ISOLATED
),
2477 LEGACY(signal_switchbase
, TT_ISOLATED
|TT_NO_LOGS
),
2478 LEGACY(signal_restore
, TT_ISOLATED
),
2479 LEGACY(signal_assert
, TT_ISOLATED
),
2480 LEGACY(signal_while_processing
, TT_ISOLATED
),