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

   1 package be.nikiroo.utils.test;
   2
   3 import be.nikiroo.utils.Version;
   4 import be.nikiroo.utils.serial.Exporter;
   5 import be.nikiroo.utils.serial.Importer;
   6 import be.nikiroo.utils.serial.server.ConnectActionClientObject;
   7 import be.nikiroo.utils.serial.server.ConnectActionClientString;
   8 import be.nikiroo.utils.serial.server.ConnectActionServerObject;
   9 import be.nikiroo.utils.serial.server.ConnectActionServerString;
  10 import be.nikiroo.utils.serial.server.ServerObject;
  11 import be.nikiroo.utils.serial.server.ServerString;
  12
  13 class SerialTest extends TestLauncher {
  14         private SerialTest() {
  15                 super("Serial test", null);
  16         }
  17
  18         private TestLauncher createServerStringTestCases(final String[] args,
  19                         final boolean ssl) {
  20                 final String ssls = (ssl ? "(ssl)" : "(plain text)");
  21                 TestLauncher series = new TestLauncher("Client/Server " + ssls, args);
  22
  23                 series.addTest(new TestCase("Simple connection " + ssls) {
  24                         @Override
  25                         public void test() throws Exception {
  26                                 final String[] rec = new String[1];
  27
  28                                 ServerString server = new ServerString(this.getName(), 0, ssl) {
  29                                         @Override
  30                                         protected String onRequest(
  31                                                         ConnectActionServerString action,
  32                                                         Version clientVersion, String data)
  33                                                         throws Exception {
  34                                                 return null;
  35                                         }
  36                                 };
  37
  38                                 assertEquals("A port should have been assigned", true,
  39                                                 server.getPort() > 0);
  40
  41                                 server.start();
  42
  43                                 try {
  44                                         new ConnectActionClientObject(null, server.getPort(), ssl) {
  45                                                 @Override
  46                                                 public void action(Version serverVersion)
  47                                                                 throws Exception {
  48                                                         rec[0] = "ok";
  49                                                 }
  50                                         }.connect();
  51                                 } finally {
  52                                         server.stop();
  53                                 }
  54
  55                                 assertNotNull("The client action was not run", rec[0]);
  56                                 assertEquals("ok", rec[0]);
  57                         }
  58                 });
  59
  60                 series.addTest(new TestCase("Simple exchange " + ssls) {
  61                         final String[] sent = new String[1];
  62                         final String[] recd = new String[1];
  63                         final Exception[] err = new Exception[1];
  64
  65                         @Override
  66                         public void test() throws Exception {
  67                                 ServerString server = new ServerString(this.getName(), 0, ssl) {
  68                                         @Override
  69                                         protected String onRequest(
  70                                                         ConnectActionServerString action,
  71                                                         Version clientVersion, String data)
  72                                                         throws Exception {
  73                                                 sent[0] = data;
  74                                                 return "pong";
  75                                         }
  76
  77                                         @Override
  78                                         protected void onError(Exception e) {
  79                                                 super.onError(e);
  80                                                 err[0] = e;
  81                                         }
  82                                 };
  83
  84                                 server.start();
  85
  86                                 try {
  87                                         new ConnectActionClientString(null, server.getPort(), ssl) {
  88                                                 @Override
  89                                                 public void action(Version serverVersion)
  90                                                                 throws Exception {
  91                                                         recd[0] = send("ping");
  92                                                 }
  93                                         }.connect();
  94                                 } finally {
  95                                         server.stop();
  96                                 }
  97
  98                                 if (err[0] != null) {
  99                                         fail("An exception was thrown: " + err[0].getMessage());
 100                                 }
 101
 102                                 assertEquals("ping", sent[0]);
 103                                 assertEquals("pong", recd[0]);
 104                         }
 105                 });
 106
 107                 series.addTest(new TestCase("Multiple exchanges " + ssls) {
 108                         final String[] sent = new String[3];
 109                         final String[] recd = new String[3];
 110                         final Exception[] err = new Exception[1];
 111
 112                         @Override
 113                         public void test() throws Exception {
 114                                 ServerString server = new ServerString(this.getName(), 0, ssl) {
 115                                         @Override
 116                                         protected String onRequest(
 117                                                         ConnectActionServerString action,
 118                                                         Version clientVersion, String data)
 119                                                         throws Exception {
 120                                                 sent[0] = data;
 121                                                 action.send("pong");
 122                                                 sent[1] = action.rec();
 123                                                 return "pong2";
 124                                         }
 125
 126                                         @Override
 127                                         protected void onError(Exception e) {
 128                                                 super.onError(e);
 129                                                 err[0] = e;
 130                                         }
 131                                 };
 132
 133                                 server.start();
 134
 135                                 try {
 136                                         new ConnectActionClientString(null, server.getPort(), ssl) {
 137                                                 @Override
 138                                                 public void action(Version serverVersion)
 139                                                                 throws Exception {
 140                                                         recd[0] = send("ping");
 141                                                         recd[1] = send("ping2");
 142                                                 }
 143                                         }.connect();
 144                                 } finally {
 145                                         server.stop();
 146                                 }
 147
 148                                 if (err[0] != null) {
 149                                         fail("An exception was thrown: " + err[0].getMessage());
 150                                 }
 151
 152                                 assertEquals("ping", sent[0]);
 153                                 assertEquals("pong", recd[0]);
 154                                 assertEquals("ping2", sent[1]);
 155                                 assertEquals("pong2", recd[1]);
 156                         }
 157                 });
 158
 159                 series.addTest(new TestCase("Multiple call from client " + ssls) {
 160                         final String[] sent = new String[3];
 161                         final String[] recd = new String[3];
 162                         final Exception[] err = new Exception[1];
 163
 164                         @Override
 165                         public void test() throws Exception {
 166                                 ServerString server = new ServerString(this.getName(), 0, ssl) {
 167                                         @Override
 168                                         protected String onRequest(
 169                                                         ConnectActionServerString action,
 170                                                         Version clientVersion, String data)
 171                                                         throws Exception {
 172                                                 sent[Integer.parseInt(data)] = data;
 173                                                 return "" + (Integer.parseInt(data) * 2);
 174                                         }
 175
 176                                         @Override
 177                                         protected void onError(Exception e) {
 178                                                 super.onError(e);
 179                                                 err[0] = e;
 180                                         }
 181                                 };
 182
 183                                 server.start();
 184
 185                                 try {
 186                                         new ConnectActionClientString(null, server.getPort(), ssl) {
 187                                                 @Override
 188                                                 public void action(Version serverVersion)
 189                                                                 throws Exception {
 190                                                         for (int i = 0; i < 3; i++) {
 191                                                                 recd[i] = send("" + i);
 192                                                         }
 193                                                 }
 194                                         }.connect();
 195                                 } finally {
 196                                         server.stop();
 197                                 }
 198
 199                                 if (err[0] != null) {
 200                                         fail("An exception was thrown: " + err[0].getMessage());
 201                                 }
 202
 203                                 assertEquals("0", sent[0]);
 204                                 assertEquals("0", recd[0]);
 205                                 assertEquals("1", sent[1]);
 206                                 assertEquals("2", recd[1]);
 207                                 assertEquals("2", sent[2]);
 208                                 assertEquals("4", recd[2]);
 209                         }
 210                 });
 211
 212                 return series;
 213         }
 214
 215         private TestLauncher createServerObjectTestCases(final String[] args,
 216                         final boolean ssl) {
 217                 final String ssls = (ssl ? "(ssl)" : "(plain text)");
 218                 TestLauncher series = new TestLauncher("Client/Server " + ssls, args);
 219
 220                 series.addTest(new TestCase("Simple connection " + ssls) {
 221                         @Override
 222                         public void test() throws Exception {
 223                                 final Object[] rec = new Object[1];
 224
 225                                 ServerObject server = new ServerObject(this.getName(), 0, ssl) {
 226                                         @Override
 227                                         protected Object onRequest(
 228                                                         ConnectActionServerObject action,
 229                                                         Version clientVersion, Object data)
 230                                                         throws Exception {
 231                                                 return null;
 232                                         }
 233                                 };
 234
 235                                 assertEquals("A port should have been assigned", true,
 236                                                 server.getPort() > 0);
 237
 238                                 server.start();
 239
 240                                 try {
 241                                         new ConnectActionClientObject(null, server.getPort(), ssl) {
 242                                                 @Override
 243                                                 public void action(Version serverVersion)
 244                                                                 throws Exception {
 245                                                         rec[0] = true;
 246                                                 }
 247                                         }.connect();
 248                                 } finally {
 249                                         server.stop();
 250                                 }
 251
 252                                 assertNotNull("The client action was not run", rec[0]);
 253                                 assertEquals(true, (boolean) ((Boolean) rec[0]));
 254                         }
 255                 });
 256
 257                 series.addTest(new TestCase("Simple exchange " + ssls) {
 258                         final Object[] sent = new Object[1];
 259                         final Object[] recd = new Object[1];
 260                         final Exception[] err = new Exception[1];
 261
 262                         @Override
 263                         public void test() throws Exception {
 264                                 ServerObject server = new ServerObject(this.getName(), 0, ssl) {
 265                                         @Override
 266                                         protected Object onRequest(
 267                                                         ConnectActionServerObject action,
 268                                                         Version clientVersion, Object data)
 269                                                         throws Exception {
 270                                                 sent[0] = data;
 271                                                 return "pong";
 272                                         }
 273
 274                                         @Override
 275                                         protected void onError(Exception e) {
 276                                                 super.onError(e);
 277                                                 err[0] = e;
 278                                         }
 279                                 };
 280
 281                                 server.start();
 282
 283                                 try {
 284                                         new ConnectActionClientObject(null, server.getPort(), ssl) {
 285                                                 @Override
 286                                                 public void action(Version serverVersion)
 287                                                                 throws Exception {
 288                                                         recd[0] = send("ping");
 289                                                 }
 290                                         }.connect();
 291                                 } finally {
 292                                         server.stop();
 293                                 }
 294
 295                                 if (err[0] != null) {
 296                                         fail("An exception was thrown: " + err[0].getMessage());
 297                                 }
 298
 299                                 assertEquals("ping", sent[0]);
 300                                 assertEquals("pong", recd[0]);
 301                         }
 302                 });
 303
 304                 series.addTest(new TestCase("Multiple exchanges " + ssls) {
 305                         final Object[] sent = new Object[3];
 306                         final Object[] recd = new Object[3];
 307                         final Exception[] err = new Exception[1];
 308
 309                         @Override
 310                         public void test() throws Exception {
 311                                 ServerObject server = new ServerObject(this.getName(), 0, ssl) {
 312                                         @Override
 313                                         protected Object onRequest(
 314                                                         ConnectActionServerObject action,
 315                                                         Version clientVersion, Object data)
 316                                                         throws Exception {
 317                                                 sent[0] = data;
 318                                                 action.send("pong");
 319                                                 sent[1] = action.rec();
 320                                                 return "pong2";
 321                                         }
 322
 323                                         @Override
 324                                         protected void onError(Exception e) {
 325                                                 super.onError(e);
 326                                                 err[0] = e;
 327                                         }
 328                                 };
 329
 330                                 server.start();
 331
 332                                 try {
 333                                         new ConnectActionClientObject(null, server.getPort(), ssl) {
 334                                                 @Override
 335                                                 public void action(Version serverVersion)
 336                                                                 throws Exception {
 337                                                         recd[0] = send("ping");
 338                                                         recd[1] = send("ping2");
 339                                                 }
 340                                         }.connect();
 341                                 } finally {
 342                                         server.stop();
 343                                 }
 344
 345                                 if (err[0] != null) {
 346                                         fail("An exception was thrown: " + err[0].getMessage());
 347                                 }
 348
 349                                 assertEquals("ping", sent[0]);
 350                                 assertEquals("pong", recd[0]);
 351                                 assertEquals("ping2", sent[1]);
 352                                 assertEquals("pong2", recd[1]);
 353                         }
 354                 });
 355
 356                 series.addTest(new TestCase("Multiple call from client " + ssls) {
 357                         final Object[] sent = new Object[3];
 358                         final Object[] recd = new Object[3];
 359                         final Exception[] err = new Exception[1];
 360
 361                         @Override
 362                         public void test() throws Exception {
 363                                 ServerObject server = new ServerObject(this.getName(), 0, ssl) {
 364                                         @Override
 365                                         protected Object onRequest(
 366                                                         ConnectActionServerObject action,
 367                                                         Version clientVersion, Object data)
 368                                                         throws Exception {
 369                                                 sent[(Integer) data] = data;
 370                                                 return ((Integer) data) * 2;
 371                                         }
 372
 373                                         @Override
 374                                         protected void onError(Exception e) {
 375                                                 super.onError(e);
 376                                                 err[0] = e;
 377                                         }
 378                                 };
 379
 380                                 server.start();
 381
 382                                 try {
 383                                         new ConnectActionClientObject(null, server.getPort(), ssl) {
 384                                                 @Override
 385                                                 public void action(Version serverVersion)
 386                                                                 throws Exception {
 387                                                         for (int i = 0; i < 3; i++) {
 388                                                                 recd[i] = send(i);
 389                                                         }
 390                                                 }
 391                                         }.connect();
 392                                 } finally {
 393                                         server.stop();
 394                                 }
 395
 396                                 if (err[0] != null) {
 397                                         fail("An exception was thrown: " + err[0].getMessage());
 398                                 }
 399
 400                                 assertEquals(0, sent[0]);
 401                                 assertEquals(0, recd[0]);
 402                                 assertEquals(1, sent[1]);
 403                                 assertEquals(2, recd[1]);
 404                                 assertEquals(2, sent[2]);
 405                                 assertEquals(4, recd[2]);
 406                         }
 407                 });
 408
 409                 return series;
 410         }
 411
 412         public SerialTest(String[] args) {
 413                 super("Serial test", args);
 414
 415                 addSeries(createServerObjectTestCases(args, false));
 416
 417                 addSeries(createServerObjectTestCases(args, true));
 418
 419                 addSeries(createServerStringTestCases(args, false));
 420
 421                 addSeries(createServerStringTestCases(args, true));
 422
 423                 addTest(new TestCase("Simple class Import/Export") {
 424                         @Override
 425                         public void test() throws Exception {
 426                                 Data data = new Data(42);
 427                                 String encoded = new Exporter().append(data).toString(false);
 428                                 Object redata = new Importer().read(encoded).getValue();
 429                                 String reencoded = new Exporter().append(redata)
 430                                                 .toString(false);
 431
 432                                 assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
 433                                                 reencoded.replaceAll("@[0-9]*", "@REF"));
 434                         }
 435                 });
 436
 437                 addTest(new TestCase("Import/Export with nested objects") {
 438                         @Override
 439                         public void test() throws Exception {
 440                                 Data data = new DataObject(new Data(21));
 441                                 String encoded = new Exporter().append(data).toString(false);
 442                                 Object redata = new Importer().read(encoded).getValue();
 443                                 String reencoded = new Exporter().append(redata)
 444                                                 .toString(false);
 445
 446                                 assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
 447                                                 reencoded.replaceAll("@[0-9]*", "@REF"));
 448                         }
 449                 });
 450
 451                 addTest(new TestCase("Import/Export with nested objects forming a loop") {
 452                         @Override
 453                         public void test() throws Exception {
 454                                 DataLoop data = new DataLoop("looping");
 455                                 data.next = new DataLoop("level 2");
 456                                 data.next.next = data;
 457
 458                                 String encoded = new Exporter().append(data).toString(false);
 459                                 Object redata = new Importer().read(encoded).getValue();
 460                                 String reencoded = new Exporter().append(redata)
 461                                                 .toString(false);
 462
 463                                 assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
 464                                                 reencoded.replaceAll("@[0-9]*", "@REF"));
 465                         }
 466                 });
 467
 468                 addTest(new TestCase("Array in Object Import/Export") {
 469                         @Override
 470                         public void test() throws Exception {
 471                                 Object data = new DataArray();// new String[] { "un", "deux" };
 472                                 String encoded = new Exporter().append(data).toString(false);
 473                                 Object redata = new Importer().read(encoded).getValue();
 474                                 String reencoded = new Exporter().append(redata)
 475                                                 .toString(false);
 476
 477                                 assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
 478                                                 reencoded.replaceAll("@[0-9]*", "@REF"));
 479                         }
 480                 });
 481
 482                 addTest(new TestCase("Array Import/Export") {
 483                         @Override
 484                         public void test() throws Exception {
 485                                 Object data = new String[] { "un", "deux" };
 486                                 String encoded = new Exporter().append(data).toString(false);
 487                                 Object redata = new Importer().read(encoded).getValue();
 488                                 String reencoded = new Exporter().append(redata)
 489                                                 .toString(false);
 490
 491                                 assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
 492                                                 reencoded.replaceAll("@[0-9]*", "@REF"));
 493                         }
 494                 });
 495
 496                 addTest(new TestCase("Enum Import/Export") {
 497                         @Override
 498                         public void test() throws Exception {
 499                                 Object data = EnumToSend.FANFAN;
 500                                 String encoded = new Exporter().append(data).toString(false);
 501                                 Object redata = new Importer().read(encoded).getValue();
 502                                 String reencoded = new Exporter().append(redata)
 503                                                 .toString(false);
 504
 505                                 assertEquals(encoded.replaceAll("@[0-9]*", "@REF"),
 506                                                 reencoded.replaceAll("@[0-9]*", "@REF"));
 507                         }
 508                 });
 509         }
 510
 511         class DataArray {
 512                 public String[] data = new String[] { "un", "deux" };
 513         }
 514
 515         @SuppressWarnings("unused")
 516         class Data {
 517                 private int value;
 518
 519                 private Data() {
 520                 }
 521
 522                 public Data(int value) {
 523                         this.value = value;
 524                 }
 525         }
 526
 527         @SuppressWarnings("unused")
 528         class DataObject extends Data {
 529                 private Data data;
 530
 531                 @SuppressWarnings("synthetic-access")
 532                 private DataObject() {
 533                 }
 534
 535                 @SuppressWarnings("synthetic-access")
 536                 public DataObject(Data data) {
 537                         this.data = data;
 538                 }
 539         }
 540
 541         @SuppressWarnings("unused")
 542         class DataLoop extends Data {
 543                 public DataLoop next;
 544                 private String value;
 545
 546                 @SuppressWarnings("synthetic-access")
 547                 private DataLoop() {
 548                 }
 549
 550                 @SuppressWarnings("synthetic-access")
 551                 public DataLoop(String value) {
 552                         this.value = value;
 553                 }
 554         }
 555
 556         enum EnumToSend {
 557                 FANFAN, TULIPE,
 558         }
 559 }