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