[fanfix.git] / src / be / nikiroo / utils / test / SerialServerTest.java

package be.nikiroo.utils.test;

import java.net.URL;

import be.nikiroo.utils.Version;
import be.nikiroo.utils.serial.server.ConnectActionClientObject;
import be.nikiroo.utils.serial.server.ConnectActionClientString;
import be.nikiroo.utils.serial.server.ConnectActionServerObject;
import be.nikiroo.utils.serial.server.ConnectActionServerString;
import be.nikiroo.utils.serial.server.ServerBridge;
import be.nikiroo.utils.serial.server.ServerObject;
import be.nikiroo.utils.serial.server.ServerString;

class SerialServerTest extends TestLauncher {
	private TestLauncher createServerStringTestCases(final String[] args,
			final boolean ssl, final boolean bridge) {
		final String ssls = (ssl ? "(ssl)" : "(plain text)");
		final String bridges = (bridge ? " with bridge" : "");
		TestLauncher series = new TestLauncher(
				"ServerString " + ssls + bridges, args);

		series.addTest(new TestCase("Simple connection " + ssls) {
			@Override
			public void test() throws Exception {
				final String[] rec = new String[1];

				ServerString server = new ServerString(this.getName(), 0, ssl) {
					@Override
					protected String onRequest(
							ConnectActionServerString action,
							Version clientVersion, String data)
							throws Exception {
						return null;
					}

					@Override
					protected void onError(Exception e) {
					}
				};

				int port = server.getPort();
				assertEquals("A port should have been assigned", true, port > 0);

				server.start();

				ServerBridge br = null;
				if (bridge) {
					br = new ServerBridge(0, ssl, "", port, ssl);
					br.setTraceHandler(null);

					port = br.getPort();
					assertEquals(
							"A port should have been assigned to the bridge",
							true, port > 0);

					br.start();
				}

				try {
					try {
						new ConnectActionClientObject(null, port, ssl) {
							@Override
							public void action(Version serverVersion)
									throws Exception {
								rec[0] = "ok";
							}
						}.connect();
					} finally {
						server.stop();
					}
				} finally {
					if (br != null) {
						br.stop();
					}
				}

				assertNotNull("The client action was not run", rec[0]);
				assertEquals("ok", rec[0]);
			}
		});

		series.addTest(new TestCase("Simple exchange " + ssls) {
			final String[] sent = new String[1];
			final String[] recd = new String[1];
			final Exception[] err = new Exception[1];

			@Override
			public void test() throws Exception {
				ServerString server = new ServerString(this.getName(), 0, ssl) {
					@Override
					protected String onRequest(
							ConnectActionServerString action,
							Version clientVersion, String data)
							throws Exception {
						sent[0] = data;
						return "pong";
					}

					@Override
					protected void onError(Exception e) {
						err[0] = e;
					}
				};

				int port = server.getPort();

				server.start();

				ServerBridge br = null;
				if (bridge) {
					br = new ServerBridge(0, ssl, "", port, ssl);
					br.setTraceHandler(null);
					port = br.getPort();
					br.start();
				}

				try {
					try {
						new ConnectActionClientString(null, port, ssl) {
							@Override
							public void action(Version serverVersion)
									throws Exception {
								recd[0] = send("ping");
							}
						}.connect();
					} finally {
						server.stop();
					}
				} finally {
					if (br != null) {
						br.stop();
					}
				}

				if (err[0] != null) {
					fail("An exception was thrown: " + err[0].getMessage());
				}

				assertEquals("ping", sent[0]);
				assertEquals("pong", recd[0]);
			}
		});

		series.addTest(new TestCase("Multiple exchanges " + ssls) {
			final String[] sent = new String[3];
			final String[] recd = new String[3];
			final Exception[] err = new Exception[1];

			@Override
			public void test() throws Exception {
				ServerString server = new ServerString(this.getName(), 0, ssl) {
					@Override
					protected String onRequest(
							ConnectActionServerString action,
							Version clientVersion, String data)
							throws Exception {
						sent[0] = data;
						action.send("pong");
						sent[1] = action.rec();
						return "pong2";
					}

					@Override
					protected void onError(Exception e) {
						err[0] = e;
					}
				};

				int port = server.getPort();

				server.start();

				ServerBridge br = null;
				if (bridge) {
					br = new ServerBridge(0, ssl, "", port, ssl);
					br.setTraceHandler(null);
					port = br.getPort();
					br.start();
				}

				try {
					try {
						new ConnectActionClientString(null, port, ssl) {
							@Override
							public void action(Version serverVersion)
									throws Exception {
								recd[0] = send("ping");
								recd[1] = send("ping2");
							}
						}.connect();
					} finally {
						server.stop();
					}
				} finally {
					if (br != null) {
						br.stop();
					}
				}

				if (err[0] != null) {
					fail("An exception was thrown: " + err[0].getMessage());
				}

				assertEquals("ping", sent[0]);
				assertEquals("pong", recd[0]);
				assertEquals("ping2", sent[1]);
				assertEquals("pong2", recd[1]);
			}
		});

		series.addTest(new TestCase("Multiple call from client " + ssls) {
			final String[] sent = new String[3];
			final String[] recd = new String[3];
			final Exception[] err = new Exception[1];

			@Override
			public void test() throws Exception {
				ServerString server = new ServerString(this.getName(), 0, ssl) {
					@Override
					protected String onRequest(
							ConnectActionServerString action,
							Version clientVersion, String data)
							throws Exception {
						sent[Integer.parseInt(data)] = data;
						return "" + (Integer.parseInt(data) * 2);
					}

					@Override
					protected void onError(Exception e) {
						err[0] = e;
					}
				};

				int port = server.getPort();

				server.start();

				ServerBridge br = null;
				if (bridge) {
					br = new ServerBridge(0, ssl, "", port, ssl);
					br.setTraceHandler(null);
					port = br.getPort();
					br.start();
				}

				try {
					try {
						new ConnectActionClientString(null, port, ssl) {
							@Override
							public void action(Version serverVersion)
									throws Exception {
								for (int i = 0; i < 3; i++) {
									recd[i] = send("" + i);
								}
							}
						}.connect();
					} finally {
						server.stop();
					}
				} finally {
					if (br != null) {
						br.stop();
					}
				}

				if (err[0] != null) {
					fail("An exception was thrown: " + err[0].getMessage());
				}

				assertEquals("0", sent[0]);
				assertEquals("0", recd[0]);
				assertEquals("1", sent[1]);
				assertEquals("2", recd[1]);
				assertEquals("2", sent[2]);
				assertEquals("4", recd[2]);
			}
		});

		return series;
	}

	private TestLauncher createServerObjectTestCases(final String[] args,
			final boolean ssl, final boolean bridge) {
		final String ssls = (ssl ? "(ssl)" : "(plain text)");
		final String bridges = (bridge ? " with bridge" : "");
		TestLauncher series = new TestLauncher(
				"ServerObject " + ssls + bridges, args);

		series.addTest(new TestCase("Simple connection " + ssls) {
			@Override
			public void test() throws Exception {
				final Object[] rec = new Object[1];

				ServerObject server = new ServerObject(this.getName(), 0, ssl) {
					@Override
					protected Object onRequest(
							ConnectActionServerObject action,
							Version clientVersion, Object data)
							throws Exception {
						return null;
					}

					@Override
					protected void onError(Exception e) {
					}
				};

				int port = server.getPort();
				assertEquals("A port should have been assigned", true, port > 0);

				server.start();

				ServerBridge br = null;
				if (bridge) {
					br = new ServerBridge(0, ssl, "", port, ssl);
					br.setTraceHandler(null);
					port = br.getPort();
					br.start();
				}

				try {
					try {
						new ConnectActionClientObject(null, port, ssl) {
							@Override
							public void action(Version serverVersion)
									throws Exception {
								rec[0] = true;
							}

							@Override
							protected void onError(Exception e) {
							}
						}.connect();
					} finally {
						server.stop();
					}
				} finally {
					if (br != null) {
						br.stop();
					}
				}

				assertNotNull("The client action was not run", rec[0]);
				assertEquals(true, (boolean) ((Boolean) rec[0]));
			}
		});

		series.addTest(new TestCase("Simple exchange " + ssls) {
			final Object[] sent = new Object[1];
			final Object[] recd = new Object[1];
			final Exception[] err = new Exception[1];

			@Override
			public void test() throws Exception {
				ServerObject server = new ServerObject(this.getName(), 0, ssl) {
					@Override
					protected Object onRequest(
							ConnectActionServerObject action,
							Version clientVersion, Object data)
							throws Exception {
						sent[0] = data;
						return "pong";
					}

					@Override
					protected void onError(Exception e) {
						err[0] = e;
					}
				};

				int port = server.getPort();

				server.start();

				ServerBridge br = null;
				if (bridge) {
					br = new ServerBridge(0, ssl, "", port, ssl);
					br.setTraceHandler(null);
					port = br.getPort();
					br.start();
				}

				try {
					try {
						new ConnectActionClientObject(null, port, ssl) {
							@Override
							public void action(Version serverVersion)
									throws Exception {
								recd[0] = send("ping");
							}
						}.connect();
					} finally {
						server.stop();
					}
				} finally {
					if (br != null) {
						br.stop();
					}
				}

				if (err[0] != null) {
					fail("An exception was thrown: " + err[0].getMessage());
				}

				assertEquals("ping", sent[0]);
				assertEquals("pong", recd[0]);
			}
		});

		series.addTest(new TestCase("Multiple exchanges " + ssls) {
			final Object[] sent = new Object[3];
			final Object[] recd = new Object[3];
			final Exception[] err = new Exception[1];

			@Override
			public void test() throws Exception {
				ServerObject server = new ServerObject(this.getName(), 0, ssl) {
					@Override
					protected Object onRequest(
							ConnectActionServerObject action,
							Version clientVersion, Object data)
							throws Exception {
						sent[0] = data;
						action.send("pong");
						sent[1] = action.rec();
						return "pong2";
					}

					@Override
					protected void onError(Exception e) {
						err[0] = e;
					}
				};

				int port = server.getPort();

				server.start();

				ServerBridge br = null;
				if (bridge) {
					br = new ServerBridge(0, ssl, "", port, ssl);
					br.setTraceHandler(null);
					port = br.getPort();
					br.start();
				}

				try {
					try {
						new ConnectActionClientObject(null, port, ssl) {
							@Override
							public void action(Version serverVersion)
									throws Exception {
								recd[0] = send("ping");
								recd[1] = send("ping2");
							}
						}.connect();
					} finally {
						server.stop();
					}
				} finally {
					if (br != null) {
						br.stop();
					}
				}

				if (err[0] != null) {
					fail("An exception was thrown: " + err[0].getMessage());
				}

				assertEquals("ping", sent[0]);
				assertEquals("pong", recd[0]);
				assertEquals("ping2", sent[1]);
				assertEquals("pong2", recd[1]);
			}
		});

		series.addTest(new TestCase("Object array of URLs " + ssls) {
			final Object[] sent = new Object[1];
			final Object[] recd = new Object[1];
			final Exception[] err = new Exception[1];

			@Override
			public void test() throws Exception {
				ServerObject server = new ServerObject(this.getName(), 0, ssl) {
					@Override
					protected Object onRequest(
							ConnectActionServerObject action,
							Version clientVersion, Object data)
							throws Exception {
						sent[0] = data;
						return new Object[] { "ACK" };
					}

					@Override
					protected void onError(Exception e) {
						err[0] = e;
					}
				};

				int port = server.getPort();

				server.start();

				ServerBridge br = null;
				if (bridge) {
					br = new ServerBridge(0, ssl, "", port, ssl);
					br.setTraceHandler(null);
					port = br.getPort();
					br.start();
				}

				try {
					try {
						new ConnectActionClientObject(null, port, ssl) {
							@Override
							public void action(Version serverVersion)
									throws Exception {
								recd[0] = send(new Object[] {
										"key",
										new URL(
												"https://example.com/from_client"),
										"https://example.com/from_client" });
							}
						}.connect();
					} finally {
						server.stop();
					}
				} finally {
					if (br != null) {
						br.stop();
					}
				}

				if (err[0] != null) {
					fail("An exception was thrown: " + err[0].getMessage());
				}

				Object[] sento = (Object[]) (sent[0]);
				Object[] recdo = (Object[]) (recd[0]);

				assertEquals("key", sento[0]);
				assertEquals("https://example.com/from_client",
						((URL) sento[1]).toString());
				assertEquals("https://example.com/from_client", sento[2]);
				assertEquals("ACK", recdo[0]);
			}
		});

		series.addTest(new TestCase("Multiple call from client " + ssls) {
			final Object[] sent = new Object[3];
			final Object[] recd = new Object[3];
			final Exception[] err = new Exception[1];

			@Override
			public void test() throws Exception {
				ServerObject server = new ServerObject(this.getName(), 0, ssl) {
					@Override
					protected Object onRequest(
							ConnectActionServerObject action,
							Version clientVersion, Object data)
							throws Exception {
						sent[(Integer) data] = data;
						return ((Integer) data) * 2;
					}

					@Override
					protected void onError(Exception e) {
						err[0] = e;
					}
				};

				int port = server.getPort();

				server.start();

				ServerBridge br = null;
				if (bridge) {
					br = new ServerBridge(0, ssl, "", port, ssl);
					br.setTraceHandler(null);
					port = br.getPort();
					br.start();
				}

				try {
					try {
						new ConnectActionClientObject(null, port, ssl) {
							@Override
							public void action(Version serverVersion)
									throws Exception {
								for (int i = 0; i < 3; i++) {
									recd[i] = send(i);
								}
							}
						}.connect();
					} finally {
						server.stop();
					}
				} finally {
					if (br != null) {
						br.stop();
					}
				}

				if (err[0] != null) {
					fail("An exception was thrown: " + err[0].getMessage());
				}

				assertEquals(0, sent[0]);
				assertEquals(0, recd[0]);
				assertEquals(1, sent[1]);
				assertEquals(2, recd[1]);
				assertEquals(2, sent[2]);
				assertEquals(4, recd[2]);
			}
		});

		return series;
	}

	public SerialServerTest(String[] args) {
		super("SerialServer test", args);

		for (boolean ssl : new Boolean[] { false, true }) {
			for (boolean bridge : new Boolean[] { false, true }) {
				addSeries(createServerObjectTestCases(args, ssl, bridge));
				addSeries(createServerStringTestCases(args, ssl, bridge));
			}
		}
	}
}
Commit	Line	Data
	1	package be.nikiroo.utils.test;
	2
	3	import java.net.URL;
	4
	5	import be.nikiroo.utils.Version;
	6	import be.nikiroo.utils.serial.server.ConnectActionClientObject;
	7	import be.nikiroo.utils.serial.server.ConnectActionClientString;
	8	import be.nikiroo.utils.serial.server.ConnectActionServerObject;
	9	import be.nikiroo.utils.serial.server.ConnectActionServerString;
	10	import be.nikiroo.utils.serial.server.ServerBridge;
	11	import be.nikiroo.utils.serial.server.ServerObject;
	12	import be.nikiroo.utils.serial.server.ServerString;
	13
	14	class SerialServerTest extends TestLauncher {
	15	private TestLauncher createServerStringTestCases(final String[] args,
	16	final boolean ssl, final boolean bridge) {
	17	final String ssls = (ssl ? "(ssl)" : "(plain text)");
	18	final String bridges = (bridge ? " with bridge" : "");
	19	TestLauncher series = new TestLauncher(
	20	"ServerString " + ssls + bridges, args);
	21
	22	series.addTest(new TestCase("Simple connection " + ssls) {
	23	@Override
	24	public void test() throws Exception {
	25	final String[] rec = new String[1];
	26
	27	ServerString server = new ServerString(this.getName(), 0, ssl) {
	28	@Override
	29	protected String onRequest(
	30	ConnectActionServerString action,
	31	Version clientVersion, String data)
	32	throws Exception {
	33	return null;
	34	}
	35
	36	@Override
	37	protected void onError(Exception e) {
	38	}
	39	};
	40
	41	int port = server.getPort();
	42	assertEquals("A port should have been assigned", true, port > 0);
	43
	44	server.start();
	45
	46	ServerBridge br = null;
	47	if (bridge) {
	48	br = new ServerBridge(0, ssl, "", port, ssl);
	49	br.setTraceHandler(null);
	50
	51	port = br.getPort();
	52	assertEquals(
	53	"A port should have been assigned to the bridge",
	54	true, port > 0);
	55
	56	br.start();
	57	}
	58
	59	try {
	60	try {
	61	new ConnectActionClientObject(null, port, ssl) {
	62	@Override
	63	public void action(Version serverVersion)
	64	throws Exception {
	65	rec[0] = "ok";
	66	}
	67	}.connect();
	68	} finally {
	69	server.stop();
	70	}
	71	} finally {
	72	if (br != null) {
	73	br.stop();
	74	}
	75	}
	76
	77	assertNotNull("The client action was not run", rec[0]);
	78	assertEquals("ok", rec[0]);
	79	}
	80	});
	81
	82	series.addTest(new TestCase("Simple exchange " + ssls) {
	83	final String[] sent = new String[1];
	84	final String[] recd = new String[1];
	85	final Exception[] err = new Exception[1];
	86
	87	@Override
	88	public void test() throws Exception {
	89	ServerString server = new ServerString(this.getName(), 0, ssl) {
	90	@Override
	91	protected String onRequest(
	92	ConnectActionServerString action,
	93	Version clientVersion, String data)
	94	throws Exception {
	95	sent[0] = data;
	96	return "pong";
	97	}
	98
	99	@Override
	100	protected void onError(Exception e) {
	101	err[0] = e;
	102	}
	103	};
	104
	105	int port = server.getPort();
	106
	107	server.start();
	108
	109	ServerBridge br = null;
	110	if (bridge) {
	111	br = new ServerBridge(0, ssl, "", port, ssl);
	112	br.setTraceHandler(null);
	113	port = br.getPort();
	114	br.start();
	115	}
	116
	117	try {
	118	try {
	119	new ConnectActionClientString(null, port, ssl) {
	120	@Override
	121	public void action(Version serverVersion)
	122	throws Exception {
	123	recd[0] = send("ping");
	124	}
	125	}.connect();
	126	} finally {
	127	server.stop();
	128	}
	129	} finally {
	130	if (br != null) {
	131	br.stop();
	132	}
	133	}
	134
	135	if (err[0] != null) {
	136	fail("An exception was thrown: " + err[0].getMessage());
	137	}
	138
	139	assertEquals("ping", sent[0]);
	140	assertEquals("pong", recd[0]);
	141	}
	142	});
	143
	144	series.addTest(new TestCase("Multiple exchanges " + ssls) {
	145	final String[] sent = new String[3];
	146	final String[] recd = new String[3];
	147	final Exception[] err = new Exception[1];
	148
	149	@Override
	150	public void test() throws Exception {
	151	ServerString server = new ServerString(this.getName(), 0, ssl) {
	152	@Override
	153	protected String onRequest(
	154	ConnectActionServerString action,
	155	Version clientVersion, String data)
	156	throws Exception {
	157	sent[0] = data;
	158	action.send("pong");
	159	sent[1] = action.rec();
	160	return "pong2";
	161	}
	162
	163	@Override
	164	protected void onError(Exception e) {
	165	err[0] = e;
	166	}
	167	};
	168
	169	int port = server.getPort();
	170
	171	server.start();
	172
	173	ServerBridge br = null;
	174	if (bridge) {
	175	br = new ServerBridge(0, ssl, "", port, ssl);
	176	br.setTraceHandler(null);
	177	port = br.getPort();
	178	br.start();
	179	}
	180
	181	try {
	182	try {
	183	new ConnectActionClientString(null, port, ssl) {
	184	@Override
	185	public void action(Version serverVersion)
	186	throws Exception {
	187	recd[0] = send("ping");
	188	recd[1] = send("ping2");
	189	}
	190	}.connect();
	191	} finally {
	192	server.stop();
	193	}
	194	} finally {
	195	if (br != null) {
	196	br.stop();
	197	}
	198	}
	199
	200	if (err[0] != null) {
	201	fail("An exception was thrown: " + err[0].getMessage());
	202	}
	203
	204	assertEquals("ping", sent[0]);
	205	assertEquals("pong", recd[0]);
	206	assertEquals("ping2", sent[1]);
	207	assertEquals("pong2", recd[1]);
	208	}
	209	});
	210
	211	series.addTest(new TestCase("Multiple call from client " + ssls) {
	212	final String[] sent = new String[3];
	213	final String[] recd = new String[3];
	214	final Exception[] err = new Exception[1];
	215
	216	@Override
	217	public void test() throws Exception {
	218	ServerString server = new ServerString(this.getName(), 0, ssl) {
	219	@Override
	220	protected String onRequest(
	221	ConnectActionServerString action,
	222	Version clientVersion, String data)
	223	throws Exception {
	224	sent[Integer.parseInt(data)] = data;
	225	return "" + (Integer.parseInt(data) * 2);
	226	}
	227
	228	@Override
	229	protected void onError(Exception e) {
	230	err[0] = e;
	231	}
	232	};
	233
	234	int port = server.getPort();
	235
	236	server.start();
	237
	238	ServerBridge br = null;
	239	if (bridge) {
	240	br = new ServerBridge(0, ssl, "", port, ssl);
	241	br.setTraceHandler(null);
	242	port = br.getPort();
	243	br.start();
	244	}
	245
	246	try {
	247	try {
	248	new ConnectActionClientString(null, port, ssl) {
	249	@Override
	250	public void action(Version serverVersion)
	251	throws Exception {
	252	for (int i = 0; i < 3; i++) {
	253	recd[i] = send("" + i);
	254	}
	255	}
	256	}.connect();
	257	} finally {
	258	server.stop();
	259	}
	260	} finally {
	261	if (br != null) {
	262	br.stop();
	263	}
	264	}
	265
	266	if (err[0] != null) {
	267	fail("An exception was thrown: " + err[0].getMessage());
	268	}
	269
	270	assertEquals("0", sent[0]);
	271	assertEquals("0", recd[0]);
	272	assertEquals("1", sent[1]);
	273	assertEquals("2", recd[1]);
	274	assertEquals("2", sent[2]);
	275	assertEquals("4", recd[2]);
	276	}
	277	});
	278
	279	return series;
	280	}
	281
	282	private TestLauncher createServerObjectTestCases(final String[] args,
	283	final boolean ssl, final boolean bridge) {
	284	final String ssls = (ssl ? "(ssl)" : "(plain text)");
	285	final String bridges = (bridge ? " with bridge" : "");
	286	TestLauncher series = new TestLauncher(
	287	"ServerObject " + ssls + bridges, args);
	288
	289	series.addTest(new TestCase("Simple connection " + ssls) {
	290	@Override
	291	public void test() throws Exception {
	292	final Object[] rec = new Object[1];
	293
	294	ServerObject server = new ServerObject(this.getName(), 0, ssl) {
	295	@Override
	296	protected Object onRequest(
	297	ConnectActionServerObject action,
	298	Version clientVersion, Object data)
	299	throws Exception {
	300	return null;
	301	}
	302
	303	@Override
	304	protected void onError(Exception e) {
	305	}
	306	};
	307
	308	int port = server.getPort();
	309	assertEquals("A port should have been assigned", true, port > 0);
	310
	311	server.start();
	312
	313	ServerBridge br = null;
	314	if (bridge) {
	315	br = new ServerBridge(0, ssl, "", port, ssl);
	316	br.setTraceHandler(null);
	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	}
	329
	330	@Override
	331	protected void onError(Exception e) {
	332	}
	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	err[0] = e;
	368	}
	369	};
	370
	371	int port = server.getPort();
	372
	373	server.start();
	374
	375	ServerBridge br = null;
	376	if (bridge) {
	377	br = new ServerBridge(0, ssl, "", port, ssl);
	378	br.setTraceHandler(null);
	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	err[0] = e;
	432	}
	433	};
	434
	435	int port = server.getPort();
	436
	437	server.start();
	438
	439	ServerBridge br = null;
	440	if (bridge) {
	441	br = new ServerBridge(0, ssl, "", port, ssl);
	442	br.setTraceHandler(null);
	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("Object array of URLs " + ssls) {
	478	final Object[] sent = new Object[1];
	479	final Object[] recd = new Object[1];
	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[0] = data;
	491	return new Object[] { "ACK" };
	492	}
	493
	494	@Override
	495	protected void onError(Exception e) {
	496	err[0] = e;
	497	}
	498	};
	499
	500	int port = server.getPort();
	501
	502	server.start();
	503
	504	ServerBridge br = null;
	505	if (bridge) {
	506	br = new ServerBridge(0, ssl, "", port, ssl);
	507	br.setTraceHandler(null);
	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	recd[0] = send(new Object[] {
	519	"key",
	520	new URL(
	521	"https://example.com/from_client"),
	522	"https://example.com/from_client" });
	523	}
	524	}.connect();
	525	} finally {
	526	server.stop();
	527	}
	528	} finally {
	529	if (br != null) {
	530	br.stop();
	531	}
	532	}
	533
	534	if (err[0] != null) {
	535	fail("An exception was thrown: " + err[0].getMessage());
	536	}
	537
	538	Object[] sento = (Object[]) (sent[0]);
	539	Object[] recdo = (Object[]) (recd[0]);
	540
	541	assertEquals("key", sento[0]);
	542	assertEquals("https://example.com/from_client",
	543	((URL) sento[1]).toString());
	544	assertEquals("https://example.com/from_client", sento[2]);
	545	assertEquals("ACK", recdo[0]);
	546	}
	547	});
	548
	549	series.addTest(new TestCase("Multiple call from client " + ssls) {
	550	final Object[] sent = new Object[3];
	551	final Object[] recd = new Object[3];
	552	final Exception[] err = new Exception[1];
	553
	554	@Override
	555	public void test() throws Exception {
	556	ServerObject server = new ServerObject(this.getName(), 0, ssl) {
	557	@Override
	558	protected Object onRequest(
	559	ConnectActionServerObject action,
	560	Version clientVersion, Object data)
	561	throws Exception {
	562	sent[(Integer) data] = data;
	563	return ((Integer) data) * 2;
	564	}
	565
	566	@Override
	567	protected void onError(Exception e) {
	568	err[0] = e;
	569	}
	570	};
	571
	572	int port = server.getPort();
	573
	574	server.start();
	575
	576	ServerBridge br = null;
	577	if (bridge) {
	578	br = new ServerBridge(0, ssl, "", port, ssl);
	579	br.setTraceHandler(null);
	580	port = br.getPort();
	581	br.start();
	582	}
	583
	584	try {
	585	try {
	586	new ConnectActionClientObject(null, port, ssl) {
	587	@Override
	588	public void action(Version serverVersion)
	589	throws Exception {
	590	for (int i = 0; i < 3; i++) {
	591	recd[i] = send(i);
	592	}
	593	}
	594	}.connect();
	595	} finally {
	596	server.stop();
	597	}
	598	} finally {
	599	if (br != null) {
	600	br.stop();
	601	}
	602	}
	603
	604	if (err[0] != null) {
	605	fail("An exception was thrown: " + err[0].getMessage());
	606	}
	607
	608	assertEquals(0, sent[0]);
	609	assertEquals(0, recd[0]);
	610	assertEquals(1, sent[1]);
	611	assertEquals(2, recd[1]);
	612	assertEquals(2, sent[2]);
	613	assertEquals(4, recd[2]);
	614	}
	615	});
	616
	617	return series;
	618	}
	619
	620	public SerialServerTest(String[] args) {
	621	super("SerialServer test", args);
	622
	623	for (boolean ssl : new Boolean[] { false, true }) {
	624	for (boolean bridge : new Boolean[] { false, true }) {
	625	addSeries(createServerObjectTestCases(args, ssl, bridge));
	626	addSeries(createServerStringTestCases(args, ssl, bridge));
	627	}
	628	}
	629	}
	630	}