Commit | Line | Data |
---|---|---|
8537d55a NR |
1 | package be.nikiroo.utils.test; |
2 | ||
3 | import be.nikiroo.utils.Version; | |
4 | import be.nikiroo.utils.serial.server.ConnectActionClientObject; | |
5 | import be.nikiroo.utils.serial.server.ConnectActionClientString; | |
6 | import be.nikiroo.utils.serial.server.ConnectActionServerObject; | |
7 | import be.nikiroo.utils.serial.server.ConnectActionServerString; | |
8 | import be.nikiroo.utils.serial.server.ServerBridge; | |
9 | import be.nikiroo.utils.serial.server.ServerObject; | |
10 | import be.nikiroo.utils.serial.server.ServerString; | |
11 | ||
12 | class SerialServerTest extends TestLauncher { | |
13 | private TestLauncher createServerStringTestCases(final String[] args, | |
14 | final boolean ssl, final boolean bridge) { | |
15 | final String ssls = (ssl ? "(ssl)" : "(plain text)"); | |
16 | final String bridges = (bridge ? " with bridge" : ""); | |
17 | TestLauncher series = new TestLauncher( | |
18 | "ServerString " + ssls + bridges, args); | |
19 | ||
20 | series.addTest(new TestCase("Simple connection " + ssls) { | |
21 | @Override | |
22 | public void test() throws Exception { | |
23 | final String[] rec = new String[1]; | |
24 | ||
25 | ServerString server = new ServerString(this.getName(), 0, ssl) { | |
26 | @Override | |
27 | protected String onRequest( | |
28 | ConnectActionServerString action, | |
29 | Version clientVersion, String data) | |
30 | throws Exception { | |
31 | return null; | |
32 | } | |
d827da2a NR |
33 | |
34 | @Override | |
35 | protected void onError(Exception e) { | |
36 | } | |
8537d55a NR |
37 | }; |
38 | ||
39 | int port = server.getPort(); | |
40 | assertEquals("A port should have been assigned", true, port > 0); | |
41 | ||
42 | server.start(); | |
43 | ||
44 | ServerBridge br = null; | |
45 | if (bridge) { | |
46 | br = new ServerBridge(0, ssl, "", port, ssl); | |
47 | ||
48 | port = br.getPort(); | |
49 | assertEquals( | |
50 | "A port should have been assigned to the bridge", | |
51 | true, port > 0); | |
52 | ||
53 | br.start(); | |
54 | } | |
55 | ||
56 | try { | |
57 | try { | |
58 | new ConnectActionClientObject(null, port, ssl) { | |
59 | @Override | |
60 | public void action(Version serverVersion) | |
61 | throws Exception { | |
62 | rec[0] = "ok"; | |
63 | } | |
64 | }.connect(); | |
65 | } finally { | |
66 | server.stop(); | |
67 | } | |
68 | } finally { | |
69 | if (br != null) { | |
70 | br.stop(); | |
71 | } | |
72 | } | |
73 | ||
74 | assertNotNull("The client action was not run", rec[0]); | |
75 | assertEquals("ok", rec[0]); | |
76 | } | |
77 | }); | |
78 | ||
79 | series.addTest(new TestCase("Simple exchange " + ssls) { | |
80 | final String[] sent = new String[1]; | |
81 | final String[] recd = new String[1]; | |
82 | final Exception[] err = new Exception[1]; | |
83 | ||
84 | @Override | |
85 | public void test() throws Exception { | |
86 | ServerString server = new ServerString(this.getName(), 0, ssl) { | |
87 | @Override | |
88 | protected String onRequest( | |
89 | ConnectActionServerString action, | |
90 | Version clientVersion, String data) | |
91 | throws Exception { | |
92 | sent[0] = data; | |
93 | return "pong"; | |
94 | } | |
95 | ||
96 | @Override | |
97 | protected void onError(Exception e) { | |
98 | super.onError(e); | |
99 | err[0] = e; | |
100 | } | |
101 | }; | |
102 | ||
103 | int port = server.getPort(); | |
104 | ||
105 | server.start(); | |
106 | ||
107 | ServerBridge br = null; | |
108 | if (bridge) { | |
109 | br = new ServerBridge(0, ssl, "", port, ssl); | |
110 | port = br.getPort(); | |
111 | br.start(); | |
112 | } | |
113 | ||
114 | try { | |
115 | try { | |
116 | new ConnectActionClientString(null, port, ssl) { | |
117 | @Override | |
118 | public void action(Version serverVersion) | |
119 | throws Exception { | |
120 | recd[0] = send("ping"); | |
121 | } | |
122 | }.connect(); | |
123 | } finally { | |
124 | server.stop(); | |
125 | } | |
126 | } finally { | |
127 | if (br != null) { | |
128 | br.stop(); | |
129 | } | |
130 | } | |
131 | ||
132 | if (err[0] != null) { | |
133 | fail("An exception was thrown: " + err[0].getMessage()); | |
134 | } | |
135 | ||
136 | assertEquals("ping", sent[0]); | |
137 | assertEquals("pong", recd[0]); | |
138 | } | |
139 | }); | |
140 | ||
141 | series.addTest(new TestCase("Multiple exchanges " + ssls) { | |
142 | final String[] sent = new String[3]; | |
143 | final String[] recd = new String[3]; | |
144 | final Exception[] err = new Exception[1]; | |
145 | ||
146 | @Override | |
147 | public void test() throws Exception { | |
148 | ServerString server = new ServerString(this.getName(), 0, ssl) { | |
149 | @Override | |
150 | protected String onRequest( | |
151 | ConnectActionServerString action, | |
152 | Version clientVersion, String data) | |
153 | throws Exception { | |
154 | sent[0] = data; | |
155 | action.send("pong"); | |
156 | sent[1] = action.rec(); | |
157 | return "pong2"; | |
158 | } | |
159 | ||
160 | @Override | |
161 | protected void onError(Exception e) { | |
162 | super.onError(e); | |
163 | err[0] = e; | |
164 | } | |
165 | }; | |
166 | ||
167 | int port = server.getPort(); | |
168 | ||
169 | server.start(); | |
170 | ||
171 | ServerBridge br = null; | |
172 | if (bridge) { | |
173 | br = new ServerBridge(0, ssl, "", port, ssl); | |
174 | port = br.getPort(); | |
175 | br.start(); | |
176 | } | |
177 | ||
178 | try { | |
179 | try { | |
180 | new ConnectActionClientString(null, port, ssl) { | |
181 | @Override | |
182 | public void action(Version serverVersion) | |
183 | throws Exception { | |
184 | recd[0] = send("ping"); | |
185 | recd[1] = send("ping2"); | |
186 | } | |
187 | }.connect(); | |
188 | } finally { | |
189 | server.stop(); | |
190 | } | |
191 | } finally { | |
192 | if (br != null) { | |
193 | br.stop(); | |
194 | } | |
195 | } | |
196 | ||
197 | if (err[0] != null) { | |
198 | fail("An exception was thrown: " + err[0].getMessage()); | |
199 | } | |
200 | ||
201 | assertEquals("ping", sent[0]); | |
202 | assertEquals("pong", recd[0]); | |
203 | assertEquals("ping2", sent[1]); | |
204 | assertEquals("pong2", recd[1]); | |
205 | } | |
206 | }); | |
207 | ||
208 | series.addTest(new TestCase("Multiple call from client " + ssls) { | |
209 | final String[] sent = new String[3]; | |
210 | final String[] recd = new String[3]; | |
211 | final Exception[] err = new Exception[1]; | |
212 | ||
213 | @Override | |
214 | public void test() throws Exception { | |
215 | ServerString server = new ServerString(this.getName(), 0, ssl) { | |
216 | @Override | |
217 | protected String onRequest( | |
218 | ConnectActionServerString action, | |
219 | Version clientVersion, String data) | |
220 | throws Exception { | |
221 | sent[Integer.parseInt(data)] = data; | |
222 | return "" + (Integer.parseInt(data) * 2); | |
223 | } | |
224 | ||
225 | @Override | |
226 | protected void onError(Exception e) { | |
227 | super.onError(e); | |
228 | err[0] = e; | |
229 | } | |
230 | }; | |
231 | ||
232 | int port = server.getPort(); | |
233 | ||
234 | server.start(); | |
235 | ||
236 | ServerBridge br = null; | |
237 | if (bridge) { | |
238 | br = new ServerBridge(0, ssl, "", port, ssl); | |
239 | port = br.getPort(); | |
240 | br.start(); | |
241 | } | |
242 | ||
243 | try { | |
244 | try { | |
245 | new ConnectActionClientString(null, port, ssl) { | |
246 | @Override | |
247 | public void action(Version serverVersion) | |
248 | throws Exception { | |
249 | for (int i = 0; i < 3; i++) { | |
250 | recd[i] = send("" + i); | |
251 | } | |
252 | } | |
253 | }.connect(); | |
254 | } finally { | |
255 | server.stop(); | |
256 | } | |
257 | } finally { | |
258 | if (br != null) { | |
259 | br.stop(); | |
260 | } | |
261 | } | |
262 | ||
263 | if (err[0] != null) { | |
264 | fail("An exception was thrown: " + err[0].getMessage()); | |
265 | } | |
266 | ||
267 | assertEquals("0", sent[0]); | |
268 | assertEquals("0", recd[0]); | |
269 | assertEquals("1", sent[1]); | |
270 | assertEquals("2", recd[1]); | |
271 | assertEquals("2", sent[2]); | |
272 | assertEquals("4", recd[2]); | |
273 | } | |
274 | }); | |
275 | ||
276 | return series; | |
277 | } | |
278 | ||
279 | private TestLauncher createServerObjectTestCases(final String[] args, | |
280 | final boolean ssl, final boolean bridge) { | |
281 | final String ssls = (ssl ? "(ssl)" : "(plain text)"); | |
282 | final String bridges = (bridge ? " with bridge" : ""); | |
283 | TestLauncher series = new TestLauncher( | |
284 | "ServerObject " + ssls + bridges, args); | |
285 | ||
286 | series.addTest(new TestCase("Simple connection " + ssls) { | |
287 | @Override | |
288 | public void test() throws Exception { | |
289 | final Object[] rec = new Object[1]; | |
290 | ||
291 | ServerObject server = new ServerObject(this.getName(), 0, ssl) { | |
292 | @Override | |
293 | protected Object onRequest( | |
294 | ConnectActionServerObject action, | |
295 | Version clientVersion, Object data) | |
296 | throws Exception { | |
297 | return null; | |
298 | } | |
d827da2a NR |
299 | |
300 | @Override | |
301 | protected void onError(Exception e) { | |
302 | } | |
8537d55a NR |
303 | }; |
304 | ||
305 | int port = server.getPort(); | |
306 | assertEquals("A port should have been assigned", true, port > 0); | |
307 | ||
308 | server.start(); | |
309 | ||
310 | ServerBridge br = null; | |
311 | if (bridge) { | |
d827da2a NR |
312 | br = new ServerBridge(0, ssl, "", port, ssl) { |
313 | @Override | |
314 | protected void onError(Exception e) { | |
315 | } | |
316 | }; | |
8537d55a NR |
317 | port = br.getPort(); |
318 | br.start(); | |
319 | } | |
320 | ||
321 | try { | |
322 | try { | |
323 | new ConnectActionClientObject(null, port, ssl) { | |
324 | @Override | |
325 | public void action(Version serverVersion) | |
326 | throws Exception { | |
327 | rec[0] = true; | |
328 | } | |
d827da2a NR |
329 | |
330 | @Override | |
331 | protected void onError(Exception e) { | |
332 | } | |
8537d55a NR |
333 | }.connect(); |
334 | } finally { | |
335 | server.stop(); | |
336 | } | |
337 | } finally { | |
338 | if (br != null) { | |
339 | br.stop(); | |
340 | } | |
341 | } | |
342 | ||
343 | assertNotNull("The client action was not run", rec[0]); | |
344 | assertEquals(true, (boolean) ((Boolean) rec[0])); | |
345 | } | |
346 | }); | |
347 | ||
348 | series.addTest(new TestCase("Simple exchange " + ssls) { | |
349 | final Object[] sent = new Object[1]; | |
350 | final Object[] recd = new Object[1]; | |
351 | final Exception[] err = new Exception[1]; | |
352 | ||
353 | @Override | |
354 | public void test() throws Exception { | |
355 | ServerObject server = new ServerObject(this.getName(), 0, ssl) { | |
356 | @Override | |
357 | protected Object onRequest( | |
358 | ConnectActionServerObject action, | |
359 | Version clientVersion, Object data) | |
360 | throws Exception { | |
361 | sent[0] = data; | |
362 | return "pong"; | |
363 | } | |
364 | ||
365 | @Override | |
366 | protected void onError(Exception e) { | |
367 | super.onError(e); | |
368 | err[0] = e; | |
369 | } | |
370 | }; | |
371 | ||
372 | int port = server.getPort(); | |
373 | ||
374 | server.start(); | |
375 | ||
376 | ServerBridge br = null; | |
377 | if (bridge) { | |
378 | br = new ServerBridge(0, ssl, "", port, ssl); | |
379 | port = br.getPort(); | |
380 | br.start(); | |
381 | } | |
382 | ||
383 | try { | |
384 | try { | |
385 | new ConnectActionClientObject(null, port, ssl) { | |
386 | @Override | |
387 | public void action(Version serverVersion) | |
388 | throws Exception { | |
389 | recd[0] = send("ping"); | |
390 | } | |
391 | }.connect(); | |
392 | } finally { | |
393 | server.stop(); | |
394 | } | |
395 | } finally { | |
396 | if (br != null) { | |
397 | br.stop(); | |
398 | } | |
399 | } | |
400 | ||
401 | if (err[0] != null) { | |
402 | fail("An exception was thrown: " + err[0].getMessage()); | |
403 | } | |
404 | ||
405 | assertEquals("ping", sent[0]); | |
406 | assertEquals("pong", recd[0]); | |
407 | } | |
408 | }); | |
409 | ||
410 | series.addTest(new TestCase("Multiple exchanges " + ssls) { | |
411 | final Object[] sent = new Object[3]; | |
412 | final Object[] recd = new Object[3]; | |
413 | final Exception[] err = new Exception[1]; | |
414 | ||
415 | @Override | |
416 | public void test() throws Exception { | |
417 | ServerObject server = new ServerObject(this.getName(), 0, ssl) { | |
418 | @Override | |
419 | protected Object onRequest( | |
420 | ConnectActionServerObject action, | |
421 | Version clientVersion, Object data) | |
422 | throws Exception { | |
423 | sent[0] = data; | |
424 | action.send("pong"); | |
425 | sent[1] = action.rec(); | |
426 | return "pong2"; | |
427 | } | |
428 | ||
429 | @Override | |
430 | protected void onError(Exception e) { | |
431 | super.onError(e); | |
432 | err[0] = e; | |
433 | } | |
434 | }; | |
435 | ||
436 | int port = server.getPort(); | |
437 | ||
438 | server.start(); | |
439 | ||
440 | ServerBridge br = null; | |
441 | if (bridge) { | |
442 | br = new ServerBridge(0, ssl, "", port, ssl); | |
443 | port = br.getPort(); | |
444 | br.start(); | |
445 | } | |
446 | ||
447 | try { | |
448 | try { | |
449 | new ConnectActionClientObject(null, port, ssl) { | |
450 | @Override | |
451 | public void action(Version serverVersion) | |
452 | throws Exception { | |
453 | recd[0] = send("ping"); | |
454 | recd[1] = send("ping2"); | |
455 | } | |
456 | }.connect(); | |
457 | } finally { | |
458 | server.stop(); | |
459 | } | |
460 | } finally { | |
461 | if (br != null) { | |
462 | br.stop(); | |
463 | } | |
464 | } | |
465 | ||
466 | if (err[0] != null) { | |
467 | fail("An exception was thrown: " + err[0].getMessage()); | |
468 | } | |
469 | ||
470 | assertEquals("ping", sent[0]); | |
471 | assertEquals("pong", recd[0]); | |
472 | assertEquals("ping2", sent[1]); | |
473 | assertEquals("pong2", recd[1]); | |
474 | } | |
475 | }); | |
476 | ||
477 | series.addTest(new TestCase("Multiple call from client " + ssls) { | |
478 | final Object[] sent = new Object[3]; | |
479 | final Object[] recd = new Object[3]; | |
480 | final Exception[] err = new Exception[1]; | |
481 | ||
482 | @Override | |
483 | public void test() throws Exception { | |
484 | ServerObject server = new ServerObject(this.getName(), 0, ssl) { | |
485 | @Override | |
486 | protected Object onRequest( | |
487 | ConnectActionServerObject action, | |
488 | Version clientVersion, Object data) | |
489 | throws Exception { | |
490 | sent[(Integer) data] = data; | |
491 | return ((Integer) data) * 2; | |
492 | } | |
493 | ||
494 | @Override | |
495 | protected void onError(Exception e) { | |
496 | super.onError(e); | |
497 | err[0] = e; | |
498 | } | |
499 | }; | |
500 | ||
501 | int port = server.getPort(); | |
502 | ||
503 | server.start(); | |
504 | ||
505 | ServerBridge br = null; | |
506 | if (bridge) { | |
507 | br = new ServerBridge(0, ssl, "", port, ssl); | |
508 | port = br.getPort(); | |
509 | br.start(); | |
510 | } | |
511 | ||
512 | try { | |
513 | try { | |
514 | new ConnectActionClientObject(null, port, ssl) { | |
515 | @Override | |
516 | public void action(Version serverVersion) | |
517 | throws Exception { | |
518 | for (int i = 0; i < 3; i++) { | |
519 | recd[i] = send(i); | |
520 | } | |
521 | } | |
522 | }.connect(); | |
523 | } finally { | |
524 | server.stop(); | |
525 | } | |
526 | } finally { | |
527 | if (br != null) { | |
528 | br.stop(); | |
529 | } | |
530 | } | |
531 | ||
532 | if (err[0] != null) { | |
533 | fail("An exception was thrown: " + err[0].getMessage()); | |
534 | } | |
535 | ||
536 | assertEquals(0, sent[0]); | |
537 | assertEquals(0, recd[0]); | |
538 | assertEquals(1, sent[1]); | |
539 | assertEquals(2, recd[1]); | |
540 | assertEquals(2, sent[2]); | |
541 | assertEquals(4, recd[2]); | |
542 | } | |
543 | }); | |
544 | ||
545 | return series; | |
546 | } | |
547 | ||
548 | public SerialServerTest(String[] args) { | |
549 | super("SerialServer test", args); | |
550 | ||
551 | for (boolean ssl : new Boolean[] { false, true }) { | |
552 | for (boolean bridge : new Boolean[] { false, true }) { | |
553 | addSeries(createServerObjectTestCases(args, ssl, bridge)); | |
554 | addSeries(createServerStringTestCases(args, ssl, bridge)); | |
555 | } | |
556 | } | |
557 | } | |
558 | } |