Commit | Line | Data |
---|---|---|
db31c358 NR |
1 | package be.nikiroo.utils.test; |
2 | ||
ce0974c4 | 3 | import be.nikiroo.utils.Version; |
08a58812 | 4 | import be.nikiroo.utils.serial.ConnectActionClient; |
ce0974c4 | 5 | import be.nikiroo.utils.serial.ConnectActionServer; |
db31c358 NR |
6 | import be.nikiroo.utils.serial.Exporter; |
7 | import be.nikiroo.utils.serial.Importer; | |
ce0974c4 | 8 | import be.nikiroo.utils.serial.Server; |
db31c358 NR |
9 | |
10 | class SerialTest extends TestLauncher { | |
cd0c27d2 | 11 | @SuppressWarnings("unused") |
ce0974c4 NR |
12 | private void not_used() { |
13 | // TODO: test Server ; but this will at least help dependency checking | |
14 | try { | |
cd0c27d2 | 15 | Server server = new Server(0, false) { |
ce0974c4 NR |
16 | @Override |
17 | protected Object onRequest(ConnectActionServer action, | |
18 | Version clientVersion, Object data) throws Exception { | |
19 | return null; | |
20 | } | |
21 | }; | |
22 | } catch (Exception e) { | |
23 | } | |
24 | } | |
25 | ||
db31c358 NR |
26 | private SerialTest() { |
27 | super("Serial test", null); | |
28 | } | |
29 | ||
08a58812 NR |
30 | private TestCase[] createServerTestCases(final boolean ssl) { |
31 | final String ssls = (ssl ? "(ssl)" : "(plain text)"); | |
32 | return new TestCase[] { | |
33 | new TestCase("Client/Server simple connection " + ssls) { | |
34 | @Override | |
35 | public void test() throws Exception { | |
36 | final Object[] rec = new Object[1]; | |
37 | ||
38 | Server server = new Server("testy", 0, ssl) { | |
39 | @Override | |
40 | protected Object onRequest( | |
41 | ConnectActionServer action, | |
42 | Version clientVersion, Object data) | |
43 | throws Exception { | |
44 | return null; | |
45 | } | |
46 | }; | |
47 | ||
48 | assertEquals("A port should have been assigned", true, | |
49 | server.getPort() > 0); | |
50 | ||
51 | server.start(); | |
52 | ||
53 | try { | |
54 | new ConnectActionClient(null, server.getPort(), ssl) { | |
55 | @Override | |
56 | public void action(Version serverVersion) | |
57 | throws Exception { | |
58 | rec[0] = true; | |
59 | } | |
60 | }.connect(); | |
61 | } finally { | |
62 | server.stop(); | |
63 | } | |
64 | ||
65 | assertNotNull("The client action was not run", rec[0]); | |
66 | assertEquals(true, (boolean) ((Boolean) rec[0])); | |
67 | } | |
68 | }, // | |
69 | new TestCase("Client/Server simple exchange " + ssls) { | |
70 | final Object[] rec = new Object[3]; | |
71 | ||
72 | @Override | |
73 | public void test() throws Exception { | |
74 | Server server = new Server("testy", 0, ssl) { | |
75 | @Override | |
76 | protected Object onRequest( | |
77 | ConnectActionServer action, | |
78 | Version clientVersion, Object data) | |
79 | throws Exception { | |
80 | rec[0] = data; | |
81 | return "pong"; | |
82 | } | |
83 | ||
84 | @Override | |
85 | protected void onError(Exception e) { | |
86 | super.onError(e); | |
87 | rec[2] = e; | |
88 | } | |
89 | }; | |
90 | ||
91 | assertEquals("A port should have been assigned", true, | |
92 | server.getPort() > 0); | |
93 | ||
94 | server.start(); | |
95 | ||
96 | try { | |
97 | new ConnectActionClient(null, server.getPort(), ssl) { | |
98 | @Override | |
99 | public void action(Version serverVersion) | |
100 | throws Exception { | |
101 | rec[1] = send("ping"); | |
102 | } | |
103 | }.connect(); | |
104 | } finally { | |
105 | server.stop(); | |
106 | } | |
107 | ||
108 | if (rec[2] != null) { | |
109 | fail("An exception was thrown: " | |
110 | + ((Exception) rec[2]).getMessage()); | |
111 | } | |
112 | ||
113 | assertEquals("ping", rec[0]); | |
114 | assertEquals("pong", rec[1]); | |
115 | } | |
116 | }, // | |
117 | new TestCase("Client/Server multiple exchanges " + ssls) { | |
118 | final Object[] sent = new Object[3]; | |
119 | final Object[] recd = new Object[3]; | |
120 | final Exception[] err = new Exception[1]; | |
121 | ||
122 | @Override | |
123 | public void test() throws Exception { | |
124 | Server server = new Server("testy", 0, ssl) { | |
125 | @Override | |
126 | protected Object onRequest( | |
127 | ConnectActionServer action, | |
128 | Version clientVersion, Object data) | |
129 | throws Exception { | |
130 | sent[0] = data; | |
131 | action.send("pong"); | |
132 | sent[1] = action.flush(); | |
133 | return "pong2"; | |
134 | } | |
135 | ||
136 | @Override | |
137 | protected void onError(Exception e) { | |
138 | super.onError(e); | |
139 | err[0] = e; | |
140 | } | |
141 | }; | |
142 | ||
143 | server.start(); | |
144 | ||
145 | try { | |
146 | new ConnectActionClient(null, server.getPort(), ssl) { | |
147 | @Override | |
148 | public void action(Version serverVersion) | |
149 | throws Exception { | |
150 | recd[0] = send("ping"); | |
151 | recd[1] = send("ping2"); | |
152 | } | |
153 | }.connect(); | |
154 | } finally { | |
155 | server.stop(); | |
156 | } | |
157 | ||
158 | if (err[0] != null) { | |
159 | fail("An exception was thrown: " | |
160 | + err[0].getMessage()); | |
161 | } | |
162 | ||
163 | assertEquals("ping", sent[0]); | |
164 | assertEquals("pong", recd[0]); | |
165 | assertEquals("ping2", sent[1]); | |
166 | assertEquals("pong2", recd[1]); | |
167 | } | |
168 | }, // | |
169 | new TestCase("Client/Server multiple call from client " + ssls) { | |
170 | final Object[] sent = new Object[3]; | |
171 | final Object[] recd = new Object[3]; | |
172 | final Exception[] err = new Exception[1]; | |
173 | ||
174 | @Override | |
175 | public void test() throws Exception { | |
176 | Server server = new Server("testy", 0, ssl) { | |
177 | @Override | |
178 | protected Object onRequest( | |
179 | ConnectActionServer action, | |
180 | Version clientVersion, Object data) | |
181 | throws Exception { | |
182 | sent[(Integer) data] = data; | |
183 | return ((Integer) data) * 2; | |
184 | } | |
185 | ||
186 | @Override | |
187 | protected void onError(Exception e) { | |
188 | super.onError(e); | |
189 | err[0] = e; | |
190 | } | |
191 | }; | |
192 | ||
193 | server.start(); | |
194 | ||
195 | try { | |
196 | new ConnectActionClient(null, server.getPort(), ssl) { | |
197 | @Override | |
198 | public void action(Version serverVersion) | |
199 | throws Exception { | |
200 | for (int i = 0; i < 3; i++) { | |
201 | recd[i] = send(i); | |
202 | } | |
203 | } | |
204 | }.connect(); | |
205 | } finally { | |
206 | server.stop(); | |
207 | } | |
208 | ||
209 | if (err[0] != null) { | |
210 | fail("An exception was thrown: " | |
211 | + err[0].getMessage()); | |
212 | } | |
213 | ||
214 | assertEquals(0, sent[0]); | |
215 | assertEquals(0, recd[0]); | |
216 | assertEquals(1, sent[1]); | |
217 | assertEquals(2, recd[1]); | |
218 | assertEquals(2, sent[2]); | |
219 | assertEquals(4, recd[2]); | |
220 | } | |
221 | }, // | |
222 | }; | |
223 | } | |
224 | ||
db31c358 NR |
225 | public SerialTest(String[] args) { |
226 | super("Serial test", args); | |
227 | ||
08a58812 NR |
228 | for (TestCase test : createServerTestCases(false)) { |
229 | addTest(test); | |
230 | } | |
231 | ||
232 | for (TestCase test : createServerTestCases(true)) { | |
233 | addTest(test); | |
234 | } | |
235 | ||
db31c358 NR |
236 | addTest(new TestCase("Simple class Import/Export") { |
237 | @Override | |
238 | public void test() throws Exception { | |
239 | Data data = new Data(42); | |
240 | String encoded = new Exporter().append(data).toString(false); | |
241 | Object redata = new Importer().read(encoded).getValue(); | |
242 | String reencoded = new Exporter().append(redata) | |
243 | .toString(false); | |
244 | ||
245 | assertEquals(encoded.replaceAll("@[0-9]*", "@REF"), | |
246 | reencoded.replaceAll("@[0-9]*", "@REF")); | |
247 | } | |
248 | }); | |
249 | ||
250 | addTest(new TestCase("Import/Export with nested objects") { | |
251 | @Override | |
252 | public void test() throws Exception { | |
253 | Data data = new DataObject(new Data(21)); | |
254 | String encoded = new Exporter().append(data).toString(false); | |
255 | Object redata = new Importer().read(encoded).getValue(); | |
256 | String reencoded = new Exporter().append(redata) | |
257 | .toString(false); | |
258 | ||
259 | assertEquals(encoded.replaceAll("@[0-9]*", "@REF"), | |
260 | reencoded.replaceAll("@[0-9]*", "@REF")); | |
261 | } | |
262 | }); | |
263 | ||
264 | addTest(new TestCase("Import/Export with nested objects forming a loop") { | |
265 | @Override | |
266 | public void test() throws Exception { | |
267 | DataLoop data = new DataLoop("looping"); | |
268 | data.next = new DataLoop("level 2"); | |
269 | data.next.next = data; | |
270 | ||
271 | String encoded = new Exporter().append(data).toString(false); | |
272 | Object redata = new Importer().read(encoded).getValue(); | |
273 | String reencoded = new Exporter().append(redata) | |
274 | .toString(false); | |
275 | ||
276 | assertEquals(encoded.replaceAll("@[0-9]*", "@REF"), | |
277 | reencoded.replaceAll("@[0-9]*", "@REF")); | |
278 | } | |
279 | }); | |
ce0974c4 NR |
280 | |
281 | addTest(new TestCase("Array in Object Import/Export") { | |
282 | @Override | |
283 | public void test() throws Exception { | |
284 | Object data = new DataArray();// new String[] { "un", "deux" }; | |
285 | String encoded = new Exporter().append(data).toString(false); | |
286 | Object redata = new Importer().read(encoded).getValue(); | |
287 | String reencoded = new Exporter().append(redata) | |
288 | .toString(false); | |
289 | ||
290 | assertEquals(encoded.replaceAll("@[0-9]*", "@REF"), | |
291 | reencoded.replaceAll("@[0-9]*", "@REF")); | |
292 | } | |
293 | }); | |
294 | ||
295 | addTest(new TestCase("Array Import/Export") { | |
296 | @Override | |
297 | public void test() throws Exception { | |
298 | Object data = new String[] { "un", "deux" }; | |
299 | String encoded = new Exporter().append(data).toString(false); | |
300 | Object redata = new Importer().read(encoded).getValue(); | |
301 | String reencoded = new Exporter().append(redata) | |
302 | .toString(false); | |
303 | ||
304 | assertEquals(encoded.replaceAll("@[0-9]*", "@REF"), | |
305 | reencoded.replaceAll("@[0-9]*", "@REF")); | |
306 | } | |
307 | }); | |
e570f7eb NR |
308 | |
309 | addTest(new TestCase("Enum Import/Export") { | |
310 | @Override | |
311 | public void test() throws Exception { | |
312 | Object data = EnumToSend.FANFAN; | |
313 | String encoded = new Exporter().append(data).toString(false); | |
314 | Object redata = new Importer().read(encoded).getValue(); | |
315 | String reencoded = new Exporter().append(redata) | |
316 | .toString(false); | |
317 | ||
318 | assertEquals(encoded.replaceAll("@[0-9]*", "@REF"), | |
319 | reencoded.replaceAll("@[0-9]*", "@REF")); | |
320 | } | |
321 | }); | |
ce0974c4 NR |
322 | } |
323 | ||
324 | class DataArray { | |
325 | public String[] data = new String[] { "un", "deux" }; | |
db31c358 NR |
326 | } |
327 | ||
328 | @SuppressWarnings("unused") | |
329 | class Data { | |
330 | private int value; | |
331 | ||
332 | private Data() { | |
333 | } | |
334 | ||
335 | public Data(int value) { | |
336 | this.value = value; | |
337 | } | |
338 | } | |
339 | ||
340 | @SuppressWarnings("unused") | |
341 | class DataObject extends Data { | |
342 | private Data data; | |
343 | ||
344 | @SuppressWarnings("synthetic-access") | |
345 | private DataObject() { | |
346 | } | |
347 | ||
348 | @SuppressWarnings("synthetic-access") | |
349 | public DataObject(Data data) { | |
350 | this.data = data; | |
351 | } | |
352 | } | |
353 | ||
354 | @SuppressWarnings("unused") | |
355 | class DataLoop extends Data { | |
356 | public DataLoop next; | |
357 | private String value; | |
358 | ||
359 | @SuppressWarnings("synthetic-access") | |
360 | private DataLoop() { | |
361 | } | |
362 | ||
363 | @SuppressWarnings("synthetic-access") | |
364 | public DataLoop(String value) { | |
365 | this.value = value; | |
366 | } | |
367 | } | |
e570f7eb NR |
368 | |
369 | enum EnumToSend { | |
370 | FANFAN, TULIPE, | |
371 | } | |
db31c358 | 372 | } |