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

package be.nikiroo.utils.test_code;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.NotSerializableException;
import java.net.URL;
import java.util.Arrays;

import be.nikiroo.utils.serial.Exporter;
import be.nikiroo.utils.serial.Importer;
import be.nikiroo.utils.test.TestCase;
import be.nikiroo.utils.test.TestLauncher;

class SerialTest extends TestLauncher {
	/**
	 * Required for Import/Export of objects.
	 */
	public SerialTest() {
		this(null);
	}

	// try to remove pointer addresses
	private byte[] toBytes(Object data) throws NotSerializableException,
			IOException {
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		new Exporter(out).append(data);
		out.flush();
		String tmp = new String(out.toByteArray(), "UTF-8");
		tmp = tmp.replaceAll("@[0-9]*", "@REF");
		return tmp.getBytes("UTF-8");
	}

	private Object fromBytes(byte[] data) throws NoSuchFieldException,
			NoSuchMethodException, ClassNotFoundException,
			NullPointerException, IOException {

		InputStream in = new ByteArrayInputStream(data);
		try {
			return new Importer().read(in).getValue();
		} finally {
			in.close();
		}
	}

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

		addTest(new TestCase("Simple class Import/Export") {
			@Override
			public void test() throws Exception {
				Data data = new Data(42);

				byte[] encoded = toBytes(data);
				Object redata = fromBytes(encoded);
				byte[] reencoded = toBytes(redata);

				assertEquals("Different data after encode/decode/encode", true,
						Arrays.equals(encoded, reencoded));
			}
		});
		/*
		 * addTest(new TestCase() {
		 * 
		 * @SuppressWarnings("unused") private TestCase me =
		 * setName("Anonymous inner class");
		 * 
		 * @Override public void test() throws Exception { Data data = new
		 * Data() {
		 * 
		 * @SuppressWarnings("unused") int value = 42; };
		 * 
		 * String encoded = new Exporter().append(data).toString(false, false);
		 * Object redata = new Importer().read(encoded).getValue(); String
		 * reencoded = new Exporter().append(redata).toString( false, false);
		 * 
		 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
		 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
		 * 
		 * addTest(new TestCase() {
		 * 
		 * @SuppressWarnings("unused") private TestCase me =
		 * setName("Array of anonymous inner classes");
		 * 
		 * @Override public void test() throws Exception { Data[] data = new
		 * Data[] { new Data() {
		 * 
		 * @SuppressWarnings("unused") int value = 42; } };
		 * 
		 * String encoded = new Exporter().append(data).toString(false, false);
		 * Object redata = new Importer().read(encoded).getValue(); String
		 * reencoded = new Exporter().append(redata).toString( false, false);
		 * 
		 * // Comparing the 2 strings won't be useful, because the @REFs // will
		 * be ZIP-encoded; so we parse and re-encode the object encoded = new
		 * Exporter().append(data[0]).toString(false, false); try { reencoded =
		 * new Exporter().append(((Data[]) redata)[0]) .toString(false, false);
		 * } catch (Exception e) {
		 * fail("Cannot cast the returned data into its original object", e); }
		 * 
		 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
		 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
		 * 
		 * addTest(new TestCase("URL Import/Export") {
		 * 
		 * @Override public void test() throws Exception { URL data = new
		 * URL("https://fanfan.be/"); String encoded = new
		 * Exporter().append(data).toString(false, false); Object redata = new
		 * Importer().read(encoded).getValue(); String reencoded = new
		 * Exporter().append(redata).toString( false, false);
		 * 
		 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
		 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
		 * 
		 * addTest(new TestCase("URL-String Import/Export") {
		 * 
		 * @Override public void test() throws Exception { String data = new
		 * URL("https://fanfan.be/").toString(); String encoded = new
		 * Exporter().append(data).toString(false, false); Object redata = new
		 * Importer().read(encoded).getValue(); String reencoded = new
		 * Exporter().append(redata).toString( false, false);
		 * 
		 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
		 * reencoded.replaceAll("@[0-9]*", "@REF")); assertEquals(data, redata);
		 * } });
		 * 
		 * addTest(new TestCase("URL/URL-String arrays Import/Export") {
		 * 
		 * @Override public void test() throws Exception { final String url =
		 * "https://fanfan.be/";
		 * 
		 * Object[] data = new Object[] { new URL(url), url }; String encoded =
		 * new Exporter().append(data).toString(false, false); Object redata =
		 * new Importer().read(encoded).getValue(); String reencoded = new
		 * Exporter().append(redata).toString( false, false);
		 * 
		 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
		 * reencoded.replaceAll("@[0-9]*", "@REF")); assertEquals(data[0],
		 * ((Object[]) redata)[0]); assertEquals(data[1], ((Object[])
		 * redata)[1]); } });
		 * 
		 * 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, false); Object redata = new
		 * Importer().read(encoded).getValue(); String reencoded = new
		 * Exporter().append(redata).toString( false, 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, false);
		 * Object redata = new Importer().read(encoded).getValue(); String
		 * reencoded = new Exporter().append(redata).toString( false, 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, false); Object redata = new
		 * Importer().read(encoded).getValue(); String reencoded = new
		 * Exporter().append(redata).toString( false, 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, false); Object redata = new
		 * Importer().read(encoded).getValue(); String reencoded = new
		 * Exporter().append(redata).toString( false, 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, false); Object redata = new
		 * Importer().read(encoded).getValue(); String reencoded = new
		 * Exporter().append(redata).toString( false, false);
		 * 
		 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
		 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
		 * 
		 * addTest(new TestCase("B64 and ZIP String test") {
		 * 
		 * @Override public void test() throws Exception { Object data =
		 * "Fanfan la tulipe"; String encoded = new
		 * Exporter().append(data).toString(true, false); String redata =
		 * (String) new Importer().read(encoded) .getValue();
		 * 
		 * assertEquals("Items not identical after B64", data, redata);
		 * 
		 * encoded = new Exporter().append(data).toString(true, true); redata =
		 * (String) new Importer().read(encoded).getValue();
		 * 
		 * assertEquals("Items not identical after ZIP", data, redata); } });
		 * 
		 * addTest(new TestCase("B64 and ZIP Data test") {
		 * 
		 * @Override public void test() throws Exception { Object data = new
		 * Data(55); String encoded = new Exporter().append(data).toString(true,
		 * false); Data redata = (Data) new Importer().read(encoded).getValue();
		 * 
		 * assertEquals("Items not identical after B64", data, redata);
		 * 
		 * encoded = new Exporter().append(data).toString(true, true); redata =
		 * (Data) new Importer().read(encoded).getValue();
		 * 
		 * assertEquals("Items not identical after ZIP", data, redata); } });
		 * 
		 * addTest(new TestCase("B64 and ZIP 70000 chars test") {
		 * 
		 * @Override public void test() throws Exception { StringBuilder builder
		 * = new StringBuilder(); for (int i = 0; i < 7000; i++) {
		 * builder.append("0123456789"); }
		 * 
		 * Object data = builder.toString(); String encoded = new
		 * Exporter().append(data).toString(true, false); String redata =
		 * (String) new Importer().read(encoded) .getValue();
		 * 
		 * assertEquals("Items not identical after B64", data, redata);
		 * 
		 * encoded = new Exporter().append(data).toString(true, true); redata =
		 * (String) new Importer().read(encoded).getValue();
		 * 
		 * assertEquals("Items not identical after ZIP", data, redata); } });
		 */
	}

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

	class Data {
		private int value;

		private Data() {
		}

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

		@Override
		public boolean equals(Object obj) {
			if (obj instanceof Data) {
				Data other = (Data) obj;
				return other.value == this.value;
			}

			return false;
		}

		@Override
		public int hashCode() {
			return new Integer(value).hashCode();
		}
	}

	@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
fbcc2a2a	1	package be.nikiroo.utils.test_code;
db31c358	2
564bbbdb NR	3	import java.io.ByteArrayInputStream;
	4	import java.io.ByteArrayOutputStream;
	5	import java.io.IOException;
	6	import java.io.InputStream;
	7	import java.io.NotSerializableException;
f4053377	8	import java.net.URL;
564bbbdb	9	import java.util.Arrays;
f4053377	10
db31c358 NR	11	import be.nikiroo.utils.serial.Exporter;
db31c358 NR	12	import be.nikiroo.utils.serial.Importer;
fbcc2a2a NR	13	import be.nikiroo.utils.test.TestCase;
fbcc2a2a NR	14	import be.nikiroo.utils.test.TestLauncher;
db31c358 NR	15
db31c358 NR	16	class SerialTest extends TestLauncher {
452f38c8 NR	17	/**
	18	* Required for Import/Export of objects.
	19	*/
	20	public SerialTest() {
	21	this(null);
	22	}
	23
564bbbdb NR	24	// try to remove pointer addresses
	25	private byte[] toBytes(Object data) throws NotSerializableException,
	26	IOException {
	27	ByteArrayOutputStream out = new ByteArrayOutputStream();
	28	new Exporter(out).append(data);
	29	out.flush();
	30	String tmp = new String(out.toByteArray(), "UTF-8");
	31	tmp = tmp.replaceAll("@[0-9]*", "@REF");
	32	return tmp.getBytes("UTF-8");
	33	}
	34
	35	private Object fromBytes(byte[] data) throws NoSuchFieldException,
	36	NoSuchMethodException, ClassNotFoundException,
	37	NullPointerException, IOException {
	38
	39	InputStream in = new ByteArrayInputStream(data);
	40	try {
	41	return new Importer().read(in).getValue();
	42	} finally {
	43	in.close();
	44	}
	45	}
	46
db31c358 NR	47	public SerialTest(String[] args) {
	48	super("Serial test", args);
	49
	50	addTest(new TestCase("Simple class Import/Export") {
	51	@Override
	52	public void test() throws Exception {
	53	Data data = new Data(42);
3f277541	54
564bbbdb NR	55	byte[] encoded = toBytes(data);
	56	Object redata = fromBytes(encoded);
	57	byte[] reencoded = toBytes(redata);
3f277541	58
564bbbdb NR	59	assertEquals("Different data after encode/decode/encode", true,
564bbbdb NR	60	Arrays.equals(encoded, reencoded));
3f277541 NR	61	}
3f277541 NR	62	});
564bbbdb NR	63	/*
	64	* addTest(new TestCase() {
	65	*
	66	* @SuppressWarnings("unused") private TestCase me =
	67	* setName("Anonymous inner class");
	68	*
	69	* @Override public void test() throws Exception { Data data = new
	70	* Data() {
	71	*
	72	* @SuppressWarnings("unused") int value = 42; };
	73	*
	74	* String encoded = new Exporter().append(data).toString(false, false);
	75	* Object redata = new Importer().read(encoded).getValue(); String
	76	* reencoded = new Exporter().append(redata).toString( false, false);
	77	*
	78	* assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
	79	* reencoded.replaceAll("@[0-9]*", "@REF")); } });
	80	*
	81	* addTest(new TestCase() {
	82	*
	83	* @SuppressWarnings("unused") private TestCase me =
	84	* setName("Array of anonymous inner classes");
	85	*
	86	* @Override public void test() throws Exception { Data[] data = new
	87	* Data[] { new Data() {
	88	*
	89	* @SuppressWarnings("unused") int value = 42; } };
	90	*
	91	* String encoded = new Exporter().append(data).toString(false, false);
	92	* Object redata = new Importer().read(encoded).getValue(); String
	93	* reencoded = new Exporter().append(redata).toString( false, false);
	94	*
	95	* // Comparing the 2 strings won't be useful, because the @REFs // will
	96	* be ZIP-encoded; so we parse and re-encode the object encoded = new
	97	* Exporter().append(data[0]).toString(false, false); try { reencoded =
	98	* new Exporter().append(((Data[]) redata)[0]) .toString(false, false);
	99	* } catch (Exception e) {
	100	* fail("Cannot cast the returned data into its original object", e); }
	101	*
	102	* assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
	103	* reencoded.replaceAll("@[0-9]*", "@REF")); } });
	104	*
	105	* addTest(new TestCase("URL Import/Export") {
	106	*
	107	* @Override public void test() throws Exception { URL data = new
	108	* URL("https://fanfan.be/"); String encoded = new
	109	* Exporter().append(data).toString(false, false); Object redata = new
	110	* Importer().read(encoded).getValue(); String reencoded = new
	111	* Exporter().append(redata).toString( false, false);
	112	*
	113	* assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
	114	* reencoded.replaceAll("@[0-9]*", "@REF")); } });
	115	*
	116	* addTest(new TestCase("URL-String Import/Export") {
	117	*
	118	* @Override public void test() throws Exception { String data = new
	119	* URL("https://fanfan.be/").toString(); String encoded = new
	120	* Exporter().append(data).toString(false, false); Object redata = new
	121	* Importer().read(encoded).getValue(); String reencoded = new
	122	* Exporter().append(redata).toString( false, false);
	123	*
	124	* assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
	125	* reencoded.replaceAll("@[0-9]*", "@REF")); assertEquals(data, redata);
	126	* } });
127	*
128	* addTest(new TestCase("URL/URL-String arrays Import/Export") {
129	*
130	* @Override public void test() throws Exception { final String url =
131	* "https://fanfan.be/";
132	*
133	* Object[] data = new Object[] { new URL(url), url }; String encoded =
134	* new Exporter().append(data).toString(false, false); Object redata =
135	* new Importer().read(encoded).getValue(); String reencoded = new
136	* Exporter().append(redata).toString( false, false);
137	*
138	* assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
139	* reencoded.replaceAll("@[0-9]*", "@REF")); assertEquals(data[0],
140	* ((Object[]) redata)[0]); assertEquals(data[1], ((Object[])
141	* redata)[1]); } });
142	*
143	* addTest(new TestCase("Import/Export with nested objects") {
144	*
145	* @Override public void test() throws Exception { Data data = new
146	* DataObject(new Data(21)); String encoded = new
147	* Exporter().append(data).toString(false, false); Object redata = new
148	* Importer().read(encoded).getValue(); String reencoded = new
149	* Exporter().append(redata).toString( false, false);
150	*
151	* assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
152	* reencoded.replaceAll("@[0-9]*", "@REF")); } });
153	*
154	* addTest(new
155	* TestCase("Import/Export with nested objects forming a loop") {
156	*
157	* @Override public void test() throws Exception { DataLoop data = new
158	* DataLoop("looping"); data.next = new DataLoop("level 2");
159	* data.next.next = data;
160	*
161	* String encoded = new Exporter().append(data).toString(false, false);
162	* Object redata = new Importer().read(encoded).getValue(); String
163	* reencoded = new Exporter().append(redata).toString( false, false);
164	*
165	* assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
166	* reencoded.replaceAll("@[0-9]*", "@REF")); } });
167	*
168	* addTest(new TestCase("Array in Object Import/Export") {
169	*
170	* @Override public void test() throws Exception { Object data = new
171	* DataArray();// new String[] { "un", "deux" }; String encoded = new
172	* Exporter().append(data).toString(false, false); Object redata = new
173	* Importer().read(encoded).getValue(); String reencoded = new
174	* Exporter().append(redata).toString( false, false);
175	*
176	* assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
177	* reencoded.replaceAll("@[0-9]*", "@REF")); } });
178	*
179	* addTest(new TestCase("Array Import/Export") {
180	*
181	* @Override public void test() throws Exception { Object data = new
182	* String[] { "un", "deux" }; String encoded = new
183	* Exporter().append(data).toString(false, false); Object redata = new
184	* Importer().read(encoded).getValue(); String reencoded = new
185	* Exporter().append(redata).toString( false, false);
186	*
187	* assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
188	* reencoded.replaceAll("@[0-9]*", "@REF")); } });
189	*
190	* addTest(new TestCase("Enum Import/Export") {
191	*
192	* @Override public void test() throws Exception { Object data =
193	* EnumToSend.FANFAN; String encoded = new
194	* Exporter().append(data).toString(false, false); Object redata = new
195	* Importer().read(encoded).getValue(); String reencoded = new
196	* Exporter().append(redata).toString( false, false);
197	*
198	* assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
199	* reencoded.replaceAll("@[0-9]*", "@REF")); } });
200	*
201	* addTest(new TestCase("B64 and ZIP String test") {
202	*
203	* @Override public void test() throws Exception { Object data =
204	* "Fanfan la tulipe"; String encoded = new
205	* Exporter().append(data).toString(true, false); String redata =
206	* (String) new Importer().read(encoded) .getValue();
207	*
208	* assertEquals("Items not identical after B64", data, redata);
209	*
210	* encoded = new Exporter().append(data).toString(true, true); redata =
211	* (String) new Importer().read(encoded).getValue();
212	*
213	* assertEquals("Items not identical after ZIP", data, redata); } });
214	*
215	* addTest(new TestCase("B64 and ZIP Data test") {
216	*
217	* @Override public void test() throws Exception { Object data = new
218	* Data(55); String encoded = new Exporter().append(data).toString(true,
219	* false); Data redata = (Data) new Importer().read(encoded).getValue();
220	*
221	* assertEquals("Items not identical after B64", data, redata);
222	*
223	* encoded = new Exporter().append(data).toString(true, true); redata =
224	* (Data) new Importer().read(encoded).getValue();
225	*
226	* assertEquals("Items not identical after ZIP", data, redata); } });
227	*
228	* addTest(new TestCase("B64 and ZIP 70000 chars test") {
229	*
230	* @Override public void test() throws Exception { StringBuilder builder
231	* = new StringBuilder(); for (int i = 0; i < 7000; i++) {
232	* builder.append("0123456789"); }
233	*
234	* Object data = builder.toString(); String encoded = new
235	* Exporter().append(data).toString(true, false); String redata =
236	* (String) new Importer().read(encoded) .getValue();
237	*
238	* assertEquals("Items not identical after B64", data, redata);
239	*
240	* encoded = new Exporter().append(data).toString(true, true); redata =
241	* (String) new Importer().read(encoded).getValue();
242	*
243	* assertEquals("Items not identical after ZIP", data, redata); } });
244	*/
ce0974c4 NR	245	}
	246
	247	class DataArray {
	248	public String[] data = new String[] { "un", "deux" };
db31c358 NR	249	}
db31c358 NR	250
db31c358 NR	251	class Data {
	252	private int value;
	253
	254	private Data() {
	255	}
	256
	257	public Data(int value) {
	258	this.value = value;
	259	}
3f277541 NR	260
	261	@Override
	262	public boolean equals(Object obj) {
	263	if (obj instanceof Data) {
	264	Data other = (Data) obj;
	265	return other.value == this.value;
	266	}
	267
	268	return false;
	269	}
	270
	271	@Override
	272	public int hashCode() {
b6d4ace8	273	return new Integer(value).hashCode();
3f277541	274	}
db31c358 NR	275	}
	276
	277	@SuppressWarnings("unused")
	278	class DataObject extends Data {
	279	private Data data;
	280
	281	@SuppressWarnings("synthetic-access")
	282	private DataObject() {
	283	}
	284
	285	@SuppressWarnings("synthetic-access")
	286	public DataObject(Data data) {
	287	this.data = data;
	288	}
	289	}
	290
	291	@SuppressWarnings("unused")
	292	class DataLoop extends Data {
	293	public DataLoop next;
	294	private String value;
	295
	296	@SuppressWarnings("synthetic-access")
	297	private DataLoop() {
	298	}
	299
	300	@SuppressWarnings("synthetic-access")
	301	public DataLoop(String value) {
	302	this.value = value;
	303	}
	304	}
e570f7eb NR	305
	306	enum EnumToSend {
	307	FANFAN, TULIPE,
	308	}
db31c358	309	}