![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to regress.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent / test|
Return to regress.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent / test |
1.1 misho 1: /*
2: * Copyright (c) 2003, 2004 Niels Provos <provos@citi.umich.edu>
3: * All rights reserved.
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:
28: #ifdef WIN32
29: #include <winsock2.h>
30: #include <windows.h>
31: #endif
32:
33: #ifdef HAVE_CONFIG_H
34: #include "config.h"
35: #endif
36:
37: #include <sys/types.h>
38: #include <sys/stat.h>
39: #ifdef HAVE_SYS_TIME_H
40: #include <sys/time.h>
41: #endif
42: #include <sys/queue.h>
43: #ifndef WIN32
44: #include <sys/socket.h>
45: #include <sys/wait.h>
46: #include <signal.h>
47: #include <unistd.h>
48: #include <netdb.h>
49: #endif
50: #include <assert.h>
51: #include <fcntl.h>
52: #include <signal.h>
53: #include <stdlib.h>
54: #include <stdio.h>
55: #include <string.h>
56: #include <errno.h>
57:
58: #include "event.h"
59: #include "evutil.h"
60: #include "event-internal.h"
61: #include "log.h"
62:
63: #include "regress.h"
64: #ifndef WIN32
65: #include "regress.gen.h"
66: #endif
67:
68: int pair[2];
69: int test_ok;
70: static int called;
71: static char wbuf[4096];
72: static char rbuf[4096];
73: static int woff;
74: static int roff;
75: static int usepersist;
76: static struct timeval tset;
77: static struct timeval tcalled;
78: static struct event_base *global_base;
79:
80: #define TEST1 "this is a test"
81: #define SECONDS 1
82:
83: #ifndef SHUT_WR
84: #define SHUT_WR 1
85: #endif
86:
87: #ifdef WIN32
88: #define write(fd,buf,len) send((fd),(buf),(len),0)
89: #define read(fd,buf,len) recv((fd),(buf),(len),0)
90: #endif
91:
92: static void
93: simple_read_cb(int fd, short event, void *arg)
94: {
95: char buf[256];
96: int len;
97:
98: if (arg == NULL)
99: return;
100:
101: len = read(fd, buf, sizeof(buf));
102:
103: if (len) {
104: if (!called) {
105: if (event_add(arg, NULL) == -1)
106: exit(1);
107: }
108: } else if (called == 1)
109: test_ok = 1;
110:
111: called++;
112: }
113:
114: static void
115: simple_write_cb(int fd, short event, void *arg)
116: {
117: int len;
118:
119: if (arg == NULL)
120: return;
121:
122: len = write(fd, TEST1, strlen(TEST1) + 1);
123: if (len == -1)
124: test_ok = 0;
125: else
126: test_ok = 1;
127: }
128:
129: static void
130: multiple_write_cb(int fd, short event, void *arg)
131: {
132: struct event *ev = arg;
133: int len;
134:
135: len = 128;
136: if (woff + len >= sizeof(wbuf))
137: len = sizeof(wbuf) - woff;
138:
139: len = write(fd, wbuf + woff, len);
140: if (len == -1) {
141: fprintf(stderr, "%s: write\n", __func__);
142: if (usepersist)
143: event_del(ev);
144: return;
145: }
146:
147: woff += len;
148:
149: if (woff >= sizeof(wbuf)) {
150: shutdown(fd, SHUT_WR);
151: if (usepersist)
152: event_del(ev);
153: return;
154: }
155:
156: if (!usepersist) {
157: if (event_add(ev, NULL) == -1)
158: exit(1);
159: }
160: }
161:
162: static void
163: multiple_read_cb(int fd, short event, void *arg)
164: {
165: struct event *ev = arg;
166: int len;
167:
168: len = read(fd, rbuf + roff, sizeof(rbuf) - roff);
169: if (len == -1)
170: fprintf(stderr, "%s: read\n", __func__);
171: if (len <= 0) {
172: if (usepersist)
173: event_del(ev);
174: return;
175: }
176:
177: roff += len;
178: if (!usepersist) {
179: if (event_add(ev, NULL) == -1)
180: exit(1);
181: }
182: }
183:
184: static void
185: timeout_cb(int fd, short event, void *arg)
186: {
187: struct timeval tv;
188: int diff;
189:
190: evutil_gettimeofday(&tcalled, NULL);
191: if (evutil_timercmp(&tcalled, &tset, >))
192: evutil_timersub(&tcalled, &tset, &tv);
193: else
194: evutil_timersub(&tset, &tcalled, &tv);
195:
196: diff = tv.tv_sec*1000 + tv.tv_usec/1000 - SECONDS * 1000;
197: if (diff < 0)
198: diff = -diff;
199:
200: if (diff < 100)
201: test_ok = 1;
202: }
203:
204: #ifndef WIN32
205: static void
206: signal_cb_sa(int sig)
207: {
208: test_ok = 2;
209: }
210:
211: static void
212: signal_cb(int fd, short event, void *arg)
213: {
214: struct event *ev = arg;
215:
216: signal_del(ev);
217: test_ok = 1;
218: }
219: #endif
220:
221: struct both {
222: struct event ev;
223: int nread;
224: };
225:
226: static void
227: combined_read_cb(int fd, short event, void *arg)
228: {
229: struct both *both = arg;
230: char buf[128];
231: int len;
232:
233: len = read(fd, buf, sizeof(buf));
234: if (len == -1)
235: fprintf(stderr, "%s: read\n", __func__);
236: if (len <= 0)
237: return;
238:
239: both->nread += len;
240: if (event_add(&both->ev, NULL) == -1)
241: exit(1);
242: }
243:
244: static void
245: combined_write_cb(int fd, short event, void *arg)
246: {
247: struct both *both = arg;
248: char buf[128];
249: int len;
250:
251: len = sizeof(buf);
252: if (len > both->nread)
253: len = both->nread;
254:
255: len = write(fd, buf, len);
256: if (len == -1)
257: fprintf(stderr, "%s: write\n", __func__);
258: if (len <= 0) {
259: shutdown(fd, SHUT_WR);
260: return;
261: }
262:
263: both->nread -= len;
264: if (event_add(&both->ev, NULL) == -1)
265: exit(1);
266: }
267:
268: /* Test infrastructure */
269:
270: static int
271: setup_test(const char *name)
272: {
273:
274: fprintf(stdout, "%s", name);
275:
276: if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {
277: fprintf(stderr, "%s: socketpair\n", __func__);
278: exit(1);
279: }
280:
281: #ifdef HAVE_FCNTL
282: if (fcntl(pair[0], F_SETFL, O_NONBLOCK) == -1)
283: fprintf(stderr, "fcntl(O_NONBLOCK)");
284:
285: if (fcntl(pair[1], F_SETFL, O_NONBLOCK) == -1)
286: fprintf(stderr, "fcntl(O_NONBLOCK)");
287: #endif
288:
289: test_ok = 0;
290: called = 0;
291: return (0);
292: }
293:
294: static int
295: cleanup_test(void)
296: {
297: #ifndef WIN32
298: close(pair[0]);
299: close(pair[1]);
300: #else
301: CloseHandle((HANDLE)pair[0]);
302: CloseHandle((HANDLE)pair[1]);
303: #endif
304: if (test_ok)
305: fprintf(stdout, "OK\n");
306: else {
307: fprintf(stdout, "FAILED\n");
308: exit(1);
309: }
310: test_ok = 0;
311: return (0);
312: }
313:
314: static void
315: test_registerfds(void)
316: {
317: int i, j;
318: int pair[2];
319: struct event read_evs[512];
320: struct event write_evs[512];
321:
322: struct event_base *base = event_base_new();
323:
324: fprintf(stdout, "Testing register fds: ");
325:
326: for (i = 0; i < 512; ++i) {
327: if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {
328: /* run up to the limit of file descriptors */
329: break;
330: }
331: event_set(&read_evs[i], pair[0],
332: EV_READ|EV_PERSIST, simple_read_cb, NULL);
333: event_base_set(base, &read_evs[i]);
334: event_add(&read_evs[i], NULL);
335: event_set(&write_evs[i], pair[1],
336: EV_WRITE|EV_PERSIST, simple_write_cb, NULL);
337: event_base_set(base, &write_evs[i]);
338: event_add(&write_evs[i], NULL);
339:
340: /* just loop once */
341: event_base_loop(base, EVLOOP_ONCE);
342: }
343:
344: /* now delete everything */
345: for (j = 0; j < i; ++j) {
346: event_del(&read_evs[j]);
347: event_del(&write_evs[j]);
348: #ifndef WIN32
349: close(read_evs[j].ev_fd);
350: close(write_evs[j].ev_fd);
351: #else
352: CloseHandle((HANDLE)read_evs[j].ev_fd);
353: CloseHandle((HANDLE)write_evs[j].ev_fd);
354: #endif
355:
356: /* just loop once */
357: event_base_loop(base, EVLOOP_ONCE);
358: }
359:
360: event_base_free(base);
361:
362: fprintf(stdout, "OK\n");
363: }
364:
365: static void
366: test_simpleread(void)
367: {
368: struct event ev;
369:
370: /* Very simple read test */
371: setup_test("Simple read: ");
372:
373: write(pair[0], TEST1, strlen(TEST1)+1);
374: shutdown(pair[0], SHUT_WR);
375:
376: event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
377: if (event_add(&ev, NULL) == -1)
378: exit(1);
379: event_dispatch();
380:
381: cleanup_test();
382: }
383:
384: static void
385: test_simplewrite(void)
386: {
387: struct event ev;
388:
389: /* Very simple write test */
390: setup_test("Simple write: ");
391:
392: event_set(&ev, pair[0], EV_WRITE, simple_write_cb, &ev);
393: if (event_add(&ev, NULL) == -1)
394: exit(1);
395: event_dispatch();
396:
397: cleanup_test();
398: }
399:
400: static void
401: test_multiple(void)
402: {
403: struct event ev, ev2;
404: int i;
405:
406: /* Multiple read and write test */
407: setup_test("Multiple read/write: ");
408: memset(rbuf, 0, sizeof(rbuf));
409: for (i = 0; i < sizeof(wbuf); i++)
410: wbuf[i] = i;
411:
412: roff = woff = 0;
413: usepersist = 0;
414:
415: event_set(&ev, pair[0], EV_WRITE, multiple_write_cb, &ev);
416: if (event_add(&ev, NULL) == -1)
417: exit(1);
418: event_set(&ev2, pair[1], EV_READ, multiple_read_cb, &ev2);
419: if (event_add(&ev2, NULL) == -1)
420: exit(1);
421: event_dispatch();
422:
423: if (roff == woff)
424: test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
425:
426: cleanup_test();
427: }
428:
429: static void
430: test_persistent(void)
431: {
432: struct event ev, ev2;
433: int i;
434:
435: /* Multiple read and write test with persist */
436: setup_test("Persist read/write: ");
437: memset(rbuf, 0, sizeof(rbuf));
438: for (i = 0; i < sizeof(wbuf); i++)
439: wbuf[i] = i;
440:
441: roff = woff = 0;
442: usepersist = 1;
443:
444: event_set(&ev, pair[0], EV_WRITE|EV_PERSIST, multiple_write_cb, &ev);
445: if (event_add(&ev, NULL) == -1)
446: exit(1);
447: event_set(&ev2, pair[1], EV_READ|EV_PERSIST, multiple_read_cb, &ev2);
448: if (event_add(&ev2, NULL) == -1)
449: exit(1);
450: event_dispatch();
451:
452: if (roff == woff)
453: test_ok = memcmp(rbuf, wbuf, sizeof(wbuf)) == 0;
454:
455: cleanup_test();
456: }
457:
458: static void
459: test_combined(void)
460: {
461: struct both r1, r2, w1, w2;
462:
463: setup_test("Combined read/write: ");
464: memset(&r1, 0, sizeof(r1));
465: memset(&r2, 0, sizeof(r2));
466: memset(&w1, 0, sizeof(w1));
467: memset(&w2, 0, sizeof(w2));
468:
469: w1.nread = 4096;
470: w2.nread = 8192;
471:
472: event_set(&r1.ev, pair[0], EV_READ, combined_read_cb, &r1);
473: event_set(&w1.ev, pair[0], EV_WRITE, combined_write_cb, &w1);
474: event_set(&r2.ev, pair[1], EV_READ, combined_read_cb, &r2);
475: event_set(&w2.ev, pair[1], EV_WRITE, combined_write_cb, &w2);
476: if (event_add(&r1.ev, NULL) == -1)
477: exit(1);
478: if (event_add(&w1.ev, NULL))
479: exit(1);
480: if (event_add(&r2.ev, NULL))
481: exit(1);
482: if (event_add(&w2.ev, NULL))
483: exit(1);
484:
485: event_dispatch();
486:
487: if (r1.nread == 8192 && r2.nread == 4096)
488: test_ok = 1;
489:
490: cleanup_test();
491: }
492:
493: static void
494: test_simpletimeout(void)
495: {
496: struct timeval tv;
497: struct event ev;
498:
499: setup_test("Simple timeout: ");
500:
501: tv.tv_usec = 0;
502: tv.tv_sec = SECONDS;
503: evtimer_set(&ev, timeout_cb, NULL);
504: evtimer_add(&ev, &tv);
505:
506: evutil_gettimeofday(&tset, NULL);
507: event_dispatch();
508:
509: cleanup_test();
510: }
511:
512: #ifndef WIN32
513: extern struct event_base *current_base;
514:
515: static void
516: child_signal_cb(int fd, short event, void *arg)
517: {
518: struct timeval tv;
519: int *pint = arg;
520:
521: *pint = 1;
522:
523: tv.tv_usec = 500000;
524: tv.tv_sec = 0;
525: event_loopexit(&tv);
526: }
527:
528: static void
529: test_fork(void)
530: {
531: int status, got_sigchld = 0;
532: struct event ev, sig_ev;
533: pid_t pid;
534:
535: setup_test("After fork: ");
536:
537: write(pair[0], TEST1, strlen(TEST1)+1);
538:
539: event_set(&ev, pair[1], EV_READ, simple_read_cb, &ev);
540: if (event_add(&ev, NULL) == -1)
541: exit(1);
542:
543: signal_set(&sig_ev, SIGCHLD, child_signal_cb, &got_sigchld);
544: signal_add(&sig_ev, NULL);
545:
546: if ((pid = fork()) == 0) {
547: /* in the child */
548: if (event_reinit(current_base) == -1) {
549: fprintf(stderr, "FAILED (reinit)\n");
550: exit(1);
551: }
552:
553: signal_del(&sig_ev);
554:
555: called = 0;
556:
557: event_dispatch();
558:
559: /* we do not send an EOF; simple_read_cb requires an EOF
560: * to set test_ok. we just verify that the callback was
561: * called. */
562: exit(test_ok != 0 || called != 2 ? -2 : 76);
563: }
564:
565: /* wait for the child to read the data */
566: sleep(1);
567:
568: write(pair[0], TEST1, strlen(TEST1)+1);
569:
570: if (waitpid(pid, &status, 0) == -1) {
571: fprintf(stderr, "FAILED (fork)\n");
572: exit(1);
573: }
574:
575: if (WEXITSTATUS(status) != 76) {
576: fprintf(stderr, "FAILED (exit): %d\n", WEXITSTATUS(status));
577: exit(1);
578: }
579:
580: /* test that the current event loop still works */
581: write(pair[0], TEST1, strlen(TEST1)+1);
582: shutdown(pair[0], SHUT_WR);
583:
584: event_dispatch();
585:
586: if (!got_sigchld) {
587: fprintf(stdout, "FAILED (sigchld)\n");
588: exit(1);
589: }
590:
591: signal_del(&sig_ev);
592:
593: cleanup_test();
594: }
595:
596: static void
597: test_simplesignal(void)
598: {
599: struct event ev;
600: struct itimerval itv;
601:
602: setup_test("Simple signal: ");
603: signal_set(&ev, SIGALRM, signal_cb, &ev);
604: signal_add(&ev, NULL);
605: /* find bugs in which operations are re-ordered */
606: signal_del(&ev);
607: signal_add(&ev, NULL);
608:
609: memset(&itv, 0, sizeof(itv));
610: itv.it_value.tv_sec = 1;
611: if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
612: goto skip_simplesignal;
613:
614: event_dispatch();
615: skip_simplesignal:
616: if (signal_del(&ev) == -1)
617: test_ok = 0;
618:
619: cleanup_test();
620: }
621:
622: static void
623: test_multiplesignal(void)
624: {
625: struct event ev_one, ev_two;
626: struct itimerval itv;
627:
628: setup_test("Multiple signal: ");
629:
630: signal_set(&ev_one, SIGALRM, signal_cb, &ev_one);
631: signal_add(&ev_one, NULL);
632:
633: signal_set(&ev_two, SIGALRM, signal_cb, &ev_two);
634: signal_add(&ev_two, NULL);
635:
636: memset(&itv, 0, sizeof(itv));
637: itv.it_value.tv_sec = 1;
638: if (setitimer(ITIMER_REAL, &itv, NULL) == -1)
639: goto skip_simplesignal;
640:
641: event_dispatch();
642:
643: skip_simplesignal:
644: if (signal_del(&ev_one) == -1)
645: test_ok = 0;
646: if (signal_del(&ev_two) == -1)
647: test_ok = 0;
648:
649: cleanup_test();
650: }
651:
652: static void
653: test_immediatesignal(void)
654: {
655: struct event ev;
656:
657: test_ok = 0;
658: printf("Immediate signal: ");
659: signal_set(&ev, SIGUSR1, signal_cb, &ev);
660: signal_add(&ev, NULL);
661: raise(SIGUSR1);
662: event_loop(EVLOOP_NONBLOCK);
663: signal_del(&ev);
664: cleanup_test();
665: }
666:
667: static void
668: test_signal_dealloc(void)
669: {
670: /* make sure that signal_event is event_del'ed and pipe closed */
671: struct event ev;
672: struct event_base *base = event_init();
673: printf("Signal dealloc: ");
674: signal_set(&ev, SIGUSR1, signal_cb, &ev);
675: signal_add(&ev, NULL);
676: signal_del(&ev);
677: event_base_free(base);
678: /* If we got here without asserting, we're fine. */
679: test_ok = 1;
680: cleanup_test();
681: }
682:
683: static void
684: test_signal_pipeloss(void)
685: {
686: /* make sure that the base1 pipe is closed correctly. */
687: struct event_base *base1, *base2;
688: int pipe1;
689: test_ok = 0;
690: printf("Signal pipeloss: ");
691: base1 = event_init();
692: pipe1 = base1->sig.ev_signal_pair[0];
693: base2 = event_init();
694: event_base_free(base2);
695: event_base_free(base1);
696: if (close(pipe1) != -1 || errno!=EBADF) {
697: /* fd must be closed, so second close gives -1, EBADF */
698: printf("signal pipe not closed. ");
699: test_ok = 0;
700: } else {
701: test_ok = 1;
702: }
703: cleanup_test();
704: }
705:
706: /*
707: * make two bases to catch signals, use both of them. this only works
708: * for event mechanisms that use our signal pipe trick. kqueue handles
709: * signals internally, and all interested kqueues get all the signals.
710: */
711: static void
712: test_signal_switchbase(void)
713: {
714: struct event ev1, ev2;
715: struct event_base *base1, *base2;
716: int is_kqueue;
717: test_ok = 0;
718: printf("Signal switchbase: ");
719: base1 = event_init();
720: base2 = event_init();
721: is_kqueue = !strcmp(event_get_method(),"kqueue");
722: signal_set(&ev1, SIGUSR1, signal_cb, &ev1);
723: signal_set(&ev2, SIGUSR1, signal_cb, &ev2);
724: if (event_base_set(base1, &ev1) ||
725: event_base_set(base2, &ev2) ||
726: event_add(&ev1, NULL) ||
727: event_add(&ev2, NULL)) {
728: fprintf(stderr, "%s: cannot set base, add\n", __func__);
729: exit(1);
730: }
731:
732: test_ok = 0;
733: /* can handle signal before loop is called */
734: raise(SIGUSR1);
735: event_base_loop(base2, EVLOOP_NONBLOCK);
736: if (is_kqueue) {
737: if (!test_ok)
738: goto done;
739: test_ok = 0;
740: }
741: event_base_loop(base1, EVLOOP_NONBLOCK);
742: if (test_ok && !is_kqueue) {
743: test_ok = 0;
744:
745: /* set base1 to handle signals */
746: event_base_loop(base1, EVLOOP_NONBLOCK);
747: raise(SIGUSR1);
748: event_base_loop(base1, EVLOOP_NONBLOCK);
749: event_base_loop(base2, EVLOOP_NONBLOCK);
750: }
751: done:
752: event_base_free(base1);
753: event_base_free(base2);
754: cleanup_test();
755: }
756:
757: /*
758: * assert that a signal event removed from the event queue really is
759: * removed - with no possibility of it's parent handler being fired.
760: */
761: static void
762: test_signal_assert(void)
763: {
764: struct event ev;
765: struct event_base *base = event_init();
766: test_ok = 0;
767: printf("Signal handler assert: ");
768: /* use SIGCONT so we don't kill ourselves when we signal to nowhere */
769: signal_set(&ev, SIGCONT, signal_cb, &ev);
770: signal_add(&ev, NULL);
771: /*
772: * if signal_del() fails to reset the handler, it's current handler
773: * will still point to evsignal_handler().
774: */
775: signal_del(&ev);
776:
777: raise(SIGCONT);
778: /* only way to verify we were in evsignal_handler() */
779: if (base->sig.evsignal_caught)
780: test_ok = 0;
781: else
782: test_ok = 1;
783:
784: event_base_free(base);
785: cleanup_test();
786: return;
787: }
788:
789: /*
790: * assert that we restore our previous signal handler properly.
791: */
792: static void
793: test_signal_restore(void)
794: {
795: struct event ev;
796: struct event_base *base = event_init();
797: #ifdef HAVE_SIGACTION
798: struct sigaction sa;
799: #endif
800:
801: test_ok = 0;
802: printf("Signal handler restore: ");
803: #ifdef HAVE_SIGACTION
804: sa.sa_handler = signal_cb_sa;
805: sa.sa_flags = 0x0;
806: sigemptyset(&sa.sa_mask);
807: if (sigaction(SIGUSR1, &sa, NULL) == -1)
808: goto out;
809: #else
810: if (signal(SIGUSR1, signal_cb_sa) == SIG_ERR)
811: goto out;
812: #endif
813: signal_set(&ev, SIGUSR1, signal_cb, &ev);
814: signal_add(&ev, NULL);
815: signal_del(&ev);
816:
817: raise(SIGUSR1);
818: /* 1 == signal_cb, 2 == signal_cb_sa, we want our previous handler */
819: if (test_ok != 2)
820: test_ok = 0;
821: out:
822: event_base_free(base);
823: cleanup_test();
824: return;
825: }
826:
827: static void
828: signal_cb_swp(int sig, short event, void *arg)
829: {
830: called++;
831: if (called < 5)
832: raise(sig);
833: else
834: event_loopexit(NULL);
835: }
836: static void
837: timeout_cb_swp(int fd, short event, void *arg)
838: {
839: if (called == -1) {
840: struct timeval tv = {5, 0};
841:
842: called = 0;
843: evtimer_add((struct event *)arg, &tv);
844: raise(SIGUSR1);
845: return;
846: }
847: test_ok = 0;
848: event_loopexit(NULL);
849: }
850:
851: static void
852: test_signal_while_processing(void)
853: {
854: struct event_base *base = event_init();
855: struct event ev, ev_timer;
856: struct timeval tv = {0, 0};
857:
858: setup_test("Receiving a signal while processing other signal: ");
859:
860: called = -1;
861: test_ok = 1;
862: signal_set(&ev, SIGUSR1, signal_cb_swp, NULL);
863: signal_add(&ev, NULL);
864: evtimer_set(&ev_timer, timeout_cb_swp, &ev_timer);
865: evtimer_add(&ev_timer, &tv);
866: event_dispatch();
867:
868: event_base_free(base);
869: cleanup_test();
870: return;
871: }
872: #endif
873:
874: static void
875: test_free_active_base(void)
876: {
877: struct event_base *base1;
878: struct event ev1;
879: setup_test("Free active base: ");
880: base1 = event_init();
881: event_set(&ev1, pair[1], EV_READ, simple_read_cb, &ev1);
882: event_base_set(base1, &ev1);
883: event_add(&ev1, NULL);
884: /* event_del(&ev1); */
885: event_base_free(base1);
886: test_ok = 1;
887: cleanup_test();
888: }
889:
890: static void
891: test_event_base_new(void)
892: {
893: struct event_base *base;
894: struct event ev1;
895: setup_test("Event base new: ");
896:
897: write(pair[0], TEST1, strlen(TEST1)+1);
898: shutdown(pair[0], SHUT_WR);
899:
900: base = event_base_new();
901: event_set(&ev1, pair[1], EV_READ, simple_read_cb, &ev1);
902: event_base_set(base, &ev1);
903: event_add(&ev1, NULL);
904:
905: event_base_dispatch(base);
906:
907: event_base_free(base);
908: test_ok = 1;
909: cleanup_test();
910: }
911:
912: static void
913: test_loopexit(void)
914: {
915: struct timeval tv, tv_start, tv_end;
916: struct event ev;
917:
918: setup_test("Loop exit: ");
919:
920: tv.tv_usec = 0;
921: tv.tv_sec = 60*60*24;
922: evtimer_set(&ev, timeout_cb, NULL);
923: evtimer_add(&ev, &tv);
924:
925: tv.tv_usec = 0;
926: tv.tv_sec = 1;
927: event_loopexit(&tv);
928:
929: evutil_gettimeofday(&tv_start, NULL);
930: event_dispatch();
931: evutil_gettimeofday(&tv_end, NULL);
932: evutil_timersub(&tv_end, &tv_start, &tv_end);
933:
934: evtimer_del(&ev);
935:
936: if (tv.tv_sec < 2)
937: test_ok = 1;
938:
939: cleanup_test();
940: }
941:
942: static void
943: test_loopexit_multiple(void)
944: {
945: struct timeval tv;
946: struct event_base *base;
947:
948: setup_test("Loop Multiple exit: ");
949:
950: base = event_base_new();
951:
952: tv.tv_usec = 0;
953: tv.tv_sec = 1;
954: event_base_loopexit(base, &tv);
955:
956: tv.tv_usec = 0;
957: tv.tv_sec = 2;
958: event_base_loopexit(base, &tv);
959:
960: event_base_dispatch(base);
961:
962: event_base_free(base);
963:
964: test_ok = 1;
965:
966: cleanup_test();
967: }
968:
969: static void
970: break_cb(int fd, short events, void *arg)
971: {
972: test_ok = 1;
973: event_loopbreak();
974: }
975:
976: static void
977: fail_cb(int fd, short events, void *arg)
978: {
979: test_ok = 0;
980: }
981:
982: static void
983: test_loopbreak(void)
984: {
985: struct event ev1, ev2;
986: struct timeval tv;
987:
988: setup_test("Loop break: ");
989:
990: tv.tv_sec = 0;
991: tv.tv_usec = 0;
992: evtimer_set(&ev1, break_cb, NULL);
993: evtimer_add(&ev1, &tv);
994: evtimer_set(&ev2, fail_cb, NULL);
995: evtimer_add(&ev2, &tv);
996:
997: event_dispatch();
998:
999: evtimer_del(&ev1);
1000: evtimer_del(&ev2);
1001:
1002: cleanup_test();
1003: }
1004:
1005: static void
1006: test_evbuffer(void) {
1007:
1008: struct evbuffer *evb = evbuffer_new();
1009: setup_test("Testing Evbuffer: ");
1010:
1011: evbuffer_add_printf(evb, "%s/%d", "hello", 1);
1012:
1013: if (EVBUFFER_LENGTH(evb) == 7 &&
1014: strcmp((char*)EVBUFFER_DATA(evb), "hello/1") == 0)
1015: test_ok = 1;
1016:
1017: evbuffer_free(evb);
1018:
1019: cleanup_test();
1020: }
1021:
1022: static void
1023: test_evbuffer_readln(void)
1024: {
1025: struct evbuffer *evb = evbuffer_new();
1026: struct evbuffer *evb_tmp = evbuffer_new();
1027: const char *s;
1028: char *cp = NULL;
1029: size_t sz;
1030:
1031: #define tt_line_eq(content) \
1032: if (!cp || sz != strlen(content) || strcmp(cp, content)) { \
1033: fprintf(stdout, "FAILED\n"); \
1034: exit(1); \
1035: }
1036: #define tt_assert(expression) \
1037: if (!(expression)) { \
1038: fprintf(stdout, "FAILED\n"); \
1039: exit(1); \
1040: } \
1041:
1042: /* Test EOL_ANY. */
1043: fprintf(stdout, "Testing evbuffer_readln EOL_ANY: ");
1044:
1045: s = "complex silly newline\r\n\n\r\n\n\rmore\0\n";
1046: evbuffer_add(evb, s, strlen(s)+2);
1047: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
1048: tt_line_eq("complex silly newline");
1049: free(cp);
1050: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
1051: if (!cp || sz != 5 || memcmp(cp, "more\0\0", 6)) {
1052: fprintf(stdout, "FAILED\n");
1053: exit(1);
1054: }
1055: if (evb->totallen == 0) {
1056: fprintf(stdout, "FAILED\n");
1057: exit(1);
1058: }
1059: s = "\nno newline";
1060: evbuffer_add(evb, s, strlen(s));
1061: free(cp);
1062: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
1063: tt_line_eq("");
1064: free(cp);
1065: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
1066: tt_assert(!cp);
1067: evbuffer_drain(evb, EVBUFFER_LENGTH(evb));
1068: tt_assert(EVBUFFER_LENGTH(evb) == 0);
1069:
1070: fprintf(stdout, "OK\n");
1071:
1072: /* Test EOL_CRLF */
1073: fprintf(stdout, "Testing evbuffer_readln EOL_CRLF: ");
1074:
1075: s = "Line with\rin the middle\nLine with good crlf\r\n\nfinal\n";
1076: evbuffer_add(evb, s, strlen(s));
1077: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
1078: tt_line_eq("Line with\rin the middle");
1079: free(cp);
1080:
1081: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
1082: tt_line_eq("Line with good crlf");
1083: free(cp);
1084:
1085: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
1086: tt_line_eq("");
1087: free(cp);
1088:
1089: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
1090: tt_line_eq("final");
1091: s = "x";
1092: evbuffer_add(evb, s, 1);
1093: free(cp);
1094: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
1095: tt_assert(!cp);
1096:
1097: fprintf(stdout, "OK\n");
1098:
1099: /* Test CRLF_STRICT */
1100: fprintf(stdout, "Testing evbuffer_readln CRLF_STRICT: ");
1101:
1102: s = " and a bad crlf\nand a good one\r\n\r\nMore\r";
1103: evbuffer_add(evb, s, strlen(s));
1104: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1105: tt_line_eq("x and a bad crlf\nand a good one");
1106: free(cp);
1107:
1108: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1109: tt_line_eq("");
1110: free(cp);
1111:
1112: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1113: tt_assert(!cp);
1114: evbuffer_add(evb, "\n", 1);
1115:
1116: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1117: tt_line_eq("More");
1118: free(cp);
1119: tt_assert(EVBUFFER_LENGTH(evb) == 0);
1120:
1121: s = "An internal CR\r is not an eol\r\nNor is a lack of one";
1122: evbuffer_add(evb, s, strlen(s));
1123: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1124: tt_line_eq("An internal CR\r is not an eol");
1125: free(cp);
1126:
1127: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1128: tt_assert(!cp);
1129:
1130: evbuffer_add(evb, "\r\n", 2);
1131: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1132: tt_line_eq("Nor is a lack of one");
1133: free(cp);
1134: tt_assert(EVBUFFER_LENGTH(evb) == 0);
1135:
1136: fprintf(stdout, "OK\n");
1137:
1138: /* Test LF */
1139: fprintf(stdout, "Testing evbuffer_readln LF: ");
1140:
1141: s = "An\rand a nl\n\nText";
1142: evbuffer_add(evb, s, strlen(s));
1143:
1144: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1145: tt_line_eq("An\rand a nl");
1146: free(cp);
1147:
1148: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1149: tt_line_eq("");
1150: free(cp);
1151:
1152: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1153: tt_assert(!cp);
1154: free(cp);
1155: evbuffer_add(evb, "\n", 1);
1156: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1157: tt_line_eq("Text");
1158: free(cp);
1159:
1160: fprintf(stdout, "OK\n");
1161:
1162: /* Test CRLF_STRICT - across boundaries */
1163: fprintf(stdout,
1164: "Testing evbuffer_readln CRLF_STRICT across boundaries: ");
1165:
1166: s = " and a bad crlf\nand a good one\r";
1167: evbuffer_add(evb_tmp, s, strlen(s));
1168: evbuffer_add_buffer(evb, evb_tmp);
1169: s = "\n\r";
1170: evbuffer_add(evb_tmp, s, strlen(s));
1171: evbuffer_add_buffer(evb, evb_tmp);
1172: s = "\nMore\r";
1173: evbuffer_add(evb_tmp, s, strlen(s));
1174: evbuffer_add_buffer(evb, evb_tmp);
1175:
1176: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1177: tt_line_eq(" and a bad crlf\nand a good one");
1178: free(cp);
1179:
1180: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1181: tt_line_eq("");
1182: free(cp);
1183:
1184: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1185: tt_assert(!cp);
1186: free(cp);
1187: evbuffer_add(evb, "\n", 1);
1188: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
1189: tt_line_eq("More");
1190: free(cp); cp = NULL;
1191: if (EVBUFFER_LENGTH(evb) != 0) {
1192: fprintf(stdout, "FAILED\n");
1193: exit(1);
1194: }
1195:
1196: fprintf(stdout, "OK\n");
1197:
1198: /* Test memory problem */
1199: fprintf(stdout, "Testing evbuffer_readln memory problem: ");
1200:
1201: s = "one line\ntwo line\nblue line";
1202: evbuffer_add(evb_tmp, s, strlen(s));
1203: evbuffer_add_buffer(evb, evb_tmp);
1204:
1205: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1206: tt_line_eq("one line");
1207: free(cp); cp = NULL;
1208:
1209: cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
1210: tt_line_eq("two line");
1211: free(cp); cp = NULL;
1212:
1213: fprintf(stdout, "OK\n");
1214:
1215: test_ok = 1;
1216: evbuffer_free(evb);
1217: evbuffer_free(evb_tmp);
1218: if (cp) free(cp);
1219: }
1220:
1221: static void
1222: test_evbuffer_find(void)
1223: {
1224: u_char* p;
1225: const char* test1 = "1234567890\r\n";
1226: const char* test2 = "1234567890\r";
1227: #define EVBUFFER_INITIAL_LENGTH 256
1228: char test3[EVBUFFER_INITIAL_LENGTH];
1229: unsigned int i;
1230: struct evbuffer * buf = evbuffer_new();
1231:
1232: /* make sure evbuffer_find doesn't match past the end of the buffer */
1233: fprintf(stdout, "Testing evbuffer_find 1: ");
1234: evbuffer_add(buf, (u_char*)test1, strlen(test1));
1235: evbuffer_drain(buf, strlen(test1));
1236: evbuffer_add(buf, (u_char*)test2, strlen(test2));
1237: p = evbuffer_find(buf, (u_char*)"\r\n", 2);
1238: if (p == NULL) {
1239: fprintf(stdout, "OK\n");
1240: } else {
1241: fprintf(stdout, "FAILED\n");
1242: exit(1);
1243: }
1244:
1245: /*
1246: * drain the buffer and do another find; in r309 this would
1247: * read past the allocated buffer causing a valgrind error.
1248: */
1249: fprintf(stdout, "Testing evbuffer_find 2: ");
1250: evbuffer_drain(buf, strlen(test2));
1251: for (i = 0; i < EVBUFFER_INITIAL_LENGTH; ++i)
1252: test3[i] = 'a';
1253: test3[EVBUFFER_INITIAL_LENGTH - 1] = 'x';
1254: evbuffer_add(buf, (u_char *)test3, EVBUFFER_INITIAL_LENGTH);
1255: p = evbuffer_find(buf, (u_char *)"xy", 2);
1256: if (p == NULL) {
1257: printf("OK\n");
1258: } else {
1259: fprintf(stdout, "FAILED\n");
1260: exit(1);
1261: }
1262:
1263: /* simple test for match at end of allocated buffer */
1264: fprintf(stdout, "Testing evbuffer_find 3: ");
1265: p = evbuffer_find(buf, (u_char *)"ax", 2);
1266: if (p != NULL && strncmp((char*)p, "ax", 2) == 0) {
1267: printf("OK\n");
1268: } else {
1269: fprintf(stdout, "FAILED\n");
1270: exit(1);
1271: }
1272:
1273: evbuffer_free(buf);
1274: }
1275:
1276: /*
1277: * simple bufferevent test
1278: */
1279:
1280: static void
1281: readcb(struct bufferevent *bev, void *arg)
1282: {
1283: if (EVBUFFER_LENGTH(bev->input) == 8333) {
1284: bufferevent_disable(bev, EV_READ);
1285: test_ok++;
1286: }
1287: }
1288:
1289: static void
1290: writecb(struct bufferevent *bev, void *arg)
1291: {
1292: if (EVBUFFER_LENGTH(bev->output) == 0)
1293: test_ok++;
1294: }
1295:
1296: static void
1297: errorcb(struct bufferevent *bev, short what, void *arg)
1298: {
1299: test_ok = -2;
1300: }
1301:
1302: static void
1303: test_bufferevent(void)
1304: {
1305: struct bufferevent *bev1, *bev2;
1306: char buffer[8333];
1307: int i;
1308:
1309: setup_test("Bufferevent: ");
1310:
1311: bev1 = bufferevent_new(pair[0], readcb, writecb, errorcb, NULL);
1312: bev2 = bufferevent_new(pair[1], readcb, writecb, errorcb, NULL);
1313:
1314: bufferevent_disable(bev1, EV_READ);
1315: bufferevent_enable(bev2, EV_READ);
1316:
1317: for (i = 0; i < sizeof(buffer); i++)
1318: buffer[i] = i;
1319:
1320: bufferevent_write(bev1, buffer, sizeof(buffer));
1321:
1322: event_dispatch();
1323:
1324: bufferevent_free(bev1);
1325: bufferevent_free(bev2);
1326:
1327: if (test_ok != 2)
1328: test_ok = 0;
1329:
1330: cleanup_test();
1331: }
1332:
1333: /*
1334: * test watermarks and bufferevent
1335: */
1336:
1337: static void
1338: wm_readcb(struct bufferevent *bev, void *arg)
1339: {
1340: int len = EVBUFFER_LENGTH(bev->input);
1341: static int nread;
1342:
1343: assert(len >= 10 && len <= 20);
1344:
1345: evbuffer_drain(bev->input, len);
1346:
1347: nread += len;
1348: if (nread == 65000) {
1349: bufferevent_disable(bev, EV_READ);
1350: test_ok++;
1351: }
1352: }
1353:
1354: static void
1355: wm_writecb(struct bufferevent *bev, void *arg)
1356: {
1357: if (EVBUFFER_LENGTH(bev->output) == 0)
1358: test_ok++;
1359: }
1360:
1361: static void
1362: wm_errorcb(struct bufferevent *bev, short what, void *arg)
1363: {
1364: test_ok = -2;
1365: }
1366:
1367: static void
1368: test_bufferevent_watermarks(void)
1369: {
1370: struct bufferevent *bev1, *bev2;
1371: char buffer[65000];
1372: int i;
1373:
1374: setup_test("Bufferevent Watermarks: ");
1375:
1376: bev1 = bufferevent_new(pair[0], NULL, wm_writecb, wm_errorcb, NULL);
1377: bev2 = bufferevent_new(pair[1], wm_readcb, NULL, wm_errorcb, NULL);
1378:
1379: bufferevent_disable(bev1, EV_READ);
1380: bufferevent_enable(bev2, EV_READ);
1381:
1382: for (i = 0; i < sizeof(buffer); i++)
1383: buffer[i] = i;
1384:
1385: bufferevent_write(bev1, buffer, sizeof(buffer));
1386:
1387: /* limit the reading on the receiving bufferevent */
1388: bufferevent_setwatermark(bev2, EV_READ, 10, 20);
1389:
1390: event_dispatch();
1391:
1392: bufferevent_free(bev1);
1393: bufferevent_free(bev2);
1394:
1395: if (test_ok != 2)
1396: test_ok = 0;
1397:
1398: cleanup_test();
1399: }
1400:
1401: struct test_pri_event {
1402: struct event ev;
1403: int count;
1404: };
1405:
1406: static void
1407: test_priorities_cb(int fd, short what, void *arg)
1408: {
1409: struct test_pri_event *pri = arg;
1410: struct timeval tv;
1411:
1412: if (pri->count == 3) {
1413: event_loopexit(NULL);
1414: return;
1415: }
1416:
1417: pri->count++;
1418:
1419: evutil_timerclear(&tv);
1420: event_add(&pri->ev, &tv);
1421: }
1422:
1423: static void
1424: test_priorities(int npriorities)
1425: {
1426: char buf[32];
1427: struct test_pri_event one, two;
1428: struct timeval tv;
1429:
1430: evutil_snprintf(buf, sizeof(buf), "Testing Priorities %d: ", npriorities);
1431: setup_test(buf);
1432:
1433: event_base_priority_init(global_base, npriorities);
1434:
1435: memset(&one, 0, sizeof(one));
1436: memset(&two, 0, sizeof(two));
1437:
1438: timeout_set(&one.ev, test_priorities_cb, &one);
1439: if (event_priority_set(&one.ev, 0) == -1) {
1440: fprintf(stderr, "%s: failed to set priority", __func__);
1441: exit(1);
1442: }
1443:
1444: timeout_set(&two.ev, test_priorities_cb, &two);
1445: if (event_priority_set(&two.ev, npriorities - 1) == -1) {
1446: fprintf(stderr, "%s: failed to set priority", __func__);
1447: exit(1);
1448: }
1449:
1450: evutil_timerclear(&tv);
1451:
1452: if (event_add(&one.ev, &tv) == -1)
1453: exit(1);
1454: if (event_add(&two.ev, &tv) == -1)
1455: exit(1);
1456:
1457: event_dispatch();
1458:
1459: event_del(&one.ev);
1460: event_del(&two.ev);
1461:
1462: if (npriorities == 1) {
1463: if (one.count == 3 && two.count == 3)
1464: test_ok = 1;
1465: } else if (npriorities == 2) {
1466: /* Two is called once because event_loopexit is priority 1 */
1467: if (one.count == 3 && two.count == 1)
1468: test_ok = 1;
1469: } else {
1470: if (one.count == 3 && two.count == 0)
1471: test_ok = 1;
1472: }
1473:
1474: cleanup_test();
1475: }
1476:
1477: static void
1478: test_multiple_cb(int fd, short event, void *arg)
1479: {
1480: if (event & EV_READ)
1481: test_ok |= 1;
1482: else if (event & EV_WRITE)
1483: test_ok |= 2;
1484: }
1485:
1486: static void
1487: test_multiple_events_for_same_fd(void)
1488: {
1489: struct event e1, e2;
1490:
1491: setup_test("Multiple events for same fd: ");
1492:
1493: event_set(&e1, pair[0], EV_READ, test_multiple_cb, NULL);
1494: event_add(&e1, NULL);
1495: event_set(&e2, pair[0], EV_WRITE, test_multiple_cb, NULL);
1496: event_add(&e2, NULL);
1497: event_loop(EVLOOP_ONCE);
1498: event_del(&e2);
1499: write(pair[1], TEST1, strlen(TEST1)+1);
1500: event_loop(EVLOOP_ONCE);
1501: event_del(&e1);
1502:
1503: if (test_ok != 3)
1504: test_ok = 0;
1505:
1506: cleanup_test();
1507: }
1508:
1509: int evtag_decode_int(uint32_t *pnumber, struct evbuffer *evbuf);
1510: int evtag_encode_tag(struct evbuffer *evbuf, uint32_t number);
1511: int evtag_decode_tag(uint32_t *pnumber, struct evbuffer *evbuf);
1512:
1513: static void
1514: read_once_cb(int fd, short event, void *arg)
1515: {
1516: char buf[256];
1517: int len;
1518:
1519: len = read(fd, buf, sizeof(buf));
1520:
1521: if (called) {
1522: test_ok = 0;
1523: } else if (len) {
1524: /* Assumes global pair[0] can be used for writing */
1525: write(pair[0], TEST1, strlen(TEST1)+1);
1526: test_ok = 1;
1527: }
1528:
1529: called++;
1530: }
1531:
1532: static void
1533: test_want_only_once(void)
1534: {
1535: struct event ev;
1536: struct timeval tv;
1537:
1538: /* Very simple read test */
1539: setup_test("Want read only once: ");
1540:
1541: write(pair[0], TEST1, strlen(TEST1)+1);
1542:
1543: /* Setup the loop termination */
1544: evutil_timerclear(&tv);
1545: tv.tv_sec = 1;
1546: event_loopexit(&tv);
1547:
1548: event_set(&ev, pair[1], EV_READ, read_once_cb, &ev);
1549: if (event_add(&ev, NULL) == -1)
1550: exit(1);
1551: event_dispatch();
1552:
1553: cleanup_test();
1554: }
1555:
1556: #define TEST_MAX_INT 6
1557:
1558: static void
1559: evtag_int_test(void)
1560: {
1561: struct evbuffer *tmp = evbuffer_new();
1562: uint32_t integers[TEST_MAX_INT] = {
1563: 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1564: };
1565: uint32_t integer;
1566: int i;
1567:
1568: for (i = 0; i < TEST_MAX_INT; i++) {
1569: int oldlen, newlen;
1570: oldlen = EVBUFFER_LENGTH(tmp);
1571: encode_int(tmp, integers[i]);
1572: newlen = EVBUFFER_LENGTH(tmp);
1573: fprintf(stdout, "\t\tencoded 0x%08x with %d bytes\n",
1574: integers[i], newlen - oldlen);
1575: }
1576:
1577: for (i = 0; i < TEST_MAX_INT; i++) {
1578: if (evtag_decode_int(&integer, tmp) == -1) {
1579: fprintf(stderr, "decode %d failed", i);
1580: exit(1);
1581: }
1582: if (integer != integers[i]) {
1583: fprintf(stderr, "got %x, wanted %x",
1584: integer, integers[i]);
1585: exit(1);
1586: }
1587: }
1588:
1589: if (EVBUFFER_LENGTH(tmp) != 0) {
1590: fprintf(stderr, "trailing data");
1591: exit(1);
1592: }
1593: evbuffer_free(tmp);
1594:
1595: fprintf(stdout, "\t%s: OK\n", __func__);
1596: }
1597:
1598: static void
1599: evtag_fuzz(void)
1600: {
1601: u_char buffer[4096];
1602: struct evbuffer *tmp = evbuffer_new();
1603: struct timeval tv;
1604: int i, j;
1605:
1606: int not_failed = 0;
1607: for (j = 0; j < 100; j++) {
1608: for (i = 0; i < sizeof(buffer); i++)
1609: buffer[i] = rand();
1610: evbuffer_drain(tmp, -1);
1611: evbuffer_add(tmp, buffer, sizeof(buffer));
1612:
1613: if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1)
1614: not_failed++;
1615: }
1616:
1617: /* The majority of decodes should fail */
1618: if (not_failed >= 10) {
1619: fprintf(stderr, "evtag_unmarshal should have failed");
1620: exit(1);
1621: }
1622:
1623: /* Now insert some corruption into the tag length field */
1624: evbuffer_drain(tmp, -1);
1625: evutil_timerclear(&tv);
1626: tv.tv_sec = 1;
1627: evtag_marshal_timeval(tmp, 0, &tv);
1628: evbuffer_add(tmp, buffer, sizeof(buffer));
1629:
1630: EVBUFFER_DATA(tmp)[1] = 0xff;
1631: if (evtag_unmarshal_timeval(tmp, 0, &tv) != -1) {
1632: fprintf(stderr, "evtag_unmarshal_timeval should have failed");
1633: exit(1);
1634: }
1635:
1636: evbuffer_free(tmp);
1637:
1638: fprintf(stdout, "\t%s: OK\n", __func__);
1639: }
1640:
1641: static void
1642: evtag_tag_encoding(void)
1643: {
1644: struct evbuffer *tmp = evbuffer_new();
1645: uint32_t integers[TEST_MAX_INT] = {
1646: 0xaf0, 0x1000, 0x1, 0xdeadbeef, 0x00, 0xbef000
1647: };
1648: uint32_t integer;
1649: int i;
1650:
1651: for (i = 0; i < TEST_MAX_INT; i++) {
1652: int oldlen, newlen;
1653: oldlen = EVBUFFER_LENGTH(tmp);
1654: evtag_encode_tag(tmp, integers[i]);
1655: newlen = EVBUFFER_LENGTH(tmp);
1656: fprintf(stdout, "\t\tencoded 0x%08x with %d bytes\n",
1657: integers[i], newlen - oldlen);
1658: }
1659:
1660: for (i = 0; i < TEST_MAX_INT; i++) {
1661: if (evtag_decode_tag(&integer, tmp) == -1) {
1662: fprintf(stderr, "decode %d failed", i);
1663: exit(1);
1664: }
1665: if (integer != integers[i]) {
1666: fprintf(stderr, "got %x, wanted %x",
1667: integer, integers[i]);
1668: exit(1);
1669: }
1670: }
1671:
1672: if (EVBUFFER_LENGTH(tmp) != 0) {
1673: fprintf(stderr, "trailing data");
1674: exit(1);
1675: }
1676: evbuffer_free(tmp);
1677:
1678: fprintf(stdout, "\t%s: OK\n", __func__);
1679: }
1680:
1681: static void
1682: evtag_test(void)
1683: {
1684: fprintf(stdout, "Testing Tagging:\n");
1685:
1686: evtag_init();
1687: evtag_int_test();
1688: evtag_fuzz();
1689:
1690: evtag_tag_encoding();
1691:
1692: fprintf(stdout, "OK\n");
1693: }
1694:
1695: #ifndef WIN32
1696: static void
1697: rpc_test(void)
1698: {
1699: struct msg *msg, *msg2;
1700: struct kill *attack;
1701: struct run *run;
1702: struct evbuffer *tmp = evbuffer_new();
1703: struct timeval tv_start, tv_end;
1704: uint32_t tag;
1705: int i;
1706:
1707: fprintf(stdout, "Testing RPC: ");
1708:
1709: msg = msg_new();
1710: EVTAG_ASSIGN(msg, from_name, "niels");
1711: EVTAG_ASSIGN(msg, to_name, "phoenix");
1712:
1713: if (EVTAG_GET(msg, attack, &attack) == -1) {
1714: fprintf(stderr, "Failed to set kill message.\n");
1715: exit(1);
1716: }
1717:
1718: EVTAG_ASSIGN(attack, weapon, "feather");
1719: EVTAG_ASSIGN(attack, action, "tickle");
1720:
1721: evutil_gettimeofday(&tv_start, NULL);
1722: for (i = 0; i < 1000; ++i) {
1723: run = EVTAG_ADD(msg, run);
1724: if (run == NULL) {
1725: fprintf(stderr, "Failed to add run message.\n");
1726: exit(1);
1727: }
1728: EVTAG_ASSIGN(run, how, "very fast but with some data in it");
1729: EVTAG_ASSIGN(run, fixed_bytes,
1730: (unsigned char*)"012345678901234567890123");
1731: }
1732:
1733: if (msg_complete(msg) == -1) {
1734: fprintf(stderr, "Failed to make complete message.\n");
1735: exit(1);
1736: }
1737:
1738: evtag_marshal_msg(tmp, 0xdeaf, msg);
1739:
1740: if (evtag_peek(tmp, &tag) == -1) {
1741: fprintf(stderr, "Failed to peak tag.\n");
1742: exit (1);
1743: }
1744:
1745: if (tag != 0xdeaf) {
1746: fprintf(stderr, "Got incorrect tag: %0x.\n", tag);
1747: exit (1);
1748: }
1749:
1750: msg2 = msg_new();
1751: if (evtag_unmarshal_msg(tmp, 0xdeaf, msg2) == -1) {
1752: fprintf(stderr, "Failed to unmarshal message.\n");
1753: exit(1);
1754: }
1755:
1756: evutil_gettimeofday(&tv_end, NULL);
1757: evutil_timersub(&tv_end, &tv_start, &tv_end);
1758: fprintf(stderr, "(%.1f us/add) ",
1759: (float)tv_end.tv_sec/(float)i * 1000000.0 +
1760: tv_end.tv_usec / (float)i);
1761:
1762: if (!EVTAG_HAS(msg2, from_name) ||
1763: !EVTAG_HAS(msg2, to_name) ||
1764: !EVTAG_HAS(msg2, attack)) {
1765: fprintf(stderr, "Missing data structures.\n");
1766: exit(1);
1767: }
1768:
1769: if (EVTAG_LEN(msg2, run) != i) {
1770: fprintf(stderr, "Wrong number of run messages.\n");
1771: exit(1);
1772: }
1773:
1774: msg_free(msg);
1775: msg_free(msg2);
1776:
1777: evbuffer_free(tmp);
1778:
1779: fprintf(stdout, "OK\n");
1780: }
1781: #endif
1782:
1783: static void
1784: test_evutil_strtoll(void)
1785: {
1786: const char *s;
1787: char *endptr;
1788: setup_test("evutil_stroll: ");
1789: test_ok = 0;
1790:
1791: if (evutil_strtoll("5000000000", NULL, 10) != ((ev_int64_t)5000000)*1000)
1792: goto err;
1793: if (evutil_strtoll("-5000000000", NULL, 10) != ((ev_int64_t)5000000)*-1000)
1794: goto err;
1795: s = " 99999stuff";
1796: if (evutil_strtoll(s, &endptr, 10) != (ev_int64_t)99999)
1797: goto err;
1798: if (endptr != s+6)
1799: goto err;
1800: if (evutil_strtoll("foo", NULL, 10) != 0)
1801: goto err;
1802:
1803: test_ok = 1;
1804: err:
1805: cleanup_test();
1806: }
1807:
1808:
1809: int
1810: main (int argc, char **argv)
1811: {
1812: #ifdef WIN32
1813: WORD wVersionRequested;
1814: WSADATA wsaData;
1815: int err;
1816:
1817: wVersionRequested = MAKEWORD( 2, 2 );
1818:
1819: err = WSAStartup( wVersionRequested, &wsaData );
1820: #endif
1821:
1822: #ifndef WIN32
1823: if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
1824: return (1);
1825: #endif
1826: setvbuf(stdout, NULL, _IONBF, 0);
1827:
1828: /* Initalize the event library */
1829: global_base = event_init();
1830:
1831: test_registerfds();
1832:
1833: test_evutil_strtoll();
1834:
1835: /* use the global event base and need to be called first */
1836: test_priorities(1);
1837: test_priorities(2);
1838: test_priorities(3);
1839:
1840: test_evbuffer();
1841: test_evbuffer_find();
1842: test_evbuffer_readln();
1843:
1844: test_bufferevent();
1845: test_bufferevent_watermarks();
1846:
1847: test_free_active_base();
1848:
1849: test_event_base_new();
1850:
1851: http_suite();
1852:
1853: #ifndef WIN32
1854: rpc_suite();
1855: #endif
1856:
1857: dns_suite();
1858:
1859: #ifndef WIN32
1860: test_fork();
1861: #endif
1862:
1863: test_simpleread();
1864:
1865: test_simplewrite();
1866:
1867: test_multiple();
1868:
1869: test_persistent();
1870:
1871: test_combined();
1872:
1873: test_simpletimeout();
1874: #ifndef WIN32
1875: test_simplesignal();
1876: test_multiplesignal();
1877: test_immediatesignal();
1878: #endif
1879: test_loopexit();
1880: test_loopbreak();
1881:
1882: test_loopexit_multiple();
1883:
1884: test_multiple_events_for_same_fd();
1885:
1886: test_want_only_once();
1887:
1888: evtag_test();
1889:
1890: #ifndef WIN32
1891: rpc_test();
1892:
1893: test_signal_dealloc();
1894: test_signal_pipeloss();
1895: test_signal_switchbase();
1896: test_signal_restore();
1897: test_signal_assert();
1898: test_signal_while_processing();
1899: #endif
1900:
1901: return (0);
1902: }
1903: