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