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