1 /*
2 * Copyright (c) 2003-2007 Niels Provos <provos@citi.umich.edu>
3 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27 #include "util-internal.h"
28
29 #ifdef _WIN32
30 #include <winsock2.h>
31 #include <windows.h>
32 #endif
33
34 #include "event2/event-config.h"
35
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #ifdef EVENT__HAVE_SYS_TIME_H
39 #include <sys/time.h>
40 #endif
41 #include <sys/queue.h>
42 #ifndef _WIN32
43 #include <sys/socket.h>
44 #include <sys/wait.h>
45 #include <signal.h>
46 #include <unistd.h>
47 #include <netdb.h>
48 #endif
49 #include <fcntl.h>
50 #include <signal.h>
51 #include <stdlib.h>
52 #include <stdio.h>
53 #include <string.h>
54 #include <errno.h>
55 #include <assert.h>
56 #include <ctype.h>
57
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"
69
70 #include "regress.h"
71
72 #ifndef _WIN32
73 #include "regress.gen.h"
74 #endif
75
76 evutil_socket_t pair[2];
77 int test_ok;
78 int called;
79 struct event_base *global_base;
80
81 static char wbuf[4096];
82 static char rbuf[4096];
83 static int woff;
84 static int roff;
85 static int usepersist;
86 static struct timeval tset;
87 static struct timeval tcalled;
88
89
90 #define TEST1 "this is a test"
91
92 #ifndef SHUT_WR
93 #define SHUT_WR 1
94 #endif
95
96 #ifdef _WIN32
97 #define write(fd,buf,len) send((fd),(buf),(int)(len),0)
98 #define read(fd,buf,len) recv((fd),(buf),(int)(len),0)
99 #endif
100
101 struct basic_cb_args
102 {
103 struct event_base *eb;
104 struct event *ev;
105 unsigned int callcount;
106 };
107
108 static void
simple_read_cb(evutil_socket_t fd,short event,void * arg)109 simple_read_cb(evutil_socket_t fd, short event, void *arg)
110 {
111 char buf[256];
112 int len;
113
114 len = read(fd, buf, sizeof(buf));
115
116 if (len) {
117 if (!called) {
118 if (event_add(arg, NULL) == -1)
119 exit(1);
120 }
121 } else if (called == 1)
122 test_ok = 1;
123
124 called++;
125 }
126
127 static void
basic_read_cb(evutil_socket_t fd,short event,void * data)128 basic_read_cb(evutil_socket_t fd, short event, void *data)
129 {
130 char buf[256];
131 int len;
132 struct basic_cb_args *arg = data;
133
134 len = read(fd, buf, sizeof(buf));
135
136 if (len < 0) {
137 tt_fail_perror("read (callback)");
138 } else {
139 switch (arg->callcount++) {
140 case 0: /* first call: expect to read data; cycle */
141 if (len > 0)
142 return;
143
144 tt_fail_msg("EOF before data read");
145 break;
146
147 case 1: /* second call: expect EOF; stop */
148 if (len > 0)
149 tt_fail_msg("not all data read on first cycle");
150 break;
151
152 default: /* third call: should not happen */
153 tt_fail_msg("too many cycles");
154 }
155 }
156
157 event_del(arg->ev);
158 event_base_loopexit(arg->eb, NULL);
159 }
160
161 static void
dummy_read_cb(evutil_socket_t fd,short event,void * arg)162 dummy_read_cb(evutil_socket_t fd, short event, void *arg)
163 {
164 }
165
166 static void
simple_write_cb(evutil_socket_t fd,short event,void * arg)167 simple_write_cb(evutil_socket_t fd, short event, void *arg)
168 {
169 int len;
170
171 len = write(fd, TEST1, strlen(TEST1) + 1);
172 if (len == -1)
173 test_ok = 0;
174 else
175 test_ok = 1;
176 }
177
178 static void
multiple_write_cb(evutil_socket_t fd,short event,void * arg)179 multiple_write_cb(evutil_socket_t fd, short event, void *arg)
180 {
181 struct event *ev = arg;
182 int len;
183
184 len = 128;
185 if (woff + len >= (int)sizeof(wbuf))
186 len = sizeof(wbuf) - woff;
187
188 len = write(fd, wbuf + woff, len);
189 if (len == -1) {
190 fprintf(stderr, "%s: write\n", __func__);
191 if (usepersist)
192 event_del(ev);
193 return;
194 }
195
196 woff += len;
197
198 if (woff >= (int)sizeof(wbuf)) {
199 shutdown(fd, SHUT_WR);
200 if (usepersist)
201 event_del(ev);
202 return;
203 }
204
205 if (!usepersist) {
206 if (event_add(ev, NULL) == -1)
207 exit(1);
208 }
209 }
210
211 static void
multiple_read_cb(evutil_socket_t fd,short event,void * arg)212 multiple_read_cb(evutil_socket_t fd, short event, void *arg)
213 {
214 struct event *ev = arg;
215 int len;
216
217 len = read(fd, rbuf + roff, sizeof(rbuf) - roff);
218 if (len == -1)
219 fprintf(stderr, "%s: read\n", __func__);
220 if (len <= 0) {
221 if (usepersist)
222 event_del(ev);
223 return;
224 }
225
226 roff += len;
227 if (!usepersist) {
228 if (event_add(ev, NULL) == -1)
229 exit(1);
230 }
231 }
232
233 static void
timeout_cb(evutil_socket_t fd,short event,void * arg)234 timeout_cb(evutil_socket_t fd, short event, void *arg)
235 {
236 evutil_gettimeofday(&tcalled, NULL);
237 }
238
239 struct both {
240 struct event ev;
241 int nread;
242 };
243
244 static void
combined_read_cb(evutil_socket_t fd,short event,void * arg)245 combined_read_cb(evutil_socket_t fd, short event, void *arg)
246 {
247 struct both *both = arg;
248 char buf[128];
249 int len;
250
251 len = read(fd, buf, sizeof(buf));
252 if (len == -1)
253 fprintf(stderr, "%s: read\n", __func__);
254 if (len <= 0)
255 return;
256
257 both->nread += len;
258 if (event_add(&both->ev, NULL) == -1)
259 exit(1);
260 }
261
262 static void
combined_write_cb(evutil_socket_t fd,short event,void * arg)263 combined_write_cb(evutil_socket_t fd, short event, void *arg)
264 {
265 struct both *both = arg;
266 char buf[128];
267 int len;
268
269 len = sizeof(buf);
270 if (len > both->nread)
271 len = both->nread;
272
273 memset(buf, 'q', len);
274
275 len = write(fd, buf, len);
276 if (len == -1)
277 fprintf(stderr, "%s: write\n", __func__);
278 if (len <= 0) {
279 shutdown(fd, SHUT_WR);
280 return;
281 }
282
283 both->nread -= len;
284 if (event_add(&both->ev, NULL) == -1)
285 exit(1);
286 }
287
288 /* These macros used to replicate the work of the legacy test wrapper code */
289 #define setup_test(x) do { \
290 if (!in_legacy_test_wrapper) { \
291 TT_FAIL(("Legacy test %s not wrapped properly", x)); \
292 return; \
293 } \
294 } while (0)
295 #define cleanup_test() setup_test("cleanup")
296
297 static void
test_simpleread(void)298 test_simpleread(void)
299 {
300 struct event ev;
301
302 /* Very simple read test */
303 setup_test("Simple read: ");
304
305 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
306 tt_fail_perror("write");
307 }
308
309 shutdown(pair[0], SHUT_WR);
310
311 event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
312 if (event_add(&ev, NULL) == -1)
313 exit(1);
314 event_dispatch();
315
316 cleanup_test();
317 }
318
319 static void
test_simplewrite(void)320 test_simplewrite(void)
321 {
322 struct event ev;
323
324 /* Very simple write test */
325 setup_test("Simple write: ");
326
327 event_set(&ev, pair[0], EV_WRITE, simple_write_cb, &ev);
328 if (event_add(&ev, NULL) == -1)
329 exit(1);
330 event_dispatch();
331
332 cleanup_test();
333 }
334
335 static void
simpleread_multiple_cb(evutil_socket_t fd,short event,void * arg)336 simpleread_multiple_cb(evutil_socket_t fd, short event, void *arg)
337 {
338 if (++called == 2)
339 test_ok = 1;
340 }
341
342 static void
test_simpleread_multiple(void)343 test_simpleread_multiple(void)
344 {
345 struct event one, two;
346
347 /* Very simple read test */
348 setup_test("Simple read to multiple evens: ");
349
350 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
351 tt_fail_perror("write");
352 }
353
354 shutdown(pair[0], SHUT_WR);
355
356 event_set(&one, pair[1], EV_READ, simpleread_multiple_cb, NULL);
357 if (event_add(&one, NULL) == -1)
358 exit(1);
359 event_set(&two, pair[1], EV_READ, simpleread_multiple_cb, NULL);
360 if (event_add(&two, NULL) == -1)
361 exit(1);
362 event_dispatch();
363
364 cleanup_test();
365 }
366
367 static int have_closed = 0;
368 static int premature_event = 0;
369 static void
simpleclose_close_fd_cb(evutil_socket_t s,short what,void * ptr)370 simpleclose_close_fd_cb(evutil_socket_t s, short what, void *ptr)
371 {
372 evutil_socket_t **fds = ptr;
373 TT_BLATHER(("Closing"));
374 evutil_closesocket(*fds[0]);
375 evutil_closesocket(*fds[1]);
376 *fds[0] = -1;
377 *fds[1] = -1;
378 have_closed = 1;
379 }
380
381 static void
record_event_cb(evutil_socket_t s,short what,void * ptr)382 record_event_cb(evutil_socket_t s, short what, void *ptr)
383 {
384 short *whatp = ptr;
385 if (!have_closed)
386 premature_event = 1;
387 *whatp = what;
388 TT_BLATHER(("Recorded %d on socket %d", (int)what, (int)s));
389 }
390
391 static void
test_simpleclose(void * ptr)392 test_simpleclose(void *ptr)
393 {
394 /* Test that a close of FD is detected as a read and as a write. */
395 struct event_base *base = event_base_new();
396 evutil_socket_t pair1[2]={-1,-1}, pair2[2] = {-1, -1};
397 evutil_socket_t *to_close[2];
398 struct event *rev=NULL, *wev=NULL, *closeev=NULL;
399 struct timeval tv;
400 short got_read_on_close = 0, got_write_on_close = 0;
401 char buf[1024];
402 memset(buf, 99, sizeof(buf));
403 #ifdef _WIN32
404 #define LOCAL_SOCKETPAIR_AF AF_INET
405 #else
406 #define LOCAL_SOCKETPAIR_AF AF_UNIX
407 #endif
408 if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0, pair1)<0)
409 TT_DIE(("socketpair: %s", strerror(errno)));
410 if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0, pair2)<0)
411 TT_DIE(("socketpair: %s", strerror(errno)));
412 if (evutil_make_socket_nonblocking(pair1[1]) < 0)
413 TT_DIE(("make_socket_nonblocking"));
414 if (evutil_make_socket_nonblocking(pair2[1]) < 0)
415 TT_DIE(("make_socket_nonblocking"));
416
417 /** Stuff pair2[1] full of data, until write fails */
418 while (1) {
419 int r = write(pair2[1], buf, sizeof(buf));
420 if (r<0) {
421 int err = evutil_socket_geterror(pair2[1]);
422 if (! EVUTIL_ERR_RW_RETRIABLE(err))
423 TT_DIE(("write failed strangely: %s",
424 evutil_socket_error_to_string(err)));
425 break;
426 }
427 }
428 to_close[0] = &pair1[0];
429 to_close[1] = &pair2[0];
430
431 closeev = event_new(base, -1, EV_TIMEOUT, simpleclose_close_fd_cb,
432 to_close);
433 rev = event_new(base, pair1[1], EV_READ, record_event_cb,
434 &got_read_on_close);
435 TT_BLATHER(("Waiting for read on %d", (int)pair1[1]));
436 wev = event_new(base, pair2[1], EV_WRITE, record_event_cb,
437 &got_write_on_close);
438 TT_BLATHER(("Waiting for write on %d", (int)pair2[1]));
439 tv.tv_sec = 0;
440 tv.tv_usec = 100*1000; /* Close pair1[0] after a little while, and make
441 * sure we get a read event. */
442 event_add(closeev, &tv);
443 event_add(rev, NULL);
444 event_add(wev, NULL);
445 /* Don't let the test go on too long. */
446 tv.tv_sec = 0;
447 tv.tv_usec = 200*1000;
448 event_base_loopexit(base, &tv);
449 event_base_loop(base, 0);
450
451 tt_int_op(got_read_on_close, ==, EV_READ);
452 tt_int_op(got_write_on_close, ==, EV_WRITE);
453 tt_int_op(premature_event, ==, 0);
454
455 end:
456 if (pair1[0] >= 0)
457 evutil_closesocket(pair1[0]);
458 if (pair1[1] >= 0)
459 evutil_closesocket(pair1[1]);
460 if (pair2[0] >= 0)
461 evutil_closesocket(pair2[0]);
462 if (pair2[1] >= 0)
463 evutil_closesocket(pair2[1]);
464 if (rev)
465 event_free(rev);
466 if (wev)
467 event_free(wev);
468 if (closeev)
469 event_free(closeev);
470 if (base)
471 event_base_free(base);
472 }
473
474
475 static void
test_multiple(void)476 test_multiple(void)
477 {
478 struct event ev, ev2;
479 int i;
480
481 /* Multiple read and write test */
482 setup_test("Multiple read/write: ");
483 memset(rbuf, 0, sizeof(rbuf));
484 for (i = 0; i < (int)sizeof(wbuf); i++)
485 wbuf[i] = i;
486
487 roff = woff = 0;
488 usepersist = 0;
489
490 event_set(&ev, pair[0], EV_WRITE, multiple_write_cb, &ev);
491 if (event_add(&ev, NULL) == -1)
492 exit(1);
493 event_set(&ev2, pair[1], EV_READ, multiple_read_cb, &ev2);
494 if (event_add(&ev2, NULL) == -1)
495 exit(1);
496 event_dispatch();
497
498 if (roff == woff)
499 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
500
501 cleanup_test();
502 }
503
504 static void
test_persistent(void)505 test_persistent(void)
506 {
507 struct event ev, ev2;
508 int i;
509
510 /* Multiple read and write test with persist */
511 setup_test("Persist read/write: ");
512 memset(rbuf, 0, sizeof(rbuf));
513 for (i = 0; i < (int)sizeof(wbuf); i++)
514 wbuf[i] = i;
515
516 roff = woff = 0;
517 usepersist = 1;
518
519 event_set(&ev, pair[0], EV_WRITE|EV_PERSIST, multiple_write_cb, &ev);
520 if (event_add(&ev, NULL) == -1)
521 exit(1);
522 event_set(&ev2, pair[1], EV_READ|EV_PERSIST, multiple_read_cb, &ev2);
523 if (event_add(&ev2, NULL) == -1)
524 exit(1);
525 event_dispatch();
526
527 if (roff == woff)
528 test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
529
530 cleanup_test();
531 }
532
533 static void
test_combined(void)534 test_combined(void)
535 {
536 struct both r1, r2, w1, w2;
537
538 setup_test("Combined read/write: ");
539 memset(&r1, 0, sizeof(r1));
540 memset(&r2, 0, sizeof(r2));
541 memset(&w1, 0, sizeof(w1));
542 memset(&w2, 0, sizeof(w2));
543
544 w1.nread = 4096;
545 w2.nread = 8192;
546
547 event_set(&r1.ev, pair[0], EV_READ, combined_read_cb, &r1);
548 event_set(&w1.ev, pair[0], EV_WRITE, combined_write_cb, &w1);
549 event_set(&r2.ev, pair[1], EV_READ, combined_read_cb, &r2);
550 event_set(&w2.ev, pair[1], EV_WRITE, combined_write_cb, &w2);
551 tt_assert(event_add(&r1.ev, NULL) != -1);
552 tt_assert(!event_add(&w1.ev, NULL));
553 tt_assert(!event_add(&r2.ev, NULL));
554 tt_assert(!event_add(&w2.ev, NULL));
555 event_dispatch();
556
557 if (r1.nread == 8192 && r2.nread == 4096)
558 test_ok = 1;
559
560 end:
561 cleanup_test();
562 }
563
564 static void
test_simpletimeout(void)565 test_simpletimeout(void)
566 {
567 struct timeval tv;
568 struct event ev;
569
570 setup_test("Simple timeout: ");
571
572 tv.tv_usec = 200*1000;
573 tv.tv_sec = 0;
574 evutil_timerclear(&tcalled);
575 evtimer_set(&ev, timeout_cb, NULL);
576 evtimer_add(&ev, &tv);
577
578 evutil_gettimeofday(&tset, NULL);
579 event_dispatch();
580 test_timeval_diff_eq(&tset, &tcalled, 200);
581
582 test_ok = 1;
583 end:
584 cleanup_test();
585 }
586
587 static void
periodic_timeout_cb(evutil_socket_t fd,short event,void * arg)588 periodic_timeout_cb(evutil_socket_t fd, short event, void *arg)
589 {
590 int *count = arg;
591
592 (*count)++;
593 if (*count == 6) {
594 /* call loopexit only once - on slow machines(?), it is
595 * apparently possible for this to get called twice. */
596 test_ok = 1;
597 event_base_loopexit(global_base, NULL);
598 }
599 }
600
601 static void
test_persistent_timeout(void)602 test_persistent_timeout(void)
603 {
604 struct timeval tv;
605 struct event ev;
606 int count = 0;
607
608 evutil_timerclear(&tv);
609 tv.tv_usec = 10000;
610
611 event_assign(&ev, global_base, -1, EV_TIMEOUT|EV_PERSIST,
612 periodic_timeout_cb, &count);
613 event_add(&ev, &tv);
614
615 event_dispatch();
616
617 event_del(&ev);
618 }
619
620 static void
test_persistent_timeout_jump(void * ptr)621 test_persistent_timeout_jump(void *ptr)
622 {
623 struct basic_test_data *data = ptr;
624 struct event ev;
625 int count = 0;
626 struct timeval msec100 = { 0, 100 * 1000 };
627 struct timeval msec50 = { 0, 50 * 1000 };
628 struct timeval msec300 = { 0, 300 * 1000 };
629
630 event_assign(&ev, data->base, -1, EV_PERSIST, periodic_timeout_cb, &count);
631 event_add(&ev, &msec100);
632 /* Wait for a bit */
633 evutil_usleep_(&msec300);
634 event_base_loopexit(data->base, &msec50);
635 event_base_dispatch(data->base);
636 tt_int_op(count, ==, 1);
637
638 end:
639 event_del(&ev);
640 }
641
642 struct persist_active_timeout_called {
643 int n;
644 short events[16];
645 struct timeval tvs[16];
646 };
647
648 static void
activate_cb(evutil_socket_t fd,short event,void * arg)649 activate_cb(evutil_socket_t fd, short event, void *arg)
650 {
651 struct event *ev = arg;
652 event_active(ev, EV_READ, 1);
653 }
654
655 static void
persist_active_timeout_cb(evutil_socket_t fd,short event,void * arg)656 persist_active_timeout_cb(evutil_socket_t fd, short event, void *arg)
657 {
658 struct persist_active_timeout_called *c = arg;
659 if (c->n < 15) {
660 c->events[c->n] = event;
661 evutil_gettimeofday(&c->tvs[c->n], NULL);
662 ++c->n;
663 }
664 }
665
666 static void
test_persistent_active_timeout(void * ptr)667 test_persistent_active_timeout(void *ptr)
668 {
669 struct timeval tv, tv2, tv_exit, start;
670 struct event ev;
671 struct persist_active_timeout_called res;
672
673 struct basic_test_data *data = ptr;
674 struct event_base *base = data->base;
675
676 memset(&res, 0, sizeof(res));
677
678 tv.tv_sec = 0;
679 tv.tv_usec = 200 * 1000;
680 event_assign(&ev, base, -1, EV_TIMEOUT|EV_PERSIST,
681 persist_active_timeout_cb, &res);
682 event_add(&ev, &tv);
683
684 tv2.tv_sec = 0;
685 tv2.tv_usec = 100 * 1000;
686 event_base_once(base, -1, EV_TIMEOUT, activate_cb, &ev, &tv2);
687
688 tv_exit.tv_sec = 0;
689 tv_exit.tv_usec = 600 * 1000;
690 event_base_loopexit(base, &tv_exit);
691
692 event_base_assert_ok_(base);
693 evutil_gettimeofday(&start, NULL);
694
695 event_base_dispatch(base);
696 event_base_assert_ok_(base);
697
698 tt_int_op(res.n, ==, 3);
699 tt_int_op(res.events[0], ==, EV_READ);
700 tt_int_op(res.events[1], ==, EV_TIMEOUT);
701 tt_int_op(res.events[2], ==, EV_TIMEOUT);
702 test_timeval_diff_eq(&start, &res.tvs[0], 100);
703 test_timeval_diff_eq(&start, &res.tvs[1], 300);
704 test_timeval_diff_eq(&start, &res.tvs[2], 500);
705 end:
706 event_del(&ev);
707 }
708
709 struct common_timeout_info {
710 struct event ev;
711 struct timeval called_at;
712 int which;
713 int count;
714 };
715
716 static void
common_timeout_cb(evutil_socket_t fd,short event,void * arg)717 common_timeout_cb(evutil_socket_t fd, short event, void *arg)
718 {
719 struct common_timeout_info *ti = arg;
720 ++ti->count;
721 evutil_gettimeofday(&ti->called_at, NULL);
722 if (ti->count >= 4)
723 event_del(&ti->ev);
724 }
725
726 static void
test_common_timeout(void * ptr)727 test_common_timeout(void *ptr)
728 {
729 struct basic_test_data *data = ptr;
730
731 struct event_base *base = data->base;
732 int i;
733 struct common_timeout_info info[100];
734
735 struct timeval start;
736 struct timeval tmp_100_ms = { 0, 100*1000 };
737 struct timeval tmp_200_ms = { 0, 200*1000 };
738 struct timeval tmp_5_sec = { 5, 0 };
739 struct timeval tmp_5M_usec = { 0, 5*1000*1000 };
740
741 const struct timeval *ms_100, *ms_200, *sec_5;
742
743 ms_100 = event_base_init_common_timeout(base, &tmp_100_ms);
744 ms_200 = event_base_init_common_timeout(base, &tmp_200_ms);
745 sec_5 = event_base_init_common_timeout(base, &tmp_5_sec);
746 tt_assert(ms_100);
747 tt_assert(ms_200);
748 tt_assert(sec_5);
749 tt_ptr_op(event_base_init_common_timeout(base, &tmp_200_ms),
750 ==, ms_200);
751 tt_ptr_op(event_base_init_common_timeout(base, ms_200), ==, ms_200);
752 tt_ptr_op(event_base_init_common_timeout(base, &tmp_5M_usec), ==, sec_5);
753 tt_int_op(ms_100->tv_sec, ==, 0);
754 tt_int_op(ms_200->tv_sec, ==, 0);
755 tt_int_op(sec_5->tv_sec, ==, 5);
756 tt_int_op(ms_100->tv_usec, ==, 100000|0x50000000);
757 tt_int_op(ms_200->tv_usec, ==, 200000|0x50100000);
758 tt_int_op(sec_5->tv_usec, ==, 0|0x50200000);
759
760 memset(info, 0, sizeof(info));
761
762 for (i=0; i<100; ++i) {
763 info[i].which = i;
764 event_assign(&info[i].ev, base, -1, EV_TIMEOUT|EV_PERSIST,
765 common_timeout_cb, &info[i]);
766 if (i % 2) {
767 if ((i%20)==1) {
768 /* Glass-box test: Make sure we survive the
769 * transition to non-common timeouts. It's
770 * a little tricky. */
771 event_add(&info[i].ev, ms_200);
772 event_add(&info[i].ev, &tmp_100_ms);
773 } else if ((i%20)==3) {
774 /* Check heap-to-common too. */
775 event_add(&info[i].ev, &tmp_200_ms);
776 event_add(&info[i].ev, ms_100);
777 } else if ((i%20)==5) {
778 /* Also check common-to-common. */
779 event_add(&info[i].ev, ms_200);
780 event_add(&info[i].ev, ms_100);
781 } else {
782 event_add(&info[i].ev, ms_100);
783 }
784 } else {
785 event_add(&info[i].ev, ms_200);
786 }
787 }
788
789 event_base_assert_ok_(base);
790 evutil_gettimeofday(&start, NULL);
791 event_base_dispatch(base);
792
793 event_base_assert_ok_(base);
794
795 for (i=0; i<10; ++i) {
796 tt_int_op(info[i].count, ==, 4);
797 if (i % 2) {
798 test_timeval_diff_eq(&start, &info[i].called_at, 400);
799 } else {
800 test_timeval_diff_eq(&start, &info[i].called_at, 800);
801 }
802 }
803
804 /* Make sure we can free the base with some events in. */
805 for (i=0; i<100; ++i) {
806 if (i % 2) {
807 event_add(&info[i].ev, ms_100);
808 } else {
809 event_add(&info[i].ev, ms_200);
810 }
811 }
812
813 end:
814 event_base_free(data->base); /* need to do this here before info is
815 * out-of-scope */
816 data->base = NULL;
817 }
818
819 #ifndef _WIN32
820 static void signal_cb(evutil_socket_t fd, short event, void *arg);
821
822 #define current_base event_global_current_base_
823 extern struct event_base *current_base;
824
825 static void
child_signal_cb(evutil_socket_t fd,short event,void * arg)826 child_signal_cb(evutil_socket_t fd, short event, void *arg)
827 {
828 struct timeval tv;
829 int *pint = arg;
830
831 *pint = 1;
832
833 tv.tv_usec = 500000;
834 tv.tv_sec = 0;
835 event_loopexit(&tv);
836 }
837
838 static void
test_fork(void)839 test_fork(void)
840 {
841 int status, got_sigchld = 0;
842 struct event ev, sig_ev;
843 pid_t pid;
844
845 setup_test("After fork: ");
846
847 tt_assert(current_base);
848 evthread_make_base_notifiable(current_base);
849
850 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
851 tt_fail_perror("write");
852 }
853
854 event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
855 if (event_add(&ev, NULL) == -1)
856 exit(1);
857
858 evsignal_set(&sig_ev, SIGCHLD, child_signal_cb, &got_sigchld);
859 evsignal_add(&sig_ev, NULL);
860
861 event_base_assert_ok_(current_base);
862 TT_BLATHER(("Before fork"));
863 if ((pid = regress_fork()) == 0) {
864 /* in the child */
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");
869 exit(1);
870 }
871 TT_BLATHER(("After reinit"));
872 event_base_assert_ok_(current_base);
873 TT_BLATHER(("After assert-ok"));
874
875 evsignal_del(&sig_ev);
876
877 called = 0;
878
879 event_dispatch();
880
881 event_base_free(current_base);
882
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
885 * called. */
886 exit(test_ok != 0 || called != 2 ? -2 : 76);
887 }
888
889 /* wait for the child to read the data */
890 {
891 const struct timeval tv = { 0, 100000 };
892 evutil_usleep_(&tv);
893 }
894
895 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
896 tt_fail_perror("write");
897 }
898
899 TT_BLATHER(("Before waitpid"));
900 if (waitpid(pid, &status, 0) == -1) {
901 fprintf(stdout, "FAILED (fork)\n");
902 exit(1);
903 }
904 TT_BLATHER(("After waitpid"));
905
906 if (WEXITSTATUS(status) != 76) {
907 fprintf(stdout, "FAILED (exit): %d\n", WEXITSTATUS(status));
908 exit(1);
909 }
910
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__);
914 }
915
916 shutdown(pair[0], SHUT_WR);
917
918 event_dispatch();
919
920 if (!got_sigchld) {
921 fprintf(stdout, "FAILED (sigchld)\n");
922 exit(1);
923 }
924
925 evsignal_del(&sig_ev);
926
927 end:
928 cleanup_test();
929 }
930
931 static void
signal_cb_sa(int sig)932 signal_cb_sa(int sig)
933 {
934 test_ok = 2;
935 }
936
937 static void
signal_cb(evutil_socket_t fd,short event,void * arg)938 signal_cb(evutil_socket_t fd, short event, void *arg)
939 {
940 struct event *ev = arg;
941
942 evsignal_del(ev);
943 test_ok = 1;
944 }
945
946 static void
test_simplesignal_impl(int find_reorder)947 test_simplesignal_impl(int find_reorder)
948 {
949 struct event ev;
950 struct itimerval itv;
951
952 evsignal_set(&ev, SIGALRM, signal_cb, &ev);
953 evsignal_add(&ev, NULL);
954 /* find bugs in which operations are re-ordered */
955 if (find_reorder) {
956 evsignal_del(&ev);
957 evsignal_add(&ev, NULL);
958 }
959
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;
965
966 event_dispatch();
967 skip_simplesignal:
968 if (evsignal_del(&ev) == -1)
969 test_ok = 0;
970
971 cleanup_test();
972 }
973
974 static void
test_simplestsignal(void)975 test_simplestsignal(void)
976 {
977 setup_test("Simplest one signal: ");
978 test_simplesignal_impl(0);
979 }
980
981 static void
test_simplesignal(void)982 test_simplesignal(void)
983 {
984 setup_test("Simple signal: ");
985 test_simplesignal_impl(1);
986 }
987
988 static void
test_multiplesignal(void)989 test_multiplesignal(void)
990 {
991 struct event ev_one, ev_two;
992 struct itimerval itv;
993
994 setup_test("Multiple signal: ");
995
996 evsignal_set(&ev_one, SIGALRM, signal_cb, &ev_one);
997 evsignal_add(&ev_one, NULL);
998
999 evsignal_set(&ev_two, SIGALRM, signal_cb, &ev_two);
1000 evsignal_add(&ev_two, NULL);
1001
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;
1007
1008 event_dispatch();
1009
1010 skip_simplesignal:
1011 if (evsignal_del(&ev_one) == -1)
1012 test_ok = 0;
1013 if (evsignal_del(&ev_two) == -1)
1014 test_ok = 0;
1015
1016 cleanup_test();
1017 }
1018
1019 static void
test_immediatesignal(void)1020 test_immediatesignal(void)
1021 {
1022 struct event ev;
1023
1024 test_ok = 0;
1025 evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
1026 evsignal_add(&ev, NULL);
1027 raise(SIGUSR1);
1028 event_loop(EVLOOP_NONBLOCK);
1029 evsignal_del(&ev);
1030 cleanup_test();
1031 }
1032
1033 static void
test_signal_dealloc(void)1034 test_signal_dealloc(void)
1035 {
1036 /* make sure that evsignal_event is event_del'ed and pipe closed */
1037 struct event ev;
1038 struct event_base *base = event_init();
1039 evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
1040 evsignal_add(&ev, NULL);
1041 evsignal_del(&ev);
1042 event_base_free(base);
1043 /* If we got here without asserting, we're fine. */
1044 test_ok = 1;
1045 cleanup_test();
1046 }
1047
1048 static void
test_signal_pipeloss(void)1049 test_signal_pipeloss(void)
1050 {
1051 /* make sure that the base1 pipe is closed correctly. */
1052 struct event_base *base1, *base2;
1053 int pipe1;
1054 test_ok = 0;
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. ");
1063 test_ok = 0;
1064 } else {
1065 test_ok = 1;
1066 }
1067 cleanup_test();
1068 }
1069
1070 /*
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.
1074 */
1075 static void
test_signal_switchbase(void)1076 test_signal_switchbase(void)
1077 {
1078 struct event ev1, ev2;
1079 struct event_base *base1, *base2;
1080 int is_kqueue;
1081 test_ok = 0;
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__);
1092 exit(1);
1093 }
1094
1095 tt_ptr_op(event_get_base(&ev1), ==, base1);
1096 tt_ptr_op(event_get_base(&ev2), ==, base2);
1097
1098 test_ok = 0;
1099 /* can handle signal before loop is called */
1100 raise(SIGUSR1);
1101 event_base_loop(base2, EVLOOP_NONBLOCK);
1102 if (is_kqueue) {
1103 if (!test_ok)
1104 goto end;
1105 test_ok = 0;
1106 }
1107 event_base_loop(base1, EVLOOP_NONBLOCK);
1108 if (test_ok && !is_kqueue) {
1109 test_ok = 0;
1110
1111 /* set base1 to handle signals */
1112 event_base_loop(base1, EVLOOP_NONBLOCK);
1113 raise(SIGUSR1);
1114 event_base_loop(base1, EVLOOP_NONBLOCK);
1115 event_base_loop(base2, EVLOOP_NONBLOCK);
1116 }
1117 end:
1118 event_base_free(base1);
1119 event_base_free(base2);
1120 cleanup_test();
1121 }
1122
1123 /*
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.
1126 */
1127 static void
test_signal_assert(void)1128 test_signal_assert(void)
1129 {
1130 struct event ev;
1131 struct event_base *base = event_init();
1132 test_ok = 0;
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);
1136 /*
1137 * if evsignal_del() fails to reset the handler, it's current handler
1138 * will still point to evsig_handler().
1139 */
1140 evsignal_del(&ev);
1141
1142 raise(SIGCONT);
1143 #if 0
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)
1147 test_ok = 0;
1148 else
1149 test_ok = 1;
1150 #else
1151 test_ok = 1;
1152 #endif
1153
1154 event_base_free(base);
1155 cleanup_test();
1156 return;
1157 }
1158
1159 /*
1160 * assert that we restore our previous signal handler properly.
1161 */
1162 static void
test_signal_restore(void)1163 test_signal_restore(void)
1164 {
1165 struct event ev;
1166 struct event_base *base = event_init();
1167 #ifdef EVENT__HAVE_SIGACTION
1168 struct sigaction sa;
1169 #endif
1170
1171 test_ok = 0;
1172 #ifdef EVENT__HAVE_SIGACTION
1173 sa.sa_handler = signal_cb_sa;
1174 sa.sa_flags = 0x0;
1175 sigemptyset(&sa.sa_mask);
1176 if (sigaction(SIGUSR1, &sa, NULL) == -1)
1177 goto out;
1178 #else
1179 if (signal(SIGUSR1, signal_cb_sa) == SIG_ERR)
1180 goto out;
1181 #endif
1182 evsignal_set(&ev, SIGUSR1, signal_cb, &ev);
1183 evsignal_add(&ev, NULL);
1184 evsignal_del(&ev);
1185
1186 raise(SIGUSR1);
1187 /* 1 == signal_cb, 2 == signal_cb_sa, we want our previous handler */
1188 if (test_ok != 2)
1189 test_ok = 0;
1190 out:
1191 event_base_free(base);
1192 cleanup_test();
1193 return;
1194 }
1195
1196 static void
signal_cb_swp(int sig,short event,void * arg)1197 signal_cb_swp(int sig, short event, void *arg)
1198 {
1199 called++;
1200 if (called < 5)
1201 raise(sig);
1202 else
1203 event_loopexit(NULL);
1204 }
1205 static void
timeout_cb_swp(evutil_socket_t fd,short event,void * arg)1206 timeout_cb_swp(evutil_socket_t fd, short event, void *arg)
1207 {
1208 if (called == -1) {
1209 struct timeval tv = {5, 0};
1210
1211 called = 0;
1212 evtimer_add((struct event *)arg, &tv);
1213 raise(SIGUSR1);
1214 return;
1215 }
1216 test_ok = 0;
1217 event_loopexit(NULL);
1218 }
1219
1220 static void
test_signal_while_processing(void)1221 test_signal_while_processing(void)
1222 {
1223 struct event_base *base = event_init();
1224 struct event ev, ev_timer;
1225 struct timeval tv = {0, 0};
1226
1227 setup_test("Receiving a signal while processing other signal: ");
1228
1229 called = -1;
1230 test_ok = 1;
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);
1235 event_dispatch();
1236
1237 event_base_free(base);
1238 cleanup_test();
1239 return;
1240 }
1241 #endif
1242
1243 static void
test_free_active_base(void * ptr)1244 test_free_active_base(void *ptr)
1245 {
1246 struct basic_test_data *data = ptr;
1247 struct event_base *base1;
1248 struct event ev1;
1249
1250 base1 = event_init();
1251 if (base1) {
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 */
1256 } else {
1257 tt_fail_msg("failed to create event_base for test");
1258 }
1259
1260 base1 = event_init();
1261 tt_assert(base1);
1262 event_assign(&ev1, base1, 0, 0, dummy_read_cb, NULL);
1263 event_active(&ev1, EV_READ, 1);
1264 event_base_free(base1);
1265 end:
1266 ;
1267 }
1268
1269 static void
test_manipulate_active_events(void * ptr)1270 test_manipulate_active_events(void *ptr)
1271 {
1272 struct basic_test_data *data = ptr;
1273 struct event_base *base = data->base;
1274 struct event ev1;
1275
1276 event_assign(&ev1, base, -1, EV_TIMEOUT, dummy_read_cb, NULL);
1277
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),
1281 ==, EV_READ);
1282
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);
1287
1288 end:
1289 event_del(&ev1);
1290 }
1291
1292 static void
event_selfarg_cb(evutil_socket_t fd,short event,void * arg)1293 event_selfarg_cb(evutil_socket_t fd, short event, void *arg)
1294 {
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));
1300 }
1301
1302 static void
test_event_new_selfarg(void * ptr)1303 test_event_new_selfarg(void *ptr)
1304 {
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());
1309
1310 event_active(ev, EV_READ, 1);
1311 event_base_dispatch(base);
1312
1313 event_free(ev);
1314 }
1315
1316 static void
test_event_assign_selfarg(void * ptr)1317 test_event_assign_selfarg(void *ptr)
1318 {
1319 struct basic_test_data *data = ptr;
1320 struct event_base *base = data->base;
1321 struct event ev;
1322
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);
1327 }
1328
1329 static void
test_event_base_get_num_events(void * ptr)1330 test_event_base_get_num_events(void *ptr)
1331 {
1332 struct basic_test_data *data = ptr;
1333 struct event_base *base = data->base;
1334 struct event ev;
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;
1342
1343 struct timeval qsec = {0, 100000};
1344
1345 event_assign(&ev, base, -1, EV_READ, event_selfarg_cb,
1346 event_self_cbarg());
1347
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);
1373
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);
1398
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);
1423
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);
1448
1449 end:
1450 ;
1451 }
1452
1453 static void
test_event_base_get_max_events(void * ptr)1454 test_event_base_get_max_events(void *ptr)
1455 {
1456 struct basic_test_data *data = ptr;
1457 struct event_base *base = data->base;
1458 struct event ev;
1459 struct event ev2;
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;
1467
1468 struct timeval qsec = {0, 100000};
1469
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());
1474
1475 event_add(&ev, &qsec);
1476 event_add(&ev2, &qsec);
1477 event_del(&ev2);
1478
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);
1495
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);
1504
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);
1522
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);
1530
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);
1548
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);
1556
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);
1566
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);
1584
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);
1592
1593 end:
1594 ;
1595 }
1596
1597 static void
test_bad_assign(void * ptr)1598 test_bad_assign(void *ptr)
1599 {
1600 struct event ev;
1601 int r;
1602 /* READ|SIGNAL is not allowed */
1603 r = event_assign(&ev, NULL, -1, EV_SIGNAL|EV_READ, dummy_read_cb, NULL);
1604 tt_int_op(r,==,-1);
1605
1606 end:
1607 ;
1608 }
1609
1610 static int reentrant_cb_run = 0;
1611
1612 static void
bad_reentrant_run_loop_cb(evutil_socket_t fd,short what,void * ptr)1613 bad_reentrant_run_loop_cb(evutil_socket_t fd, short what, void *ptr)
1614 {
1615 struct event_base *base = ptr;
1616 int r;
1617 reentrant_cb_run = 1;
1618 /* This reentrant call to event_base_loop should be detected and
1619 * should fail */
1620 r = event_base_loop(base, 0);
1621 tt_int_op(r, ==, -1);
1622 end:
1623 ;
1624 }
1625
1626 static void
test_bad_reentrant(void * ptr)1627 test_bad_reentrant(void *ptr)
1628 {
1629 struct basic_test_data *data = ptr;
1630 struct event_base *base = data->base;
1631 struct event ev;
1632 int r;
1633 event_assign(&ev, base, -1,
1634 0, bad_reentrant_run_loop_cb, base);
1635
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);
1640 end:
1641 ;
1642 }
1643
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;
1647 static void
write_a_byte_cb(evutil_socket_t fd,short what,void * arg)1648 write_a_byte_cb(evutil_socket_t fd, short what, void *arg)
1649 {
1650 char buf[] = "x";
1651 if (write(fd, buf, 1) == 1)
1652 ++n_write_a_byte_cb;
1653 }
1654 static void
read_and_drain_cb(evutil_socket_t fd,short what,void * arg)1655 read_and_drain_cb(evutil_socket_t fd, short what, void *arg)
1656 {
1657 char buf[128];
1658 int n;
1659 ++n_read_and_drain_cb;
1660 while ((n = read(fd, buf, sizeof(buf))) > 0)
1661 ;
1662 }
1663
1664 static void
activate_other_event_cb(evutil_socket_t fd,short what,void * other_)1665 activate_other_event_cb(evutil_socket_t fd, short what, void *other_)
1666 {
1667 struct event *ev_activate = other_;
1668 ++n_activate_other_event_cb;
1669 event_active_later_(ev_activate, EV_READ);
1670 }
1671
1672 static void
test_active_later(void * ptr)1673 test_active_later(void *ptr)
1674 {
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);
1686
1687 event_base_loopexit(data->base, &qsec);
1688
1689 event_base_loop(data->base, 0);
1690
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));
1693 event_del(&ev3);
1694 event_del(&ev4);
1695
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);
1700
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);
1706
1707 /* Now leave this one around, so that event_free sees it and removes
1708 * it. */
1709 event_active_later_(&ev3, EV_READ);
1710 event_base_assert_ok_(data->base);
1711
1712 end:
1713 if (ev1)
1714 event_free(ev1);
1715 if (ev2)
1716 event_free(ev2);
1717
1718 event_base_free(data->base);
1719 data->base = NULL;
1720 }
1721
1722
incr_arg_cb(evutil_socket_t fd,short what,void * arg)1723 static void incr_arg_cb(evutil_socket_t fd, short what, void *arg)
1724 {
1725 int *intptr = arg;
1726 (void) fd; (void) what;
1727 ++*intptr;
1728 }
remove_timers_cb(evutil_socket_t fd,short what,void * arg)1729 static void remove_timers_cb(evutil_socket_t fd, short what, void *arg)
1730 {
1731 struct event **ep = arg;
1732 (void) fd; (void) what;
1733 event_remove_timer(ep[0]);
1734 event_remove_timer(ep[1]);
1735 }
send_a_byte_cb(evutil_socket_t fd,short what,void * arg)1736 static void send_a_byte_cb(evutil_socket_t fd, short what, void *arg)
1737 {
1738 evutil_socket_t *sockp = arg;
1739 (void) fd; (void) what;
1740 (void) write(*sockp, "A", 1);
1741 }
1742 struct read_not_timeout_param
1743 {
1744 struct event **ev;
1745 int events;
1746 int count;
1747 };
read_not_timeout_cb(evutil_socket_t fd,short what,void * arg)1748 static void read_not_timeout_cb(evutil_socket_t fd, short what, void *arg)
1749 {
1750 struct read_not_timeout_param *rntp = arg;
1751 char c;
1752 ev_ssize_t n;
1753 (void) fd; (void) what;
1754 n = read(fd, &c, 1);
1755 tt_int_op(n, ==, 1);
1756 rntp->events |= what;
1757 ++rntp->count;
1758 if(2 == rntp->count) event_del(rntp->ev[0]);
1759 end:
1760 ;
1761 }
1762
1763 static void
test_event_remove_timeout(void * ptr)1764 test_event_remove_timeout(void *ptr)
1765 {
1766 struct basic_test_data *data = ptr;
1767 struct event_base *base = data->base;
1768 struct event *ev[5];
1769 int ev1_fired=0;
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 };
1775
1776 event_base_assert_ok_(base);
1777
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]);
1784 tt_assert(base);
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);
1791
1792 event_base_dispatch(base);
1793
1794 tt_int_op(ev1_fired, ==, 0);
1795 tt_int_op(rntp.events, ==, EV_READ);
1796
1797 event_base_assert_ok_(base);
1798 end:
1799 event_free(ev[0]);
1800 event_free(ev[1]);
1801 event_free(ev[2]);
1802 event_free(ev[3]);
1803 event_free(ev[4]);
1804 }
1805
1806 static void
test_event_base_new(void * ptr)1807 test_event_base_new(void *ptr)
1808 {
1809 struct basic_test_data *data = ptr;
1810 struct event_base *base = 0;
1811 struct event ev1;
1812 struct basic_cb_args args;
1813
1814 int towrite = (int)strlen(TEST1)+1;
1815 int len = write(data->pair[0], TEST1, towrite);
1816
1817 if (len < 0)
1818 tt_abort_perror("initial write");
1819 else if (len != towrite)
1820 tt_abort_printf(("initial write fell short (%d of %d bytes)",
1821 len, towrite));
1822
1823 if (shutdown(data->pair[0], SHUT_WR))
1824 tt_abort_perror("initial write shutdown");
1825
1826 base = event_base_new();
1827 if (!base)
1828 tt_abort_msg("failed to create event base");
1829
1830 args.eb = base;
1831 args.ev = &ev1;
1832 args.callcount = 0;
1833 event_assign(&ev1, base, data->pair[1],
1834 EV_READ|EV_PERSIST, basic_read_cb, &args);
1835
1836 if (event_add(&ev1, NULL))
1837 tt_abort_perror("initial event_add");
1838
1839 if (event_base_loop(base, 0))
1840 tt_abort_msg("unsuccessful exit from event loop");
1841
1842 end:
1843 if (base)
1844 event_base_free(base);
1845 }
1846
1847 static void
test_loopexit(void)1848 test_loopexit(void)
1849 {
1850 struct timeval tv, tv_start, tv_end;
1851 struct event ev;
1852
1853 setup_test("Loop exit: ");
1854
1855 tv.tv_usec = 0;
1856 tv.tv_sec = 60*60*24;
1857 evtimer_set(&ev, timeout_cb, NULL);
1858 evtimer_add(&ev, &tv);
1859
1860 tv.tv_usec = 300*1000;
1861 tv.tv_sec = 0;
1862 event_loopexit(&tv);
1863
1864 evutil_gettimeofday(&tv_start, NULL);
1865 event_dispatch();
1866 evutil_gettimeofday(&tv_end, NULL);
1867
1868 evtimer_del(&ev);
1869
1870 tt_assert(event_base_got_exit(global_base));
1871 tt_assert(!event_base_got_break(global_base));
1872
1873 test_timeval_diff_eq(&tv_start, &tv_end, 300);
1874
1875 test_ok = 1;
1876 end:
1877 cleanup_test();
1878 }
1879
1880 static void
test_loopexit_multiple(void)1881 test_loopexit_multiple(void)
1882 {
1883 struct timeval tv, tv_start, tv_end;
1884 struct event_base *base;
1885
1886 setup_test("Loop Multiple exit: ");
1887
1888 base = event_base_new();
1889
1890 tv.tv_usec = 200*1000;
1891 tv.tv_sec = 0;
1892 event_base_loopexit(base, &tv);
1893
1894 tv.tv_usec = 0;
1895 tv.tv_sec = 3;
1896 event_base_loopexit(base, &tv);
1897
1898 evutil_gettimeofday(&tv_start, NULL);
1899 event_base_dispatch(base);
1900 evutil_gettimeofday(&tv_end, NULL);
1901
1902 tt_assert(event_base_got_exit(base));
1903 tt_assert(!event_base_got_break(base));
1904
1905 event_base_free(base);
1906
1907 test_timeval_diff_eq(&tv_start, &tv_end, 200);
1908
1909 test_ok = 1;
1910
1911 end:
1912 cleanup_test();
1913 }
1914
1915 static void
break_cb(evutil_socket_t fd,short events,void * arg)1916 break_cb(evutil_socket_t fd, short events, void *arg)
1917 {
1918 test_ok = 1;
1919 event_loopbreak();
1920 }
1921
1922 static void
fail_cb(evutil_socket_t fd,short events,void * arg)1923 fail_cb(evutil_socket_t fd, short events, void *arg)
1924 {
1925 test_ok = 0;
1926 }
1927
1928 static void
test_loopbreak(void)1929 test_loopbreak(void)
1930 {
1931 struct event ev1, ev2;
1932 struct timeval tv;
1933
1934 setup_test("Loop break: ");
1935
1936 tv.tv_sec = 0;
1937 tv.tv_usec = 0;
1938 evtimer_set(&ev1, break_cb, NULL);
1939 evtimer_add(&ev1, &tv);
1940 evtimer_set(&ev2, fail_cb, NULL);
1941 evtimer_add(&ev2, &tv);
1942
1943 event_dispatch();
1944
1945 tt_assert(!event_base_got_exit(global_base));
1946 tt_assert(event_base_got_break(global_base));
1947
1948 evtimer_del(&ev1);
1949 evtimer_del(&ev2);
1950
1951 end:
1952 cleanup_test();
1953 }
1954
1955 static struct event *readd_test_event_last_added = NULL;
1956 static void
re_add_read_cb(evutil_socket_t fd,short event,void * arg)1957 re_add_read_cb(evutil_socket_t fd, short event, void *arg)
1958 {
1959 char buf[256];
1960 struct event *ev_other = arg;
1961 ev_ssize_t n_read;
1962
1963 readd_test_event_last_added = ev_other;
1964
1965 n_read = read(fd, buf, sizeof(buf));
1966
1967 if (n_read < 0) {
1968 tt_fail_perror("read");
1969 event_base_loopbreak(event_get_base(ev_other));
1970 return;
1971 } else {
1972 event_add(ev_other, NULL);
1973 ++test_ok;
1974 }
1975 }
1976
1977 static void
test_nonpersist_readd(void)1978 test_nonpersist_readd(void)
1979 {
1980 struct event ev1, ev2;
1981
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);
1985
1986 if (write(pair[0], "Hello", 5) < 0) {
1987 tt_fail_perror("write(pair[0])");
1988 }
1989
1990 if (write(pair[1], "Hello", 5) < 0) {
1991 tt_fail_perror("write(pair[1])\n");
1992 }
1993
1994 if (event_add(&ev1, NULL) == -1 ||
1995 event_add(&ev2, NULL) == -1) {
1996 test_ok = 0;
1997 }
1998 if (test_ok != 0)
1999 exit(1);
2000 event_loop(EVLOOP_ONCE);
2001 if (test_ok != 2)
2002 exit(1);
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.
2007 */
2008 if (!readd_test_event_last_added) {
2009 test_ok = 0;
2010 } else if (readd_test_event_last_added == &ev1) {
2011 if (!event_pending(&ev1, EV_READ, NULL) ||
2012 event_pending(&ev2, EV_READ, NULL))
2013 test_ok = 0;
2014 } else {
2015 if (event_pending(&ev1, EV_READ, NULL) ||
2016 !event_pending(&ev2, EV_READ, NULL))
2017 test_ok = 0;
2018 }
2019
2020 event_del(&ev1);
2021 event_del(&ev2);
2022
2023 cleanup_test();
2024 }
2025
2026 struct test_pri_event {
2027 struct event ev;
2028 int count;
2029 };
2030
2031 static void
test_priorities_cb(evutil_socket_t fd,short what,void * arg)2032 test_priorities_cb(evutil_socket_t fd, short what, void *arg)
2033 {
2034 struct test_pri_event *pri = arg;
2035 struct timeval tv;
2036
2037 if (pri->count == 3) {
2038 event_loopexit(NULL);
2039 return;
2040 }
2041
2042 pri->count++;
2043
2044 evutil_timerclear(&tv);
2045 event_add(&pri->ev, &tv);
2046 }
2047
2048 static void
test_priorities_impl(int npriorities)2049 test_priorities_impl(int npriorities)
2050 {
2051 struct test_pri_event one, two;
2052 struct timeval tv;
2053
2054 TT_BLATHER(("Testing Priorities %d: ", npriorities));
2055
2056 event_base_priority_init(global_base, npriorities);
2057
2058 memset(&one, 0, sizeof(one));
2059 memset(&two, 0, sizeof(two));
2060
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__);
2064 exit(1);
2065 }
2066
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__);
2070 exit(1);
2071 }
2072
2073 evutil_timerclear(&tv);
2074
2075 if (event_add(&one.ev, &tv) == -1)
2076 exit(1);
2077 if (event_add(&two.ev, &tv) == -1)
2078 exit(1);
2079
2080 event_dispatch();
2081
2082 event_del(&one.ev);
2083 event_del(&two.ev);
2084
2085 if (npriorities == 1) {
2086 if (one.count == 3 && two.count == 3)
2087 test_ok = 1;
2088 } else if (npriorities == 2) {
2089 /* Two is called once because event_loopexit is priority 1 */
2090 if (one.count == 3 && two.count == 1)
2091 test_ok = 1;
2092 } else {
2093 if (one.count == 3 && two.count == 0)
2094 test_ok = 1;
2095 }
2096 }
2097
2098 static void
test_priorities(void)2099 test_priorities(void)
2100 {
2101 test_priorities_impl(1);
2102 if (test_ok)
2103 test_priorities_impl(2);
2104 if (test_ok)
2105 test_priorities_impl(3);
2106 }
2107
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];
2112
2113 static void
prio_active_inversion_cb(evutil_socket_t fd,short what,void * arg)2114 prio_active_inversion_cb(evutil_socket_t fd, short what, void *arg)
2115 {
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);
2125 }
2126 }
2127
2128 static void
test_priority_active_inversion(void * data_)2129 test_priority_active_inversion(void *data_)
2130 {
2131 struct basic_test_data *data = data_;
2132 struct event_base *base = data->base;
2133 int call_order[3];
2134 int i;
2135 tt_int_op(event_base_priority_init(base, 8), ==, 0);
2136
2137 n_pai_calls = 0;
2138 memset(call_order, 0, sizeof(call_order));
2139
2140 for (i=0;i<3;++i) {
2141 event_assign(&pai_events[i], data->base, -1, 0,
2142 prio_active_inversion_cb, &call_order[i]);
2143 }
2144
2145 event_priority_set(&pai_events[0], 4);
2146 event_priority_set(&pai_events[1], 4);
2147 event_priority_set(&pai_events[2], 0);
2148
2149 event_active(&pai_events[0], EV_WRITE, 1);
2150
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);
2156 end:
2157 ;
2158 }
2159
2160
2161 static void
test_multiple_cb(evutil_socket_t fd,short event,void * arg)2162 test_multiple_cb(evutil_socket_t fd, short event, void *arg)
2163 {
2164 if (event & EV_READ)
2165 test_ok |= 1;
2166 else if (event & EV_WRITE)
2167 test_ok |= 2;
2168 }
2169
2170 static void
test_multiple_events_for_same_fd(void)2171 test_multiple_events_for_same_fd(void)
2172 {
2173 struct event e1, e2;
2174
2175 setup_test("Multiple events for same fd: ");
2176
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);
2182 event_del(&e2);
2183
2184 if (write(pair[1], TEST1, strlen(TEST1)+1) < 0) {
2185 tt_fail_perror("write");
2186 }
2187
2188 event_loop(EVLOOP_ONCE);
2189 event_del(&e1);
2190
2191 if (test_ok != 3)
2192 test_ok = 0;
2193
2194 cleanup_test();
2195 }
2196
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);
2201
2202 static void
read_once_cb(evutil_socket_t fd,short event,void * arg)2203 read_once_cb(evutil_socket_t fd, short event, void *arg)
2204 {
2205 char buf[256];
2206 int len;
2207
2208 len = read(fd, buf, sizeof(buf));
2209
2210 if (called) {
2211 test_ok = 0;
2212 } else if (len) {
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");
2216 test_ok = 0;
2217 } else {
2218 test_ok = 1;
2219 }
2220 }
2221
2222 called++;
2223 }
2224
2225 static void
test_want_only_once(void)2226 test_want_only_once(void)
2227 {
2228 struct event ev;
2229 struct timeval tv;
2230
2231 /* Very simple read test */
2232 setup_test("Want read only once: ");
2233
2234 if (write(pair[0], TEST1, strlen(TEST1)+1) < 0) {
2235 tt_fail_perror("write");
2236 }
2237
2238 /* Setup the loop termination */
2239 evutil_timerclear(&tv);
2240 tv.tv_usec = 300*1000;
2241 event_loopexit(&tv);
2242
2243 event_set(&ev, pair[1], EV_READ, read_once_cb, &ev);
2244 if (event_add(&ev, NULL) == -1)
2245 exit(1);
2246 event_dispatch();
2247
2248 cleanup_test();
2249 }
2250
2251 #define TEST_MAX_INT 6
2252
2253 static void
evtag_int_test(void * ptr)2254 evtag_int_test(void *ptr)
2255 {
2256 struct evbuffer *tmp = evbuffer_new();
2257 ev_uint32_t integers[TEST_MAX_INT] = {
2258 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
2259 };
2260 ev_uint32_t integer;
2261 ev_uint64_t big_int;
2262 int i;
2263
2264 evtag_init();
2265
2266 for (i = 0; i < TEST_MAX_INT; i++) {
2267 int oldlen, newlen;
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);
2276 }
2277
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]);
2283 }
2284
2285 tt_uint_op(EVBUFFER_LENGTH(tmp), ==, 0);
2286 end:
2287 evbuffer_free(tmp);
2288 }
2289
2290 static void
evtag_fuzz(void * ptr)2291 evtag_fuzz(void *ptr)
2292 {
2293 u_char buffer[4096];
2294 struct evbuffer *tmp = evbuffer_new();
2295 struct timeval tv;
2296 int i, j;
2297
2298 int not_failed = 0;
2299
2300 evtag_init();
2301
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));
2307
2308 if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1)
2309 not_failed++;
2310 }
2311
2312 /* The majority of decodes should fail */
2313 tt_int_op(not_failed, <, 10);
2314
2315 /* Now insert some corruption into the tag length field */
2316 evbuffer_drain(tmp, -1);
2317 evutil_timerclear(&tv);
2318 tv.tv_sec = 1;
2319 evtag_marshal_timeval(tmp, 0, &tv);
2320 evbuffer_add(tmp, buffer, sizeof(buffer));
2321
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");
2325 }
2326
2327 end:
2328 evbuffer_free(tmp);
2329 }
2330
2331 static void
evtag_tag_encoding(void * ptr)2332 evtag_tag_encoding(void *ptr)
2333 {
2334 struct evbuffer *tmp = evbuffer_new();
2335 ev_uint32_t integers[TEST_MAX_INT] = {
2336 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
2337 };
2338 ev_uint32_t integer;
2339 int i;
2340
2341 evtag_init();
2342
2343 for (i = 0; i < TEST_MAX_INT; i++) {
2344 int oldlen, newlen;
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));
2350 }
2351
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]);
2355 }
2356
2357 tt_uint_op(EVBUFFER_LENGTH(tmp), ==, 0);
2358
2359 end:
2360 evbuffer_free(tmp);
2361 }
2362
2363 static void
evtag_test_peek(void * ptr)2364 evtag_test_peek(void *ptr)
2365 {
2366 struct evbuffer *tmp = evbuffer_new();
2367 ev_uint32_t u32;
2368
2369 evtag_marshal_int(tmp, 30, 0);
2370 evtag_marshal_string(tmp, 40, "Hello world");
2371
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);
2377
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);
2384
2385 end:
2386 evbuffer_free(tmp);
2387 }
2388
2389
2390 static void
test_methods(void * ptr)2391 test_methods(void *ptr)
2392 {
2393 const char **methods = event_get_supported_methods();
2394 struct event_config *cfg = NULL;
2395 struct event_base *base = NULL;
2396 const char *backend;
2397 int n_methods = 0;
2398
2399 tt_assert(methods);
2400
2401 backend = methods[0];
2402 while (*methods != NULL) {
2403 TT_BLATHER(("Support method: %s", *methods));
2404 ++methods;
2405 ++n_methods;
2406 }
2407
2408 cfg = event_config_new();
2409 assert(cfg != NULL);
2410
2411 tt_int_op(event_config_avoid_method(cfg, backend), ==, 0);
2412 event_config_set_flag(cfg, EVENT_BASE_FLAG_IGNORE_ENV);
2413
2414 base = event_base_new_with_config(cfg);
2415 if (n_methods > 1) {
2416 tt_assert(base);
2417 tt_str_op(backend, !=, event_base_get_method(base));
2418 } else {
2419 tt_assert(base == NULL);
2420 }
2421
2422 end:
2423 if (base)
2424 event_base_free(base);
2425 if (cfg)
2426 event_config_free(cfg);
2427 }
2428
2429 static void
test_version(void * arg)2430 test_version(void *arg)
2431 {
2432 const char *vstr;
2433 ev_uint32_t vint;
2434 int major, minor, patch, n;
2435
2436 vstr = event_get_version();
2437 vint = event_get_version_number();
2438
2439 tt_assert(vstr);
2440 tt_assert(vint);
2441
2442 tt_str_op(vstr, ==, LIBEVENT_VERSION);
2443 tt_int_op(vint, ==, LIBEVENT_VERSION_NUMBER);
2444
2445 n = sscanf(vstr, "%d.%d.%d", &major, &minor, &patch);
2446 tt_assert(3 == n);
2447 tt_int_op((vint&0xffffff00), ==, ((major<<24)|(minor<<16)|(patch<<8)));
2448 end:
2449 ;
2450 }
2451
2452 static void
test_base_features(void * arg)2453 test_base_features(void *arg)
2454 {
2455 struct event_base *base = NULL;
2456 struct event_config *cfg = NULL;
2457
2458 cfg = event_config_new();
2459
2460 tt_assert(0 == event_config_require_features(cfg, EV_FEATURE_ET));
2461
2462 base = event_base_new_with_config(cfg);
2463 if (base) {
2464 tt_int_op(EV_FEATURE_ET, ==,
2465 event_base_get_features(base) & EV_FEATURE_ET);
2466 } else {
2467 base = event_base_new();
2468 tt_int_op(0, ==, event_base_get_features(base) & EV_FEATURE_ET);
2469 }
2470
2471 end:
2472 if (base)
2473 event_base_free(base);
2474 if (cfg)
2475 event_config_free(cfg);
2476 }
2477
2478 #ifdef EVENT__HAVE_SETENV
2479 #define SETENV_OK
2480 #elif !defined(EVENT__HAVE_SETENV) && defined(EVENT__HAVE_PUTENV)
setenv(const char * k,const char * v,int o_)2481 static void setenv(const char *k, const char *v, int o_)
2482 {
2483 char b[256];
2484 evutil_snprintf(b, sizeof(b), "%s=%s",k,v);
2485 putenv(b);
2486 }
2487 #define SETENV_OK
2488 #endif
2489
2490 #ifdef EVENT__HAVE_UNSETENV
2491 #define UNSETENV_OK
2492 #elif !defined(EVENT__HAVE_UNSETENV) && defined(EVENT__HAVE_PUTENV)
unsetenv(const char * k)2493 static void unsetenv(const char *k)
2494 {
2495 char b[256];
2496 evutil_snprintf(b, sizeof(b), "%s=",k);
2497 putenv(b);
2498 }
2499 #define UNSETENV_OK
2500 #endif
2501
2502 #if defined(SETENV_OK) && defined(UNSETENV_OK)
2503 static void
methodname_to_envvar(const char * mname,char * buf,size_t buflen)2504 methodname_to_envvar(const char *mname, char *buf, size_t buflen)
2505 {
2506 char *cp;
2507 evutil_snprintf(buf, buflen, "EVENT_NO%s", mname);
2508 for (cp = buf; *cp; ++cp) {
2509 *cp = EVUTIL_TOUPPER_(*cp);
2510 }
2511 }
2512 #endif
2513
2514 static void
test_base_environ(void * arg)2515 test_base_environ(void *arg)
2516 {
2517 struct event_base *base = NULL;
2518 struct event_config *cfg = NULL;
2519
2520 #if defined(SETENV_OK) && defined(UNSETENV_OK)
2521 const char **basenames;
2522 int i, n_methods=0;
2523 char varbuf[128];
2524 const char *defaultname, *ignoreenvname;
2525
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"));
2532 #else
2533 TT_DECLARE("NOTE", ("unsetenv doesn't work; skipping test"));
2534 #endif
2535 tt_skip();
2536 }
2537
2538 basenames = event_get_supported_methods();
2539 for (i = 0; basenames[i]; ++i) {
2540 methodname_to_envvar(basenames[i], varbuf, sizeof(varbuf));
2541 unsetenv(varbuf);
2542 ++n_methods;
2543 }
2544
2545 base = event_base_new();
2546 tt_assert(base);
2547
2548 defaultname = event_base_get_method(base);
2549 TT_BLATHER(("default is <%s>", defaultname));
2550 event_base_free(base);
2551 base = NULL;
2552
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";
2557 } else {
2558 methodname_to_envvar(defaultname, varbuf, sizeof(varbuf));
2559 setenv(varbuf, "1", 1);
2560 ignoreenvname = defaultname;
2561 }
2562
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);
2567 cfg = NULL;
2568 if (n_methods == 1) {
2569 tt_assert(!base);
2570 } else {
2571 tt_assert(base);
2572 tt_str_op(defaultname, !=, event_base_get_method(base));
2573 event_base_free(base);
2574 base = NULL;
2575 }
2576
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);
2581 tt_assert(base);
2582 tt_str_op(ignoreenvname, ==, event_base_get_method(base));
2583 #else
2584 tt_skip();
2585 #endif
2586
2587 end:
2588 if (base)
2589 event_base_free(base);
2590 if (cfg)
2591 event_config_free(cfg);
2592 }
2593
2594 static void
read_called_once_cb(evutil_socket_t fd,short event,void * arg)2595 read_called_once_cb(evutil_socket_t fd, short event, void *arg)
2596 {
2597 tt_int_op(event, ==, EV_READ);
2598 called += 1;
2599 end:
2600 ;
2601 }
2602
2603 static void
timeout_called_once_cb(evutil_socket_t fd,short event,void * arg)2604 timeout_called_once_cb(evutil_socket_t fd, short event, void *arg)
2605 {
2606 tt_int_op(event, ==, EV_TIMEOUT);
2607 called += 100;
2608 end:
2609 ;
2610 }
2611
2612 static void
immediate_called_twice_cb(evutil_socket_t fd,short event,void * arg)2613 immediate_called_twice_cb(evutil_socket_t fd, short event, void *arg)
2614 {
2615 tt_int_op(event, ==, EV_TIMEOUT);
2616 called += 1000;
2617 end:
2618 ;
2619 }
2620
2621 static void
test_event_once(void * ptr)2622 test_event_once(void *ptr)
2623 {
2624 struct basic_test_data *data = ptr;
2625 struct timeval tv;
2626 int r;
2627
2628 tv.tv_sec = 0;
2629 tv.tv_usec = 50*1000;
2630 called = 0;
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);
2638 tt_int_op(r, <, 0);
2639 r = event_base_once(data->base, -1, EV_TIMEOUT,
2640 immediate_called_twice_cb, NULL, NULL);
2641 tt_int_op(r, ==, 0);
2642 tv.tv_sec = 0;
2643 tv.tv_usec = 0;
2644 r = event_base_once(data->base, -1, EV_TIMEOUT,
2645 immediate_called_twice_cb, NULL, &tv);
2646 tt_int_op(r, ==, 0);
2647
2648 if (write(data->pair[1], TEST1, strlen(TEST1)+1) < 0) {
2649 tt_fail_perror("write");
2650 }
2651
2652 shutdown(data->pair[1], SHUT_WR);
2653
2654 event_base_dispatch(data->base);
2655
2656 tt_int_op(called, ==, 2101);
2657 end:
2658 ;
2659 }
2660
2661 static void
test_event_once_never(void * ptr)2662 test_event_once_never(void *ptr)
2663 {
2664 struct basic_test_data *data = ptr;
2665 struct timeval tv;
2666
2667 /* Have one trigger in 10 seconds (don't worry, because) */
2668 tv.tv_sec = 10;
2669 tv.tv_usec = 0;
2670 called = 0;
2671 event_base_once(data->base, -1, EV_TIMEOUT,
2672 timeout_called_once_cb, NULL, &tv);
2673
2674 /* But shut down the base in 75 msec. */
2675 tv.tv_sec = 0;
2676 tv.tv_usec = 75*1000;
2677 event_base_loopexit(data->base, &tv);
2678
2679 event_base_dispatch(data->base);
2680
2681 tt_int_op(called, ==, 0);
2682 end:
2683 ;
2684 }
2685
2686 static void
test_event_pending(void * ptr)2687 test_event_pending(void *ptr)
2688 {
2689 struct basic_test_data *data = ptr;
2690 struct event *r=NULL, *w=NULL, *t=NULL;
2691 struct timeval tv, now, tv2;
2692
2693 tv.tv_sec = 0;
2694 tv.tv_usec = 500 * 1000;
2695 r = event_new(data->base, data->pair[0], EV_READ, simple_read_cb,
2696 NULL);
2697 w = event_new(data->base, data->pair[1], EV_WRITE, simple_write_cb,
2698 NULL);
2699 t = evtimer_new(data->base, timeout_cb, NULL);
2700
2701 tt_assert(r);
2702 tt_assert(w);
2703 tt_assert(t);
2704
2705 evutil_gettimeofday(&now, NULL);
2706 event_add(r, NULL);
2707 event_add(t, &tv);
2708
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));
2716
2717 tt_assert(evutil_timercmp(&tv2, &now, >));
2718
2719 test_timeval_diff_eq(&now, &tv2, 500);
2720
2721 end:
2722 if (r) {
2723 event_del(r);
2724 event_free(r);
2725 }
2726 if (w) {
2727 event_del(w);
2728 event_free(w);
2729 }
2730 if (t) {
2731 event_del(t);
2732 event_free(t);
2733 }
2734 }
2735
2736 #ifndef _WIN32
2737 /* You can't do this test on windows, since dup2 doesn't work on sockets */
2738
2739 static void
dfd_cb(evutil_socket_t fd,short e,void * data)2740 dfd_cb(evutil_socket_t fd, short e, void *data)
2741 {
2742 *(int*)data = (int)e;
2743 }
2744
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 */
2748 static void
test_dup_fd(void * arg)2749 test_dup_fd(void *arg)
2750 {
2751 struct basic_test_data *data = arg;
2752 struct event_base *base = data->base;
2753 struct event *ev1=NULL, *ev2=NULL;
2754 int fd, dfd=-1;
2755 int ev1_got, ev2_got;
2756
2757 tt_int_op(write(data->pair[0], "Hello world",
2758 strlen("Hello world")), >, 0);
2759 fd = data->pair[1];
2760
2761 dfd = dup(fd);
2762 tt_int_op(dfd, >=, 0);
2763
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);
2772
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. */
2776 close(dfd);
2777 event_del(ev2);
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);
2782
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);
2789 event_free(ev2);
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);
2796
2797 end:
2798 if (ev1)
2799 event_free(ev1);
2800 if (ev2)
2801 event_free(ev2);
2802 if (dfd >= 0)
2803 close(dfd);
2804 }
2805 #endif
2806
2807 #ifdef EVENT__DISABLE_MM_REPLACEMENT
2808 static void
test_mm_functions(void * arg)2809 test_mm_functions(void *arg)
2810 {
2811 tinytest_set_test_skipped_();
2812 }
2813 #else
2814 static int
check_dummy_mem_ok(void * mem_)2815 check_dummy_mem_ok(void *mem_)
2816 {
2817 char *mem = mem_;
2818 mem -= 16;
2819 return !memcmp(mem, "{[<guardedram>]}", 16);
2820 }
2821
2822 static void *
dummy_malloc(size_t len)2823 dummy_malloc(size_t len)
2824 {
2825 char *mem = malloc(len+16);
2826 if (mem == NULL) {
2827 fprintf(stderr, "Unable to allocate memory in dummy_malloc()\n");
2828 return NULL;
2829 }
2830 memcpy(mem, "{[<guardedram>]}", 16);
2831 return mem+16;
2832 }
2833
2834 static void *
dummy_realloc(void * mem_,size_t len)2835 dummy_realloc(void *mem_, size_t len)
2836 {
2837 char *mem = mem_;
2838 if (!mem)
2839 return dummy_malloc(len);
2840 tt_want(check_dummy_mem_ok(mem_));
2841 mem -= 16;
2842 mem = realloc(mem, len+16);
2843 return mem+16;
2844 }
2845
2846 static void
dummy_free(void * mem_)2847 dummy_free(void *mem_)
2848 {
2849 char *mem = mem_;
2850 tt_want(check_dummy_mem_ok(mem_));
2851 mem -= 16;
2852 free(mem);
2853 }
2854
2855 static void
test_mm_functions(void * arg)2856 test_mm_functions(void *arg)
2857 {
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);
2864 tt_assert(b);
2865 tt_assert(check_dummy_mem_ok(b));
2866 end:
2867 if (cfg)
2868 event_config_free(cfg);
2869 if (b)
2870 event_base_free(b);
2871 }
2872 #endif
2873
2874 static void
many_event_cb(evutil_socket_t fd,short event,void * arg)2875 many_event_cb(evutil_socket_t fd, short event, void *arg)
2876 {
2877 int *calledp = arg;
2878 *calledp += 1;
2879 }
2880
2881 static void
test_many_events(void * arg)2882 test_many_events(void *arg)
2883 {
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
2887 * functions. */
2888 #define MANY 70
2889
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];
2895 int called[MANY];
2896 int i;
2897 int loopflags = EVLOOP_NONBLOCK, evflags=0;
2898 if (one_at_a_time) {
2899 loopflags |= EVLOOP_ONCE;
2900 evflags = EV_PERSIST;
2901 }
2902
2903 memset(sock, 0xff, sizeof(sock));
2904 memset(ev, 0, sizeof(ev));
2905 memset(called, 0, sizeof(called));
2906
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);
2913 called[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);
2917 if (one_at_a_time)
2918 event_base_loop(base, EVLOOP_NONBLOCK|EVLOOP_ONCE);
2919 }
2920
2921 event_base_loop(base, loopflags);
2922
2923 for (i = 0; i < MANY; ++i) {
2924 if (one_at_a_time)
2925 tt_int_op(called[i], ==, MANY - i + 1);
2926 else
2927 tt_int_op(called[i], ==, 1);
2928 }
2929
2930 end:
2931 for (i = 0; i < MANY; ++i) {
2932 if (ev[i])
2933 event_free(ev[i]);
2934 if (sock[i] >= 0)
2935 evutil_closesocket(sock[i]);
2936 }
2937 #undef MANY
2938 }
2939
2940 static void
test_struct_event_size(void * arg)2941 test_struct_event_size(void *arg)
2942 {
2943 tt_int_op(event_get_struct_event_size(), <=, sizeof(struct event));
2944 end:
2945 ;
2946 }
2947
2948 static void
test_get_assignment(void * arg)2949 test_get_assignment(void *arg)
2950 {
2951 struct basic_test_data *data = arg;
2952 struct event_base *base = data->base;
2953 struct event *ev1 = NULL;
2954 const char *str = "foo";
2955
2956 struct event_base *b;
2957 evutil_socket_t s;
2958 short what;
2959 event_callback_fn cb;
2960 void *cb_arg;
2961
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);
2964
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);
2970
2971 /* Now make sure this doesn't crash. */
2972 event_get_assignment(ev1, NULL, NULL, NULL, NULL, NULL);
2973
2974 end:
2975 if (ev1)
2976 event_free(ev1);
2977 }
2978
2979 struct foreach_helper {
2980 int count;
2981 const struct event *ev;
2982 };
2983
2984 static int
foreach_count_cb(const struct event_base * base,const struct event * ev,void * arg)2985 foreach_count_cb(const struct event_base *base, const struct event *ev, void *arg)
2986 {
2987 struct foreach_helper *h = event_get_callback_arg(ev);
2988 struct timeval *tv = arg;
2989 if (event_get_callback(ev) != timeout_cb)
2990 return 0;
2991 tt_ptr_op(event_get_base(ev), ==, base);
2992 tt_int_op(tv->tv_sec, ==, 10);
2993 h->ev = ev;
2994 h->count++;
2995 return 0;
2996 end:
2997 return -1;
2998 }
2999
3000 static int
foreach_find_cb(const struct event_base * base,const struct event * ev,void * arg)3001 foreach_find_cb(const struct event_base *base, const struct event *ev, void *arg)
3002 {
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)
3006 return 0;
3007 if (h->count == 99) {
3008 *ev_out = ev;
3009 return 101;
3010 }
3011 return 0;
3012 }
3013
3014 static void
test_event_foreach(void * arg)3015 test_event_foreach(void *arg)
3016 {
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];
3021 int i;
3022 struct timeval ten_sec = {10,0};
3023 const struct event *ev_found = NULL;
3024
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]);
3029 }
3030
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));
3033
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]. */
3040
3041 tt_int_op(0, ==, event_base_foreach_event(base, foreach_count_cb,
3042 &ten_sec));
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);
3051
3052 visited[2].count = 99;
3053 tt_int_op(101, ==, event_base_foreach_event(base, foreach_find_cb,
3054 &ev_found));
3055 tt_ptr_op(ev_found, ==, ev[2]);
3056
3057 end:
3058 for (i=0; i<5; ++i) {
3059 event_free(ev[i]);
3060 }
3061 }
3062
3063 static struct event_base *cached_time_base = NULL;
3064 static int cached_time_reset = 0;
3065 static int cached_time_sleep = 0;
3066 static void
cache_time_cb(evutil_socket_t fd,short what,void * arg)3067 cache_time_cb(evutil_socket_t fd, short what, void *arg)
3068 {
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);
3074 }
3075 if (cached_time_reset) {
3076 event_base_update_cache_time(cached_time_base);
3077 }
3078 end:
3079 ;
3080 }
3081
3082 static void
test_gettimeofday_cached(void * arg)3083 test_gettimeofday_cached(void *arg)
3084 {
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;
3091
3092 cfg = event_config_new();
3093 if (cached_time_disable) {
3094 event_config_set_flag(cfg, EVENT_BASE_FLAG_NO_CACHE_TIME);
3095 }
3096 cached_time_base = base = event_base_new_with_config(cfg);
3097 tt_assert(base);
3098
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);
3105
3106 cached_time_reset = strstr(data->setup_data, "reset") != NULL;
3107 cached_time_sleep = strstr(data->setup_data, "sleep") != NULL;
3108
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);
3112
3113 event_active(ev1, EV_TIMEOUT, 1);
3114 event_active(ev2, EV_TIMEOUT, 1);
3115 event_active(ev3, EV_TIMEOUT, 1);
3116
3117 event_base_dispatch(base);
3118
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, ==));
3128 }
3129
3130 end:
3131 if (ev1)
3132 event_free(ev1);
3133 if (ev2)
3134 event_free(ev2);
3135 if (ev3)
3136 event_free(ev3);
3137 if (base)
3138 event_base_free(base);
3139 if (cfg)
3140 event_config_free(cfg);
3141 }
3142
3143 static void
tabf_cb(evutil_socket_t fd,short what,void * arg)3144 tabf_cb(evutil_socket_t fd, short what, void *arg)
3145 {
3146 int *ptr = arg;
3147 *ptr = what;
3148 *ptr += 0x10000;
3149 }
3150
3151 static void
test_active_by_fd(void * arg)3152 test_active_by_fd(void *arg)
3153 {
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;
3157 int e1,e2,e3,e4;
3158 #ifndef _WIN32
3159 struct event *evsig = NULL;
3160 int es;
3161 #endif
3162 struct timeval tenmin = { 600, 0 };
3163
3164 /* Ensure no crash on nonexistent FD. */
3165 event_base_active_by_fd(base, 1000, EV_READ);
3166
3167 /* Ensure no crash on bogus FD. */
3168 event_base_active_by_fd(base, -1, EV_READ);
3169
3170 /* Ensure no crash on nonexistent/bogus signal. */
3171 event_base_active_by_signal(base, 1000);
3172 event_base_active_by_signal(base, -1);
3173
3174 event_base_assert_ok_(base);
3175
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);
3181 tt_assert(ev1);
3182 tt_assert(ev2);
3183 tt_assert(ev3);
3184 tt_assert(ev4);
3185 #ifndef _WIN32
3186 evsig = event_new(base, SIGHUP, EV_SIGNAL, tabf_cb, &es);
3187 tt_assert(evsig);
3188 event_add(evsig, &tenmin);
3189 #endif
3190
3191 event_add(ev1, &tenmin);
3192 event_add(ev2, NULL);
3193 event_add(ev3, NULL);
3194 event_add(ev4, &tenmin);
3195
3196
3197 event_base_assert_ok_(base);
3198
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);
3202 #ifndef _WIN32
3203 event_base_active_by_signal(base, SIGHUP);
3204 #endif
3205
3206 event_base_assert_ok_(base);
3207
3208 event_base_loop(base, EVLOOP_ONCE);
3209
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);
3215 #ifndef _WIN32
3216 tt_int_op(es, ==, EV_SIGNAL | 0x10000);
3217 #endif
3218
3219 end:
3220 if (ev1)
3221 event_free(ev1);
3222 if (ev2)
3223 event_free(ev2);
3224 if (ev3)
3225 event_free(ev3);
3226 if (ev4)
3227 event_free(ev4);
3228 #ifndef _WIN32
3229 if (evsig)
3230 event_free(evsig);
3231 #endif
3232 }
3233
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 },
3240
3241 BASIC(event_base_new, TT_FORK|TT_NEED_SOCKETPAIR),
3242 BASIC(free_active_base, TT_FORK|TT_NEED_SOCKETPAIR),
3243
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),
3249
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),
3254
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 },
3264
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,
3270 NULL },
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,
3284 NULL },
3285 #ifndef _WIN32
3286 { "dup_fd", test_dup_fd, TT_ISOLATED, &basic_setup, NULL },
3287 #endif
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 },
3291
3292 { "struct_event_size", test_struct_event_size, 0, NULL, NULL },
3293 BASIC(get_assignment, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR),
3294
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" },
3301
3302 BASIC(active_by_fd, TT_FORK|TT_NEED_BASE|TT_NEED_SOCKETPAIR),
3303
3304 #ifndef _WIN32
3305 LEGACY(fork, TT_ISOLATED),
3306 #endif
3307 END_OF_TESTCASES
3308 };
3309
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 },
3315
3316 END_OF_TESTCASES
3317 };
3318
3319 struct testcase_t signal_testcases[] = {
3320 #ifndef _WIN32
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),
3331 #endif
3332 END_OF_TESTCASES
3333 };
3334
3335