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

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