[nikiroo-utils.git] / src / be / nikiroo / utils / test / SerialTest.java

package be.nikiroo.utils.test;

import be.nikiroo.utils.Version;
import be.nikiroo.utils.serial.ConnectActionClient;
import be.nikiroo.utils.serial.ConnectActionServer;
import be.nikiroo.utils.serial.Exporter;
import be.nikiroo.utils.serial.Importer;
import be.nikiroo.utils.serial.Server;

class SerialTest extends TestLauncher {
	@SuppressWarnings("unused")
	private void not_used() {
		// TODO: test Server ; but this will at least help dependency checking
		try {
			Server server = new Server(0, false) {
				@Override
				protected Object onRequest(ConnectActionServer action,
						Version clientVersion, Object data) throws Exception {
					return null;
				}
			};
		} catch (Exception e) {
		}
	}

	private SerialTest() {
		super("Serial test", null);
	}

	private TestCase[] createServerTestCases(final boolean ssl) {
		final String ssls = (ssl ? "(ssl)" : "(plain text)");
		return new TestCase[] {
				new TestCase("Client/Server simple connection " + ssls) {
					@Override
					public void test() throws Exception {
						final Object[] rec = new Object[1];

						Server server = new Server("testy", 0, ssl) {
							@Override
							protected Object onRequest(
									ConnectActionServer action,
									Version clientVersion, Object data)
									throws Exception {
								return null;
							}
						};

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

						server.start();

						try {
							new ConnectActionClient(null, server.getPort(), ssl) {
								@Override
								public void action(Version serverVersion)
										throws Exception {
									rec[0] = true;
								}
							}.connect();
						} finally {
							server.stop();
						}

						assertNotNull("The client action was not run", rec[0]);
						assertEquals(true, (boolean) ((Boolean) rec[0]));
					}
				}, //
				new TestCase("Client/Server simple exchange " + ssls) {
					final Object[] rec = new Object[3];

					@Override
					public void test() throws Exception {
						Server server = new Server("testy", 0, ssl) {
							@Override
							protected Object onRequest(
									ConnectActionServer action,
									Version clientVersion, Object data)
									throws Exception {
								rec[0] = data;
								return "pong";
							}

							@Override
							protected void onError(Exception e) {
								super.onError(e);
								rec[2] = e;
							}
						};

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

						server.start();

						try {
							new ConnectActionClient(null, server.getPort(), ssl) {
								@Override
								public void action(Version serverVersion)
										throws Exception {
									rec[1] = send("ping");
								}
							}.connect();
						} finally {
							server.stop();
						}

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

						assertEquals("ping", rec[0]);
						assertEquals("pong", rec[1]);
					}
				}, //
				new TestCase("Client/Server 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 {
						Server server = new Server("testy", 0, ssl) {
							@Override
							protected Object onRequest(
									ConnectActionServer action,
									Version clientVersion, Object data)
									throws Exception {
								sent[0] = data;
								action.send("pong");
								sent[1] = action.flush();
								return "pong2";
							}

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

						server.start();

						try {
							new ConnectActionClient(null, server.getPort(), ssl) {
								@Override
								public void action(Version serverVersion)
										throws Exception {
									recd[0] = send("ping");
									recd[1] = send("ping2");
								}
							}.connect();
						} finally {
							server.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]);
					}
				}, //
				new TestCase("Client/Server 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 {
						Server server = new Server("testy", 0, ssl) {
							@Override
							protected Object onRequest(
									ConnectActionServer action,
									Version clientVersion, Object data)
									throws Exception {
								sent[(Integer) data] = data;
								return ((Integer) data) * 2;
							}

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

						server.start();

						try {
							new ConnectActionClient(null, server.getPort(), ssl) {
								@Override
								public void action(Version serverVersion)
										throws Exception {
									for (int i = 0; i < 3; i++) {
										recd[i] = send(i);
									}
								}
							}.connect();
						} finally {
							server.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]);
					}
				}, //
		};
	}

	public SerialTest(String[] args) {
		super("Serial test", args);

		for (TestCase test : createServerTestCases(false)) {
			addTest(test);
		}

		for (TestCase test : createServerTestCases(true)) {
			addTest(test);
		}

		addTest(new TestCase("Simple class Import/Export") {
			@Override
			public void test() throws Exception {
				Data data = new Data(42);
				String encoded = new Exporter().append(data).toString(false);
				Object redata = new Importer().read(encoded).getValue();
				String reencoded = new Exporter().append(redata)
						.toString(false);

				assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
						reencoded.replaceAll("@[0-9]*", "@REF"));
			}
		});

		addTest(new TestCase("Import/Export with nested objects") {
			@Override
			public void test() throws Exception {
				Data data = new DataObject(new Data(21));
				String encoded = new Exporter().append(data).toString(false);
				Object redata = new Importer().read(encoded).getValue();
				String reencoded = new Exporter().append(redata)
						.toString(false);

				assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
						reencoded.replaceAll("@[0-9]*", "@REF"));
			}
		});

		addTest(new TestCase("Import/Export with nested objects forming a loop") {
			@Override
			public void test() throws Exception {
				DataLoop data = new DataLoop("looping");
				data.next = new DataLoop("level 2");
				data.next.next = data;

				String encoded = new Exporter().append(data).toString(false);
				Object redata = new Importer().read(encoded).getValue();
				String reencoded = new Exporter().append(redata)
						.toString(false);

				assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
						reencoded.replaceAll("@[0-9]*", "@REF"));
			}
		});

		addTest(new TestCase("Array in Object Import/Export") {
			@Override
			public void test() throws Exception {
				Object data = new DataArray();// new String[] { "un", "deux" };
				String encoded = new Exporter().append(data).toString(false);
				Object redata = new Importer().read(encoded).getValue();
				String reencoded = new Exporter().append(redata)
						.toString(false);

				assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
						reencoded.replaceAll("@[0-9]*", "@REF"));
			}
		});

		addTest(new TestCase("Array Import/Export") {
			@Override
			public void test() throws Exception {
				Object data = new String[] { "un", "deux" };
				String encoded = new Exporter().append(data).toString(false);
				Object redata = new Importer().read(encoded).getValue();
				String reencoded = new Exporter().append(redata)
						.toString(false);

				assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
						reencoded.replaceAll("@[0-9]*", "@REF"));
			}
		});

		addTest(new TestCase("Enum Import/Export") {
			@Override
			public void test() throws Exception {
				Object data = EnumToSend.FANFAN;
				String encoded = new Exporter().append(data).toString(false);
				Object redata = new Importer().read(encoded).getValue();
				String reencoded = new Exporter().append(redata)
						.toString(false);

				assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
						reencoded.replaceAll("@[0-9]*", "@REF"));
			}
		});
	}

	class DataArray {
		public String[] data = new String[] { "un", "deux" };
	}

	@SuppressWarnings("unused")
	class Data {
		private int value;

		private Data() {
		}

		public Data(int value) {
			this.value = value;
		}
	}

	@SuppressWarnings("unused")
	class DataObject extends Data {
		private Data data;

		@SuppressWarnings("synthetic-access")
		private DataObject() {
		}

		@SuppressWarnings("synthetic-access")
		public DataObject(Data data) {
			this.data = data;
		}
	}

	@SuppressWarnings("unused")
	class DataLoop extends Data {
		public DataLoop next;
		private String value;

		@SuppressWarnings("synthetic-access")
		private DataLoop() {
		}

		@SuppressWarnings("synthetic-access")
		public DataLoop(String value) {
			this.value = value;
		}
	}

	enum EnumToSend {
		FANFAN, TULIPE,
	}
}
Commit	Line	Data
db31c358 NR	1	package be.nikiroo.utils.test;
db31c358 NR	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;
db31c358 NR	7	import be.nikiroo.utils.serial.Importer;
ce0974c4	8	import be.nikiroo.utils.serial.Server;
db31c358 NR	9
db31c358 NR	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	}