![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_stream.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_stream.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 <unistd.h>
19:
20: static char* services[] = {
21: #ifndef WIN32
22: "unix:///tmp/strongswan-test-service.sck",
23: #endif
24: "tcp://127.0.0.1:7766",
25: "tcp://[::1]:7766",
26: };
27:
28: static char msg[] = "testmessage";
29: static int msglen = 12;
30:
31: static bool servicing(void *data, stream_t *stream)
32: {
33: char buf[64];
34: ssize_t len, total;
35:
36: ck_assert(streq((char*)data, "test"));
37:
38: for (total = 0; total < msglen;)
39: {
40: len = stream->read(stream, buf, sizeof(buf), TRUE);
41: ck_assert(len > 0);
42: total += len;
43: }
44: for (total = 0; total < msglen;)
45: {
46: len = stream->write(stream, buf, len, TRUE);
47: ck_assert(len > 0);
48: total += len;
49: }
50:
51: return FALSE;
52: }
53:
54: START_TEST(test_sync)
55: {
56: char buf[64];
57: stream_service_t *service;
58: stream_t *stream;
59: ssize_t len, total;
60:
61: lib->processor->set_threads(lib->processor, 8);
62:
63: service = lib->streams->create_service(lib->streams, services[_i], 1);
64: ck_assert(service != NULL);
65: service->on_accept(service, servicing, "test", JOB_PRIO_HIGH, 1);
66:
67: stream = lib->streams->connect(lib->streams, services[_i]);
68: ck_assert(stream != NULL);
69: for (total = 0; total < msglen;)
70: {
71: len = stream->write(stream, msg, msglen, TRUE);
72: ck_assert(len > 0);
73: total += len;
74: }
75: for (total = 0; total < msglen;)
76: {
77: len = stream->read(stream, buf, sizeof(buf), TRUE);
78: ck_assert(len > 0);
79: total += len;
80: }
81: ck_assert(streq(buf, msg));
82: stream->destroy(stream);
83:
84: service->destroy(service);
85: }
86: END_TEST
87:
88: static bool on_write(void *data, stream_t *stream)
89: {
90: ssize_t len, total;
91:
92: ck_assert(streq((char*)data, "test-write"));
93: for (total = 0; total < msglen;)
94: {
95: len = stream->write(stream, msg, msglen, TRUE);
96: ck_assert(len > 0);
97: total += len;
98: }
99: return FALSE;
100: }
101:
102: static bool read_done = FALSE;
103:
104: static bool on_read(void *data, stream_t *stream)
105: {
106: ssize_t len, total;
107: char buf[64];
108:
109: ck_assert(streq((char*)data, "test-read"));
110: for (total = 0; total < msglen;)
111: {
112: len = stream->read(stream, buf, sizeof(buf), TRUE);
113: ck_assert(len > 0);
114: total += len;
115: }
116: ck_assert(streq(buf, msg));
117: read_done = TRUE;
118: return FALSE;
119: }
120:
121: START_TEST(test_async)
122: {
123: stream_service_t *service;
124: stream_t *stream;
125:
126: lib->processor->set_threads(lib->processor, 8);
127:
128: service = lib->streams->create_service(lib->streams, services[_i], 1);
129: ck_assert(service != NULL);
130: service->on_accept(service, servicing, "test", JOB_PRIO_HIGH, 0);
131:
132: stream = lib->streams->connect(lib->streams, services[_i]);
133: ck_assert(stream != NULL);
134: read_done = FALSE;
135: stream->on_write(stream, (stream_cb_t)on_write, "test-write");
136: stream->on_read(stream, (stream_cb_t)on_read, "test-read");
137:
138: while (!read_done)
139: {
140: usleep(1000);
141: }
142: stream->destroy(stream);
143:
144: service->destroy(service);
145: }
146: END_TEST
147:
148: static bool all(void *data, stream_t *stream)
149: {
150: char buf[64], *pos;
151: ssize_t len;
152: int i;
153:
154: pos = buf;
155: for (i = 0; i < msglen; i++)
156: {
157: len = stream->read(stream, pos, 1, TRUE);
158: ck_assert_int_eq(len, 1);
159: pos += len;
160: }
161: pos = buf;
162: for (i = 0; i < msglen; i++)
163: {
164: len = stream->write(stream, pos, 1, TRUE);
165: ck_assert_int_eq(len, 1);
166: pos += len;
167: }
168:
169: return FALSE;
170: }
171:
172: START_TEST(test_all)
173: {
174: char buf[64];
175: stream_service_t *service;
176: stream_t *stream;
177:
178: lib->processor->set_threads(lib->processor, 8);
179:
180: service = lib->streams->create_service(lib->streams, services[_i], 1);
181: ck_assert(service != NULL);
182: service->on_accept(service, all, NULL, JOB_PRIO_HIGH, 1);
183:
184: stream = lib->streams->connect(lib->streams, services[_i]);
185: ck_assert(stream != NULL);
186: ck_assert(stream->write_all(stream, msg, msglen));
187: ck_assert(stream->read_all(stream, buf, msglen));
188: ck_assert(streq(buf, msg));
189: stream->destroy(stream);
190:
191: service->destroy(service);
192: }
193: END_TEST
194:
195: static bool concurrency(void *data, stream_t *stream)
196: {
197: static refcount_t refs = 0;
198: u_int current;
199: ssize_t len;
200:
201: current = ref_get(&refs);
202: ck_assert(current <= 3);
203: len = stream->write(stream, "x", 1, TRUE);
204: ck_assert_int_eq(len, 1);
205: usleep(1000);
206: ignore_result(ref_put(&refs));
207:
208: return FALSE;
209: }
210:
211: START_TEST(test_concurrency)
212: {
213: stream_service_t *service;
214: stream_t *streams[10];
215: ssize_t len;
216: char x;
217: int i;
218:
219: lib->processor->set_threads(lib->processor, 8);
220:
221: service = lib->streams->create_service(lib->streams, services[_i], 10);
222: ck_assert(service != NULL);
223: service->on_accept(service, concurrency, NULL, JOB_PRIO_HIGH, 3);
224:
225: for (i = 0; i < countof(streams); i++)
226: {
227: streams[i] = lib->streams->connect(lib->streams, services[_i]);
228: ck_assert(streams[i] != NULL);
229: }
230: for (i = 0; i < countof(streams); i++)
231: {
232: len = streams[i]->read(streams[i], &x, 1, TRUE);
233: ck_assert_int_eq(len, 1);
234: ck_assert_int_eq(x, 'x');
235: }
236: for (i = 0; i < countof(streams); i++)
237: {
238: streams[i]->destroy(streams[i]);
239: }
240: service->destroy(service);
241: }
242: END_TEST
243:
244: Suite *stream_suite_create()
245: {
246: Suite *s;
247: TCase *tc;
248:
249: s = suite_create("stream");
250:
251: tc = tcase_create("sync");
252: tcase_add_loop_test(tc, test_sync, 0, countof(services));
253: suite_add_tcase(s, tc);
254:
255: tc = tcase_create("async");
256: tcase_add_loop_test(tc, test_async, 0, countof(services));
257: suite_add_tcase(s, tc);
258:
259: tc = tcase_create("all");
260: tcase_add_loop_test(tc, test_all, 0, countof(services));
261: suite_add_tcase(s, tc);
262:
263: tc = tcase_create("concurrency");
264: tcase_add_loop_test(tc, test_concurrency, 0, countof(services));
265: suite_add_tcase(s, tc);
266:
267: return s;
268: }