X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Futils%2Ftest_code%2FSerialTest.java;fp=src%2Fbe%2Fnikiroo%2Futils%2Ftest_code%2FSerialTest.java;h=c008dec7f3e9ff6f8a971ff4ad2224d301f46d13;hb=08f80ac5fa60738d3ad74c4b5390a0b79ae313d4;hp=f3ed346a5f68fb52cc2b37ee3b3f628029cf1d5d;hpb=f28a134e4d06ee40d62c0c62123fc4799d49d8eb;p=fanfix.git diff --git a/src/be/nikiroo/utils/test_code/SerialTest.java b/src/be/nikiroo/utils/test_code/SerialTest.java index f3ed346..c008dec 100644 --- a/src/be/nikiroo/utils/test_code/SerialTest.java +++ b/src/be/nikiroo/utils/test_code/SerialTest.java @@ -1,6 +1,12 @@ 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; @@ -15,6 +21,50 @@ class SerialTest extends TestLauncher { this(null); } + private void encodeRecodeTest(TestCase test, Object data) throws Exception { + byte[] encoded = toBytes(data, true); + Object redata = fromBytes(toBytes(data, false)); + byte[] reencoded = toBytes(redata, true); + + // We suppose text mode + if (encoded.length < 256 && reencoded.length < 256) { + test.assertEquals("Different data after encode/decode/encode", + new String(encoded, "UTF-8"), + new String(reencoded, "UTF-8")); + } else { + test.assertEquals("Different data after encode/decode/encode", + true, Arrays.equals(encoded, reencoded)); + } + } + + // try to remove pointer addresses + private byte[] toBytes(Object data, boolean clearRefs) + throws NotSerializableException, IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + new Exporter(out).append(data); + out.flush(); + + if (clearRefs) { + String tmp = new String(out.toByteArray(), "UTF-8"); + tmp = tmp.replaceAll("@[0-9]*", "@REF"); + return tmp.getBytes("UTF-8"); + } + + return out.toByteArray(); + } + + 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); @@ -22,17 +72,9 @@ class SerialTest extends TestLauncher { @Override public void test() throws Exception { Data data = new Data(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")); + encodeRecodeTest(this, data); } }); - addTest(new TestCase() { @SuppressWarnings("unused") private TestCase me = setName("Anonymous inner class"); @@ -43,18 +85,9 @@ class SerialTest extends TestLauncher { @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")); + encodeRecodeTest(this, data); } }); - addTest(new TestCase() { @SuppressWarnings("unused") private TestCase me = setName("Array of anonymous inner classes"); @@ -66,211 +99,91 @@ class SerialTest extends TestLauncher { 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")); + byte[] encoded = toBytes(data, false); + Object redata = fromBytes(encoded); + + // Comparing the 2 arrays won't be useful, because the @REFs + // will be ZIP-encoded; so we parse and re-encode each object + + byte[] encoded1 = toBytes(data[0], true); + byte[] reencoded1 = toBytes(((Object[]) redata)[0], true); + + assertEquals("Different data after encode/decode/encode", true, + Arrays.equals(encoded1, reencoded1)); } }); - 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")); + encodeRecodeTest(this, data); } }); - 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); + encodeRecodeTest(this, data); } }); - 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]); + + byte[] encoded = toBytes(data, false); + Object redata = fromBytes(encoded); + + // Comparing the 2 arrays won't be useful, because the @REFs + // will be ZIP-encoded; so we parse and re-encode each object + + byte[] encoded1 = toBytes(data[0], true); + byte[] reencoded1 = toBytes(((Object[]) redata)[0], true); + byte[] encoded2 = toBytes(data[1], true); + byte[] reencoded2 = toBytes(((Object[]) redata)[1], true); + + assertEquals("Different data 1 after encode/decode/encode", + true, Arrays.equals(encoded1, reencoded1)); + assertEquals("Different data 2 after encode/decode/encode", + true, Arrays.equals(encoded2, reencoded2)); } }); - 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")); + encodeRecodeTest(this, data); } }); - 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")); + encodeRecodeTest(this, data); } }); - 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")); + encodeRecodeTest(this, data); } }); - 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")); + encodeRecodeTest(this, data); } }); - 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); + encodeRecodeTest(this, data); } }); }