1 package be
.nikiroo
.utils
.test_code
;
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
;
9 import java
.util
.Arrays
;
11 import be
.nikiroo
.utils
.serial
.Exporter
;
12 import be
.nikiroo
.utils
.serial
.Importer
;
13 import be
.nikiroo
.utils
.test
.TestCase
;
14 import be
.nikiroo
.utils
.test
.TestLauncher
;
16 class SerialTest
extends TestLauncher
{
18 * Required for Import/Export of objects.
24 // try to remove pointer addresses
25 private byte[] toBytes(Object data
) throws NotSerializableException
,
27 ByteArrayOutputStream out
= new ByteArrayOutputStream();
28 new Exporter(out
).append(data
);
30 String tmp
= new String(out
.toByteArray(), "UTF-8");
31 tmp
= tmp
.replaceAll("@[0-9]*", "@REF");
32 return tmp
.getBytes("UTF-8");
35 private Object
fromBytes(byte[] data
) throws NoSuchFieldException
,
36 NoSuchMethodException
, ClassNotFoundException
,
37 NullPointerException
, IOException
{
39 InputStream in
= new ByteArrayInputStream(data
);
41 return new Importer().read(in
).getValue();
47 public SerialTest(String
[] args
) {
48 super("Serial test", args
);
50 addTest(new TestCase("Simple class Import/Export") {
52 public void test() throws Exception
{
53 Data data
= new Data(42);
55 byte[] encoded
= toBytes(data
);
56 Object redata
= fromBytes(encoded
);
57 byte[] reencoded
= toBytes(redata
);
59 assertEquals("Different data after encode/decode/encode", true,
60 Arrays
.equals(encoded
, reencoded
));
64 * addTest(new TestCase() {
66 * @SuppressWarnings("unused") private TestCase me =
67 * setName("Anonymous inner class");
69 * @Override public void test() throws Exception { Data data = new
72 * @SuppressWarnings("unused") int value = 42; };
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);
78 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
79 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
81 * addTest(new TestCase() {
83 * @SuppressWarnings("unused") private TestCase me =
84 * setName("Array of anonymous inner classes");
86 * @Override public void test() throws Exception { Data[] data = new
87 * Data[] { new Data() {
89 * @SuppressWarnings("unused") int value = 42; } };
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);
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); }
102 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
103 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
105 * addTest(new TestCase("URL Import/Export") {
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);
113 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
114 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
116 * addTest(new TestCase("URL-String Import/Export") {
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);
124 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
125 * reencoded.replaceAll("@[0-9]*", "@REF")); assertEquals(data, redata);
128 * addTest(new TestCase("URL/URL-String arrays Import/Export") {
130 * @Override public void test() throws Exception { final String url =
131 * "https://fanfan.be/";
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);
138 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
139 * reencoded.replaceAll("@[0-9]*", "@REF")); assertEquals(data[0],
140 * ((Object[]) redata)[0]); assertEquals(data[1], ((Object[])
143 * addTest(new TestCase("Import/Export with nested objects") {
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);
151 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
152 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
155 * TestCase("Import/Export with nested objects forming a loop") {
157 * @Override public void test() throws Exception { DataLoop data = new
158 * DataLoop("looping"); data.next = new DataLoop("level 2");
159 * data.next.next = data;
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);
165 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
166 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
168 * addTest(new TestCase("Array in Object Import/Export") {
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);
176 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
177 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
179 * addTest(new TestCase("Array Import/Export") {
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);
187 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
188 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
190 * addTest(new TestCase("Enum Import/Export") {
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);
198 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
199 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
201 * addTest(new TestCase("B64 and ZIP String test") {
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();
208 * assertEquals("Items not identical after B64", data, redata);
210 * encoded = new Exporter().append(data).toString(true, true); redata =
211 * (String) new Importer().read(encoded).getValue();
213 * assertEquals("Items not identical after ZIP", data, redata); } });
215 * addTest(new TestCase("B64 and ZIP Data test") {
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();
221 * assertEquals("Items not identical after B64", data, redata);
223 * encoded = new Exporter().append(data).toString(true, true); redata =
224 * (Data) new Importer().read(encoded).getValue();
226 * assertEquals("Items not identical after ZIP", data, redata); } });
228 * addTest(new TestCase("B64 and ZIP 70000 chars test") {
230 * @Override public void test() throws Exception { StringBuilder builder
231 * = new StringBuilder(); for (int i = 0; i < 7000; i++) {
232 * builder.append("0123456789"); }
234 * Object data = builder.toString(); String encoded = new
235 * Exporter().append(data).toString(true, false); String redata =
236 * (String) new Importer().read(encoded) .getValue();
238 * assertEquals("Items not identical after B64", data, redata);
240 * encoded = new Exporter().append(data).toString(true, true); redata =
241 * (String) new Importer().read(encoded).getValue();
243 * assertEquals("Items not identical after ZIP", data, redata); } });
248 public String
[] data
= new String
[] { "un", "deux" };
257 public Data(int value
) {
262 public boolean equals(Object obj
) {
263 if (obj
instanceof Data
) {
264 Data other
= (Data
) obj
;
265 return other
.value
== this.value
;
272 public int hashCode() {
273 return new Integer(value
).hashCode();
277 @SuppressWarnings("unused")
278 class DataObject
extends Data
{
281 @SuppressWarnings("synthetic-access")
282 private DataObject() {
285 @SuppressWarnings("synthetic-access")
286 public DataObject(Data data
) {
291 @SuppressWarnings("unused")
292 class DataLoop
extends Data
{
293 public DataLoop next
;
294 private String value
;
296 @SuppressWarnings("synthetic-access")
300 @SuppressWarnings("synthetic-access")
301 public DataLoop(String value
) {