src/be/nikiroo/utils/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(encoded);
  27                 byte[] reencoded = toBytes(redata,true);
  28
  29                 test.assertEquals("Different data after encode/decode/encode", true,
  30                                 Arrays.equals(encoded, reencoded));
  31         }
  32
  33         // try to remove pointer addresses
  34         private byte[] toBytes(Object data, boolean clearRefs) throws NotSerializableException,
  35                         IOException {
  36                 ByteArrayOutputStream out = new ByteArrayOutputStream();
  37                 new Exporter(out).append(data);
  38                 out.flush();
  39
  40                 if(clearRefs){
  41                 String tmp = new String(out.toByteArray(), "UTF-8");
  42                 tmp = tmp.replaceAll("@[0-9]*", "@REF");
  43                 return tmp.getBytes("UTF-8");
  44                 }
  45
  46                 return out.toByteArray();
  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
  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);
  68                                 encodeRecodeTest(this, data);
  69                         }
  70                 });
  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                                 };
  82                                 encodeRecodeTest(this, data);
  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;
  94                                 }};
  95
  96                                 byte[] encoded = toBytes(data,false);
  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
 102                                 byte[] encoded1 = toBytes(data[0],true);
 103                                 byte[] reencoded1 = toBytes(((Data[])redata)[0],true);
 104
 105                                 assertEquals("Different data after encode/decode/encode", true,
 106                                                 Arrays.equals(encoded1, reencoded1));
 107                         }
 108                 });
 109                 /*
 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                 });
 265                 */
 266         }
 267
 268         class DataArray {
 269                 public String[] data = new String[] { "un", "deux" };
 270         }
 271
 272         class Data {
 273                 private int value;
 274
 275                 private Data() {
 276                 }
 277
 278                 public Data(int value) {
 279                         this.value = value;
 280                 }
 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() {
 294                         return new Integer(value).hashCode();
 295                 }
 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         }
 326
 327         enum EnumToSend {
 328                 FANFAN, TULIPE,
 329         }
 330 }