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