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
;
8 import java
.util
.Arrays
;
10 import be
.nikiroo
.utils
.serial
.Exporter
;
11 import be
.nikiroo
.utils
.serial
.Importer
;
12 import be
.nikiroo
.utils
.test
.TestCase
;
13 import be
.nikiroo
.utils
.test
.TestLauncher
;
15 class SerialTest
extends TestLauncher
{
17 * Required for Import/Export of objects.
23 // try to remove pointer addresses
24 private byte[] toBytes(Object data
) throws NotSerializableException
,
26 ByteArrayOutputStream out
= new ByteArrayOutputStream();
27 new Exporter(out
).append(data
);
29 String tmp
= new String(out
.toByteArray(), "UTF-8");
30 tmp
= tmp
.replaceAll("@[0-9]*", "@REF");
31 return tmp
.getBytes("UTF-8");
34 private Object
fromBytes(byte[] data
) throws NoSuchFieldException
,
35 NoSuchMethodException
, ClassNotFoundException
,
36 NullPointerException
, IOException
{
38 InputStream in
= new ByteArrayInputStream(data
);
40 return new Importer().read(in
).getValue();
46 public SerialTest(String
[] args
) {
47 super("Serial test", args
);
49 addTest(new TestCase("Simple class Import/Export") {
51 public void test() throws Exception
{
52 Data data
= new Data(42);
54 byte[] encoded
= toBytes(data
);
55 Object redata
= fromBytes(encoded
);
56 byte[] reencoded
= toBytes(redata
);
58 assertEquals("Different data after encode/decode/encode", true,
59 Arrays
.equals(encoded
, reencoded
));
63 * addTest(new TestCase() {
65 * @SuppressWarnings("unused") private TestCase me =
66 * setName("Anonymous inner class");
68 * @Override public void test() throws Exception { Data data = new
71 * @SuppressWarnings("unused") int value = 42; };
73 * String encoded = new Exporter().append(data).toString(false, false);
74 * Object redata = new Importer().read(encoded).getValue(); String
75 * reencoded = new Exporter().append(redata).toString( false, false);
77 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
78 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
80 * addTest(new TestCase() {
82 * @SuppressWarnings("unused") private TestCase me =
83 * setName("Array of anonymous inner classes");
85 * @Override public void test() throws Exception { Data[] data = new
86 * Data[] { new Data() {
88 * @SuppressWarnings("unused") int value = 42; } };
90 * String encoded = new Exporter().append(data).toString(false, false);
91 * Object redata = new Importer().read(encoded).getValue(); String
92 * reencoded = new Exporter().append(redata).toString( false, false);
94 * // Comparing the 2 strings won't be useful, because the @REFs // will
95 * be ZIP-encoded; so we parse and re-encode the object encoded = new
96 * Exporter().append(data[0]).toString(false, false); try { reencoded =
97 * new Exporter().append(((Data[]) redata)[0]) .toString(false, false);
98 * } catch (Exception e) {
99 * fail("Cannot cast the returned data into its original object", e); }
101 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
102 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
104 * addTest(new TestCase("URL Import/Export") {
106 * @Override public void test() throws Exception { URL data = new
107 * URL("https://fanfan.be/"); String encoded = new
108 * Exporter().append(data).toString(false, false); Object redata = new
109 * Importer().read(encoded).getValue(); String reencoded = new
110 * Exporter().append(redata).toString( false, false);
112 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
113 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
115 * addTest(new TestCase("URL-String Import/Export") {
117 * @Override public void test() throws Exception { String data = new
118 * URL("https://fanfan.be/").toString(); String encoded = new
119 * Exporter().append(data).toString(false, false); Object redata = new
120 * Importer().read(encoded).getValue(); String reencoded = new
121 * Exporter().append(redata).toString( false, false);
123 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
124 * reencoded.replaceAll("@[0-9]*", "@REF")); assertEquals(data, redata);
127 * addTest(new TestCase("URL/URL-String arrays Import/Export") {
129 * @Override public void test() throws Exception { final String url =
130 * "https://fanfan.be/";
132 * Object[] data = new Object[] { new URL(url), url }; String encoded =
133 * new Exporter().append(data).toString(false, false); Object redata =
134 * new Importer().read(encoded).getValue(); String reencoded = new
135 * Exporter().append(redata).toString( false, false);
137 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
138 * reencoded.replaceAll("@[0-9]*", "@REF")); assertEquals(data[0],
139 * ((Object[]) redata)[0]); assertEquals(data[1], ((Object[])
142 * addTest(new TestCase("Import/Export with nested objects") {
144 * @Override public void test() throws Exception { Data data = new
145 * DataObject(new Data(21)); String encoded = new
146 * Exporter().append(data).toString(false, false); Object redata = new
147 * Importer().read(encoded).getValue(); String reencoded = new
148 * Exporter().append(redata).toString( false, false);
150 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
151 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
154 * TestCase("Import/Export with nested objects forming a loop") {
156 * @Override public void test() throws Exception { DataLoop data = new
157 * DataLoop("looping"); data.next = new DataLoop("level 2");
158 * data.next.next = data;
160 * String encoded = new Exporter().append(data).toString(false, false);
161 * Object redata = new Importer().read(encoded).getValue(); String
162 * reencoded = new Exporter().append(redata).toString( false, false);
164 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
165 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
167 * addTest(new TestCase("Array in Object Import/Export") {
169 * @Override public void test() throws Exception { Object data = new
170 * DataArray();// new String[] { "un", "deux" }; String encoded = new
171 * Exporter().append(data).toString(false, false); Object redata = new
172 * Importer().read(encoded).getValue(); String reencoded = new
173 * Exporter().append(redata).toString( false, false);
175 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
176 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
178 * addTest(new TestCase("Array Import/Export") {
180 * @Override public void test() throws Exception { Object data = new
181 * String[] { "un", "deux" }; String encoded = new
182 * Exporter().append(data).toString(false, false); Object redata = new
183 * Importer().read(encoded).getValue(); String reencoded = new
184 * Exporter().append(redata).toString( false, false);
186 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
187 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
189 * addTest(new TestCase("Enum Import/Export") {
191 * @Override public void test() throws Exception { Object data =
192 * EnumToSend.FANFAN; String encoded = new
193 * Exporter().append(data).toString(false, false); Object redata = new
194 * Importer().read(encoded).getValue(); String reencoded = new
195 * Exporter().append(redata).toString( false, false);
197 * assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
198 * reencoded.replaceAll("@[0-9]*", "@REF")); } });
200 * addTest(new TestCase("B64 and ZIP String test") {
202 * @Override public void test() throws Exception { Object data =
203 * "Fanfan la tulipe"; String encoded = new
204 * Exporter().append(data).toString(true, false); String redata =
205 * (String) new Importer().read(encoded) .getValue();
207 * assertEquals("Items not identical after B64", data, redata);
209 * encoded = new Exporter().append(data).toString(true, true); redata =
210 * (String) new Importer().read(encoded).getValue();
212 * assertEquals("Items not identical after ZIP", data, redata); } });
214 * addTest(new TestCase("B64 and ZIP Data test") {
216 * @Override public void test() throws Exception { Object data = new
217 * Data(55); String encoded = new Exporter().append(data).toString(true,
218 * false); Data redata = (Data) new Importer().read(encoded).getValue();
220 * assertEquals("Items not identical after B64", data, redata);
222 * encoded = new Exporter().append(data).toString(true, true); redata =
223 * (Data) new Importer().read(encoded).getValue();
225 * assertEquals("Items not identical after ZIP", data, redata); } });
227 * addTest(new TestCase("B64 and ZIP 70000 chars test") {
229 * @Override public void test() throws Exception { StringBuilder builder
230 * = new StringBuilder(); for (int i = 0; i < 7000; i++) {
231 * builder.append("0123456789"); }
233 * Object data = builder.toString(); String encoded = new
234 * Exporter().append(data).toString(true, false); String redata =
235 * (String) new Importer().read(encoded) .getValue();
237 * assertEquals("Items not identical after B64", data, redata);
239 * encoded = new Exporter().append(data).toString(true, true); redata =
240 * (String) new Importer().read(encoded).getValue();
242 * assertEquals("Items not identical after ZIP", data, redata); } });
247 public String
[] data
= new String
[] { "un", "deux" };
256 public Data(int value
) {
261 public boolean equals(Object obj
) {
262 if (obj
instanceof Data
) {
263 Data other
= (Data
) obj
;
264 return other
.value
== this.value
;
271 public int hashCode() {
272 return new Integer(value
).hashCode();
276 @SuppressWarnings("unused")
277 class DataObject
extends Data
{
280 @SuppressWarnings("synthetic-access")
281 private DataObject() {
284 @SuppressWarnings("synthetic-access")
285 public DataObject(Data data
) {
290 @SuppressWarnings("unused")
291 class DataLoop
extends Data
{
292 public DataLoop next
;
293 private String value
;
295 @SuppressWarnings("synthetic-access")
299 @SuppressWarnings("synthetic-access")
300 public DataLoop(String value
) {