![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_watcher.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / tests / suites|
Return to test_watcher.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / tests / suites |
1.1 misho 1: /*
2: * Copyright (C) 2013 Martin Willi
3: * Copyright (C) 2013 revosec AG
4: *
5: * This program is free software; you can redistribute it and/or modify it
6: * under the terms of the GNU General Public License as published by the
7: * Free Software Foundation; either version 2 of the License, or (at your
8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
9: *
10: * This program is distributed in the hope that it will be useful, but
11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13: * for more details.
14: */
15:
16: #include "test_suite.h"
17:
18: #include <library.h>
19:
20: #include <unistd.h>
21: #include <errno.h>
22:
23: static char testbuf[1] = "";
24:
25: static bool readcb(void *data, int fd, watcher_event_t event)
26: {
27: ck_assert_int_eq(*(int*)data, fd);
28: ck_assert_int_eq(event, WATCHER_READ);
29:
30: if (recv(fd, testbuf, 1, MSG_DONTWAIT) != 1)
31: {
32: ck_assert(errno == EAGAIN || errno == EWOULDBLOCK);
33: }
34: return TRUE;
35: }
36:
37: START_TEST(test_read)
38: {
39: int fd[2];
40: char c;
41:
42: lib->processor->set_threads(lib->processor, 8);
43:
44: ck_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != -1);
45:
46: lib->watcher->add(lib->watcher, fd[0], WATCHER_READ, readcb, &fd[0]);
47:
48: for (c = 'a'; c <= 'z'; c++)
49: {
50: ck_assert_int_eq(send(fd[1], &c, 1, 0), 1);
51: while (testbuf[0] != c)
52: {
53: sched_yield();
54: }
55: }
56:
57: lib->watcher->remove(lib->watcher, fd[0]);
58: close(fd[0]);
59: close(fd[1]);
60:
61: lib->processor->cancel(lib->processor);
62: }
63: END_TEST
64:
65: static bool writecb(void *data, int fd, watcher_event_t event)
66: {
67: ck_assert_int_eq(event, WATCHER_WRITE);
68: if (send(fd, data, 1, MSG_DONTWAIT) != 1)
69: {
70: ck_assert(errno == EAGAIN || errno == EWOULDBLOCK);
71: }
72: return TRUE;
73: }
74:
75: START_TEST(test_write)
76: {
77: int fd[2];
78: char in = 'x', out;
79:
80: lib->processor->set_threads(lib->processor, 8);
81:
82: ck_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, fd) != -1);
83:
84: lib->watcher->add(lib->watcher, fd[1], WATCHER_WRITE, writecb, &in);
85:
86: ck_assert_int_eq(recv(fd[0], &out, 1, 0), 1);
87: ck_assert_int_eq(out, in);
88:
89: lib->watcher->remove(lib->watcher, fd[1]);
90: close(fd[1]);
91: close(fd[0]);
92:
93: lib->processor->cancel(lib->processor);
94: }
95: END_TEST
96:
97: static bool multiread(void *data, int fd, watcher_event_t event)
98: {
99: ck_assert_int_eq(event, WATCHER_READ);
100: if (recv(fd, data, 1, MSG_DONTWAIT) != 1)
101: {
102: ck_assert(errno == EAGAIN || errno == EWOULDBLOCK);
103: }
104: return TRUE;
105: }
106:
107: START_TEST(test_multiread)
108: {
109: int fd[10][2], i;
110: char in, out[countof(fd)];
111:
112: lib->processor->set_threads(lib->processor, 8);
113:
114: for (i = 0; i < countof(fd); i++)
115: {
116: ck_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, fd[i]) != -1);
117: lib->watcher->add(lib->watcher, fd[i][0],
118: WATCHER_READ, multiread, &out[i]);
119: }
120:
121: for (i = 0; i < countof(fd); i++)
122: {
123: for (in = 'a'; in <= 'z'; in++)
124: {
125: ck_assert_int_eq(send(fd[i][1], &in, 1, 0), 1);
126: while (out[i] != in)
127: {
128: sched_yield();
129: }
130: }
131: }
132:
133: for (i = 0; i < countof(fd); i++)
134: {
135: lib->watcher->remove(lib->watcher, fd[i][0]);
136: close(fd[i][1]);
137: close(fd[i][0]);
138: }
139:
140: lib->processor->cancel(lib->processor);
141: }
142: END_TEST
143:
144: static bool multiwrite(void *data, int fd, watcher_event_t event)
145: {
146: ck_assert_int_eq(event, WATCHER_WRITE);
147: if (send(fd, data, 1, MSG_DONTWAIT) != 1)
148: {
149: ck_assert(errno == EAGAIN || errno == EWOULDBLOCK);
150: }
151: return TRUE;
152: }
153:
154: START_TEST(test_multiwrite)
155: {
156: int fd[10][2], i, j;
157: u_char out, in[countof(fd)];
158:
159: lib->processor->set_threads(lib->processor, 8);
160:
161: for (i = 0; i < countof(fd); i++)
162: {
163: ck_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, fd[i]) != -1);
164: in[i] = i;
165: lib->watcher->add(lib->watcher, fd[i][1],
166: WATCHER_WRITE, multiwrite, &in[i]);
167: }
168:
169: for (j = 0; j < 10; j++)
170: {
171: for (i = 0; i < countof(fd); i++)
172: {
173: ck_assert_int_eq(recv(fd[i][0], &out, 1, 0), 1);
174: ck_assert_int_eq(out, i);
175: }
176: }
177:
178: for (i = 0; i < countof(fd); i++)
179: {
180: lib->watcher->remove(lib->watcher, fd[i][1]);
181: close(fd[i][1]);
182: close(fd[i][0]);
183: }
184:
185: lib->processor->cancel(lib->processor);
186: }
187: END_TEST
188:
189: Suite *watcher_suite_create()
190: {
191: Suite *s;
192: TCase *tc;
193:
194: s = suite_create("watcher");
195:
196: tc = tcase_create("read");
197: tcase_add_test(tc, test_read);
198: suite_add_tcase(s, tc);
199:
200: tc = tcase_create("write");
201: tcase_add_test(tc, test_write);
202: suite_add_tcase(s, tc);
203:
204: tc = tcase_create("multiread");
205: tcase_add_test(tc, test_multiread);
206: suite_add_tcase(s, tc);
207:
208: tc = tcase_create("multiwrite");
209: tcase_add_test(tc, test_multiwrite);
210: suite_add_tcase(s, tc);
211:
212: return s;
213: }