src/be/nikiroo/utils/test/SerialTest.java

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