001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.net.telnet; 018 import junit.framework.TestCase; 019 020 import java.io.IOException; 021 import java.io.InputStream; 022 import java.io.OutputStream; 023 import java.io.PipedInputStream; 024 import java.io.PipedOutputStream; 025 026 /*** 027 * JUnit test class for TelnetClient.s 028 * Implements protocol compliance tests 029 * <p> 030 * @author Bruno D'Avanzo 031 ***/ 032 public class TelnetClientTest 033 extends TestCase implements TelnetNotificationHandler 034 { 035 /** 036 * Handy holder to hold both sides of the connection 037 * used in testing for clarity. 038 */ 039 private class TestConnection { 040 TelnetTestSimpleServer server; 041 TelnetClient client; 042 int port; 043 TestConnection( 044 TelnetTestSimpleServer server, 045 TelnetClient client, 046 int port) 047 { 048 this.server = server; 049 this.client = client; 050 this.port = port; 051 } 052 protected void close() { 053 TelnetClientTest.this.closeConnection( 054 this.server, this.client, this.port); 055 } 056 } 057 058 // four connections with different properties 059 // to use in tests. 060 private TestConnection STANDARD; 061 private TestConnection OPTIONS; 062 private TestConnection ANSI; 063 private TestConnection NOREAD; 064 065 private int NUM_CONNECTIONS = 4; 066 067 068 protected int numdo = 0; 069 protected int numdont = 0; 070 protected int numwill = 0; 071 protected int numwont = 0; 072 073 /*** 074 * main for running the test. 075 ***/ 076 public static void main(String args[]) 077 { 078 junit.textui.TestRunner.run(TelnetClientTest.class); 079 } 080 081 /*** 082 * open connections needed for the tests for the test. 083 ***/ 084 @Override 085 protected void setUp() throws Exception 086 { 087 super.setUp(); 088 for (int port = 3333, socket = 0; socket < NUM_CONNECTIONS && port < 4000; port++) 089 { 090 TelnetTestSimpleServer server = null; 091 TelnetClient client = null; 092 try { 093 server = new TelnetTestSimpleServer(port); 094 switch (socket) { 095 case 0: 096 client = new TelnetClient(); 097 // redundant but makes code clearer. 098 client.setReaderThread(true); 099 break; 100 case 1: 101 client = new TelnetClient(); 102 TerminalTypeOptionHandler ttopt = 103 new TerminalTypeOptionHandler("VT100", false, false, true, false); 104 EchoOptionHandler echoopt = 105 new EchoOptionHandler(true, false, true, false); 106 SuppressGAOptionHandler gaopt = 107 new SuppressGAOptionHandler(true, true, true, true); 108 109 client.addOptionHandler(ttopt); 110 client.addOptionHandler(echoopt); 111 client.addOptionHandler(gaopt); 112 break; 113 case 2: 114 client = new TelnetClient("ANSI"); 115 break; 116 case 3: 117 client = new TelnetClient(); 118 client.setReaderThread(false); 119 break; 120 } 121 client.connect("127.0.0.1", port); 122 switch (socket) { 123 case 0: 124 STANDARD = new TestConnection(server, client, port); 125 break; 126 case 1: 127 OPTIONS = new TestConnection(server, client, port); 128 break; 129 case 2: 130 ANSI = new TestConnection(server, client, port); 131 break; 132 case 3: 133 NOREAD = new TestConnection(server, client, port); 134 break; 135 136 } 137 138 // only increment socket number on success 139 socket++; 140 } catch (IOException e) { 141 closeConnection(server, client, port); 142 System.err.println("failed to open client-server connection on port " + port); 143 } 144 } 145 Thread.sleep(1000); 146 } 147 148 /* 149 * @throws java.lang.Exception 150 */ 151 @Override 152 protected void tearDown() throws Exception { 153 NOREAD.close(); 154 ANSI.close(); 155 OPTIONS.close(); 156 STANDARD.close(); 157 try { 158 Thread.sleep(1000); 159 } catch (InterruptedException ie) { 160 //do nothing 161 } 162 super.tearDown(); 163 } 164 165 166 167 void closeConnection(TelnetTestSimpleServer server, TelnetClient client, int port) { 168 if (server != null) { 169 server.disconnect(); 170 server.stop(); 171 } 172 try { 173 if (client != null) { 174 client.disconnect(); 175 } 176 } catch (IOException e) { 177 System.err.println("failed to close client-server connection on port " + port); 178 System.err.println("ERROR in closeConnection(), "+ e.getMessage()); 179 } 180 181 } 182 183 /*** 184 * tests the initial condition of the sessions 185 ***/ 186 public void testInitial() throws Exception 187 { 188 boolean connect1_ok = false; 189 boolean connect2_ok = false; 190 boolean connect3_ok = false; 191 boolean init2_ok = false; 192 boolean add_invalid_ok1 = false; 193 boolean add_invalid_ok2 = false; 194 byte buffread2[] = new byte[9]; 195 byte expected2[] = 196 { 197 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, 198 (byte) TelnetOption.ECHO, 199 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, 200 (byte) TelnetOption.SUPPRESS_GO_AHEAD, 201 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, 202 (byte) TelnetOption.SUPPRESS_GO_AHEAD, 203 }; 204 205 SimpleOptionHandler hand = new SimpleOptionHandler(550); 206 try 207 { 208 STANDARD.client.addOptionHandler(hand); 209 } 210 catch (Exception e) 211 { 212 add_invalid_ok1 = true; 213 } 214 215 try 216 { 217 OPTIONS.client.addOptionHandler(hand); 218 } 219 catch (Exception e) 220 { 221 add_invalid_ok2 = true; 222 } 223 224 InputStream is1 = STANDARD.server.getInputStream(); 225 Thread.sleep(1000); 226 if(is1.available() == 0) 227 { 228 connect1_ok = true; 229 } 230 231 Thread.sleep(1000); 232 InputStream is2 = OPTIONS.server.getInputStream(); 233 if(is2.available() == 9) 234 { 235 is2.read(buffread2); 236 connect2_ok = true; 237 238 if(equalBytes(buffread2, expected2)) 239 init2_ok = true; 240 } 241 242 InputStream is3 = ANSI.server.getInputStream(); 243 Thread.sleep(1000); 244 if(is3.available() == 0) 245 { 246 connect3_ok = true; 247 } 248 249 250 assertTrue(connect1_ok); 251 assertTrue(connect2_ok); 252 assertTrue(connect3_ok); 253 assertTrue(!STANDARD.client.getLocalOptionState(TelnetOption.ECHO)); 254 assertTrue(!STANDARD.client.getRemoteOptionState(TelnetOption.ECHO)); 255 assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.ECHO)); 256 assertTrue(!OPTIONS.client.getRemoteOptionState(TelnetOption.ECHO)); 257 assertTrue(!ANSI.client.getLocalOptionState(TelnetOption.TERMINAL_TYPE)); 258 assertTrue(!ANSI.client.getRemoteOptionState(TelnetOption.TERMINAL_TYPE)); 259 assertTrue(init2_ok); 260 assertTrue(add_invalid_ok1); 261 assertTrue(add_invalid_ok2); 262 } 263 264 /*** 265 * protocol compliance test for option negotiation 266 ***/ 267 public void testOptionNegotiation() throws Exception 268 { 269 boolean negotiation1_ok = false; 270 byte buffread1[] = new byte[6]; 271 byte send1[] = 272 { 273 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, (byte) 15, 274 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, (byte) 15, 275 }; 276 byte expected1[] = 277 { 278 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, (byte) 15, 279 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, (byte) 15, 280 }; 281 282 boolean negotiation2_ok = false; 283 byte buffread2[] = new byte[9]; 284 byte send2[] = 285 { 286 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, 287 (byte) TelnetOption.TERMINAL_TYPE, 288 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, 289 (byte) TelnetOption.ECHO, 290 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, 291 (byte) TelnetOption.SUPPRESS_GO_AHEAD, 292 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, 293 (byte) TelnetOption.SUPPRESS_GO_AHEAD 294 }; 295 byte expected2[] = 296 { 297 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, 298 (byte) TelnetOption.TERMINAL_TYPE, 299 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, 300 (byte) TelnetOption.ECHO, 301 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, 302 (byte) TelnetOption.SUPPRESS_GO_AHEAD 303 }; 304 305 byte buffread2b[] = new byte[11]; 306 byte send2b[] = 307 { 308 (byte) TelnetCommand.IAC, (byte) TelnetCommand.SB, 309 (byte) TelnetOption.TERMINAL_TYPE, 310 (byte) 1, (byte) TelnetCommand.IAC, (byte) TelnetCommand.SE, 311 }; 312 byte expected2b[] = 313 { 314 (byte) TelnetCommand.IAC, (byte) TelnetCommand.SB, 315 (byte) TelnetOption.TERMINAL_TYPE, 316 (byte) 0, (byte) 'V', (byte) 'T', (byte) '1', (byte) '0', 317 (byte) '0', 318 (byte) TelnetCommand.IAC, (byte) TelnetCommand.SE, 319 }; 320 321 boolean negotiation3_ok = false; 322 byte buffread3[] = new byte[6]; 323 byte send3[] = 324 { 325 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, 326 (byte) TelnetOption.TERMINAL_TYPE, 327 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, 328 (byte) TelnetOption.SUPPRESS_GO_AHEAD 329 }; 330 byte expected3[] = 331 { 332 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, 333 (byte) TelnetOption.TERMINAL_TYPE, 334 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, 335 (byte) TelnetOption.SUPPRESS_GO_AHEAD 336 }; 337 byte buffread3b[] = new byte[10]; 338 byte send3b[] = 339 { 340 (byte) TelnetCommand.IAC, (byte) TelnetCommand.SB, 341 (byte) TelnetOption.TERMINAL_TYPE, 342 (byte) 1, (byte) TelnetCommand.IAC, (byte) TelnetCommand.SE, 343 }; 344 byte expected3b[] = 345 { 346 (byte) TelnetCommand.IAC, (byte) TelnetCommand.SB, 347 (byte) TelnetOption.TERMINAL_TYPE, 348 (byte) 0, (byte) 'A', (byte) 'N', (byte) 'S', (byte) 'I', 349 (byte) TelnetCommand.IAC, (byte) TelnetCommand.SE, 350 }; 351 352 353 InputStream is1 = STANDARD.server.getInputStream(); 354 OutputStream os1 = STANDARD.server.getOutputStream(); 355 is1.skip(is1.available()); 356 os1.write(send1); 357 os1.flush(); 358 Thread.sleep(1000); 359 if(is1.available() == 6) 360 { 361 is1.read(buffread1); 362 363 if(equalBytes(buffread1, expected1)) 364 negotiation1_ok = true; 365 } 366 367 InputStream is2 = OPTIONS.server.getInputStream(); 368 OutputStream os2 = OPTIONS.server.getOutputStream(); 369 Thread.sleep(1000); 370 is2.skip(is2.available()); 371 os2.write(send2); 372 os2.flush(); 373 Thread.sleep(1000); 374 if(is2.available() == 9) 375 { 376 is2.read(buffread2); 377 378 if(equalBytes(buffread2, expected2)) 379 negotiation2_ok = true; 380 381 if(negotiation2_ok) 382 { 383 negotiation2_ok = false; 384 os2.write(send2b); 385 os2.flush(); 386 Thread.sleep(1000); 387 if(is2.available() == 11) 388 { 389 is2.read(buffread2b); 390 391 if(equalBytes(buffread2b, expected2b)) 392 negotiation2_ok = true; 393 } 394 } 395 } 396 397 InputStream is3 = ANSI.server.getInputStream(); 398 OutputStream os3 = ANSI.server.getOutputStream(); 399 Thread.sleep(1000); 400 is3.skip(is3.available()); 401 os3.write(send3); 402 os3.flush(); 403 Thread.sleep(1000); 404 if(is3.available() == 6) 405 { 406 is3.read(buffread3); 407 408 if(equalBytes(buffread3, expected3)) 409 negotiation3_ok = true; 410 411 if(negotiation3_ok) 412 { 413 negotiation3_ok = false; 414 os3.write(send3b); 415 os3.flush(); 416 Thread.sleep(1000); 417 if(is3.available() == 10) 418 { 419 is3.read(buffread3b); 420 if(equalBytes(buffread3b, expected3b)) 421 negotiation3_ok = true; 422 } 423 } 424 } 425 426 assertTrue(negotiation1_ok); 427 assertTrue(negotiation2_ok); 428 assertTrue(negotiation3_ok); 429 assertTrue(!STANDARD.client.getLocalOptionState(15)); 430 assertTrue(!STANDARD.client.getRemoteOptionState(15)); 431 assertTrue(!STANDARD.client.getLocalOptionState(TelnetOption.TERMINAL_TYPE)); 432 assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.ECHO)); 433 assertTrue(!OPTIONS.client.getRemoteOptionState(TelnetOption.ECHO)); 434 assertTrue(OPTIONS.client.getLocalOptionState(TelnetOption.SUPPRESS_GO_AHEAD)); 435 assertTrue(!OPTIONS.client.getRemoteOptionState(TelnetOption.SUPPRESS_GO_AHEAD)); 436 assertTrue(OPTIONS.client.getLocalOptionState(TelnetOption.TERMINAL_TYPE)); 437 assertTrue(ANSI.client.getLocalOptionState(TelnetOption.TERMINAL_TYPE)); 438 assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.ECHO)); 439 } 440 441 442 /*** 443 * protocol compliance test for option renegotiation 444 ***/ 445 public void testOptionRenegotiation() throws Exception 446 { 447 boolean negotiation1_ok = false; 448 449 byte buffread[] = new byte[6]; 450 byte send[] = 451 { 452 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, 453 (byte) TelnetOption.ECHO, 454 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, 455 (byte) TelnetOption.SUPPRESS_GO_AHEAD, 456 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, 457 (byte) TelnetOption.SUPPRESS_GO_AHEAD 458 }; 459 byte expected[] = 460 { 461 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, 462 (byte) TelnetOption.SUPPRESS_GO_AHEAD, 463 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, 464 (byte) TelnetOption.SUPPRESS_GO_AHEAD 465 }; 466 467 byte buffread2[] = new byte[3]; 468 byte send2[] = 469 { 470 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, 471 (byte) TelnetOption.ECHO, 472 }; 473 byte expected2[] = 474 { 475 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, 476 (byte) TelnetOption.ECHO, 477 }; 478 479 480 InputStream is = OPTIONS.server.getInputStream(); 481 OutputStream os = OPTIONS.server.getOutputStream(); 482 Thread.sleep(1000); 483 is.skip(is.available()); 484 os.write(send); 485 os.flush(); 486 Thread.sleep(1000); 487 if(is.available() == 6) 488 { 489 is.read(buffread); 490 491 if(equalBytes(buffread, expected)) 492 negotiation1_ok = true; 493 494 if(negotiation1_ok) 495 { 496 negotiation1_ok = false; 497 os.write(send2); 498 os.flush(); 499 Thread.sleep(1000); 500 if(is.available() == 3) 501 { 502 is.read(buffread2); 503 if(equalBytes(buffread2, expected2)) 504 negotiation1_ok = true; 505 } 506 } 507 } 508 509 assertTrue(negotiation1_ok); 510 assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.ECHO)); 511 } 512 513 /*** 514 * test of option negotiation notification 515 ***/ 516 public void testNotification() throws Exception 517 { 518 byte buffread1[] = new byte[6]; 519 byte send1[] = 520 { 521 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, (byte) 15, 522 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, (byte) 15, 523 }; 524 525 byte buffread2[] = new byte[9]; 526 byte send2[] = 527 { 528 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, 529 (byte) TelnetOption.TERMINAL_TYPE, 530 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, 531 (byte) TelnetOption.ECHO, 532 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, 533 (byte) TelnetOption.SUPPRESS_GO_AHEAD, 534 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, 535 (byte) TelnetOption.SUPPRESS_GO_AHEAD 536 }; 537 538 byte buffread2b[] = new byte[11]; 539 540 541 numdo = 0; 542 numdont = 0; 543 numwill = 0; 544 numwont = 0; 545 OPTIONS.client.registerNotifHandler(this); 546 547 InputStream is1 = STANDARD.server.getInputStream(); 548 OutputStream os1 = STANDARD.server.getOutputStream(); 549 is1.skip(is1.available()); 550 os1.write(send1); 551 os1.flush(); 552 Thread.sleep(500); 553 if(is1.available() > 0) 554 { 555 is1.read(buffread1); 556 } 557 558 InputStream is2 = OPTIONS.server.getInputStream(); 559 OutputStream os2 = OPTIONS.server.getOutputStream(); 560 Thread.sleep(500); 561 is2.skip(is2.available()); 562 os2.write(send2); 563 os2.flush(); 564 Thread.sleep(500); 565 if(is2.available() > 0) 566 { 567 is2.read(buffread2); 568 Thread.sleep(1000); 569 if(is2.available() > 0) 570 { 571 is2.read(buffread2b); 572 } 573 } 574 575 576 assertTrue(numdo == 2); 577 assertTrue(numdont == 1); 578 assertTrue(numwont == 1); 579 assertTrue(numwill == 0); 580 } 581 582 583 /*** 584 * protocol compliance test in case of option handler removal 585 ***/ 586 public void testDeleteOptionHandler() throws Exception 587 { 588 boolean remove_ok = false; 589 boolean remove_invalid_ok1 = false; 590 boolean remove_invalid_ok2 = false; 591 592 byte buffread[] = new byte[6]; 593 byte send[] = 594 { 595 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, 596 (byte) TelnetOption.ECHO, 597 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, 598 (byte) TelnetOption.SUPPRESS_GO_AHEAD, 599 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, 600 (byte) TelnetOption.SUPPRESS_GO_AHEAD 601 }; 602 603 byte expected[] = 604 { 605 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, 606 (byte) TelnetOption.SUPPRESS_GO_AHEAD, 607 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, 608 (byte) TelnetOption.SUPPRESS_GO_AHEAD 609 }; 610 611 InputStream is = OPTIONS.server.getInputStream(); 612 OutputStream os = OPTIONS.server.getOutputStream(); 613 Thread.sleep(1000); 614 is.skip(is.available()); 615 os.write(send); 616 os.flush(); 617 Thread.sleep(1000); 618 if(is.available() == 0) 619 { 620 OPTIONS.client.deleteOptionHandler(TelnetOption.SUPPRESS_GO_AHEAD); 621 Thread.sleep(1000); 622 if(is.available() == 6) 623 { 624 is.read(buffread); 625 if(equalBytes(buffread, expected)) 626 remove_ok = true; 627 } 628 } 629 630 try 631 { 632 OPTIONS.client.deleteOptionHandler(TelnetOption.SUPPRESS_GO_AHEAD); 633 } 634 catch (Exception e) 635 { 636 remove_invalid_ok1 = true; 637 } 638 639 try 640 { 641 OPTIONS.client.deleteOptionHandler(550); 642 } 643 catch (Exception e) 644 { 645 remove_invalid_ok2 = true; 646 } 647 648 assertTrue(remove_ok); 649 assertTrue(remove_invalid_ok1); 650 assertTrue(remove_invalid_ok2); 651 assertTrue(OPTIONS.client.getLocalOptionState(TelnetOption.ECHO)); 652 assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.SUPPRESS_GO_AHEAD)); 653 assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.SUPPRESS_GO_AHEAD)); 654 } 655 656 657 /*** 658 * test of AYT functionality 659 ***/ 660 public void testAYT() throws Exception 661 { 662 boolean ayt_true_ok = false; 663 boolean ayt_false_ok = false; 664 665 666 byte AYT[] = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.AYT }; 667 byte response[] = 668 { (byte) '[', (byte) 'Y', (byte) 'e', (byte) 's', (byte) ']' }; 669 String inputs[] = new String[1]; 670 String outputs[] = new String[1]; 671 inputs[0] = new String (AYT); 672 outputs[0] = new String (response); 673 674 675 OutputStream os = ANSI.server.getOutputStream(); 676 InputStream is = ANSI.server.getInputStream(); 677 TelnetTestResponder tr = 678 new TelnetTestResponder(is, os, inputs, outputs, 30000); 679 assertNotNull(tr); 680 boolean res1 = ANSI.client.sendAYT(2000); 681 682 if(res1 == true) 683 ayt_true_ok=true; 684 685 Thread.sleep(1000); 686 is.skip(is.available()); 687 688 boolean res2 = ANSI.client.sendAYT(2000); 689 690 if(res2 == false) 691 ayt_false_ok=true; 692 693 694 assertTrue(ayt_true_ok); 695 assertTrue(ayt_false_ok); 696 } 697 698 /*** 699 * test of Spy functionality 700 ***/ 701 public void testSpy() throws Exception 702 { 703 boolean test1spy_ok = false; 704 boolean test2spy_ok = false; 705 boolean stopspy_ok = false; 706 byte expected1[] = 707 { (byte) 't', (byte) 'e', (byte) 's', (byte) 't', (byte) '1' }; 708 byte expected2[] = 709 { (byte) 't', (byte) 'e', (byte) 's', (byte) 't', (byte) '2' }; 710 711 712 PipedOutputStream po = new PipedOutputStream(); 713 PipedInputStream pi = new PipedInputStream(po); 714 715 OutputStream os = STANDARD.server.getOutputStream(); 716 OutputStream ostc = STANDARD.client.getOutputStream(); 717 718 STANDARD.client.registerSpyStream(po); 719 720 os.write("test1".getBytes()); 721 os.flush(); 722 723 Thread.sleep(1000); 724 byte buffer[] = new byte[5]; 725 726 if(pi.available() == 5) 727 { 728 pi.read(buffer); 729 if(equalBytes(buffer, expected1)) 730 test1spy_ok = true; 731 } 732 733 ostc.write("test2".getBytes()); 734 ostc.flush(); 735 736 Thread.sleep(1000); 737 738 if(pi.available() == 5) 739 { 740 pi.read(buffer); 741 if(equalBytes(buffer, expected2)) 742 test2spy_ok = true; 743 } 744 745 STANDARD.client.stopSpyStream(); 746 os.write("test1".getBytes()); 747 os.flush(); 748 ostc.write("test2".getBytes()); 749 ostc.flush(); 750 Thread.sleep(1000); 751 if(pi.available() == 0) 752 { 753 stopspy_ok = true; 754 } 755 756 757 assertTrue(test1spy_ok); 758 assertTrue(test2spy_ok); 759 assertTrue(stopspy_ok); 760 } 761 762 /*** 763 * test of setReaderThread 764 ***/ 765 public void testSetReaderThread() throws Exception 766 { 767 boolean negotiation1_ok = false; 768 boolean negotiation2_ok = false; 769 boolean read_ok = false; 770 byte buffread1[] = new byte[6]; 771 byte send1[] = 772 { 773 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, (byte) 15, 774 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, (byte) 15, 775 }; 776 byte expected1[] = 777 { 778 (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, (byte) 15, 779 (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, (byte) 15, 780 }; 781 782 783 InputStream is1 = NOREAD.server.getInputStream(); 784 OutputStream os1 = NOREAD.server.getOutputStream(); 785 is1.skip(is1.available()); 786 os1.write(send1); 787 os1.flush(); 788 os1.write("A".getBytes()); 789 os1.flush(); 790 Thread.sleep(1000); 791 InputStream instr = NOREAD.client.getInputStream(); 792 byte[] buff = new byte[4]; 793 int ret_read = 0; 794 795 ret_read = instr.read(buff); 796 if((ret_read == 1) && (buff[0] == 'A')) 797 { 798 read_ok = true; 799 } 800 801 // if(is1.available() == 6) 802 //{ 803 is1.read(buffread1); 804 805 if(equalBytes(buffread1, expected1)) 806 negotiation1_ok = true; 807 //} 808 809 810 InputStream is2 = STANDARD.server.getInputStream(); 811 OutputStream os2 = STANDARD.server.getOutputStream(); 812 Thread.sleep(1000); 813 is2.skip(is2.available()); 814 os2.write(send1); 815 os2.flush(); 816 Thread.sleep(1000); 817 //if(is2.available() == 6) 818 //{ 819 is2.read(buffread1); 820 821 if(equalBytes(buffread1, expected1)) 822 negotiation2_ok = true; 823 //} 824 825 assertTrue(!NOREAD.client.getReaderThread()); 826 assertTrue(STANDARD.client.getReaderThread()); 827 assertTrue("Expected read_ok to be true, got " + read_ok, read_ok); 828 assertTrue("Expected negotiation1_ok to be true, got " + negotiation1_ok, negotiation1_ok); 829 assertTrue("Expected negotiation2_ok to be true, got " + negotiation2_ok, negotiation2_ok); 830 } 831 832 833 /*** 834 * Helper method. compares two arrays of int 835 ***/ 836 protected boolean equalBytes(byte a1[], byte a2[]) 837 { 838 if(a1.length != a2.length) 839 { 840 return(false); 841 } 842 else 843 { 844 boolean result = true; 845 for(int ii=0; ii<a1.length; ii++) 846 { 847 848 if(a1[ii]!= a2[ii]) 849 result = false; 850 } 851 return(result); 852 } 853 } 854 855 /*** 856 * Callback method called when TelnetClient receives an option 857 * negotiation command. 858 * <p> 859 * @param negotiation_code - type of negotiation command received 860 * (RECEIVED_DO, RECEIVED_DONT, RECEIVED_WILL, RECEIVED_WONT) 861 * <p> 862 * @param option_code - code of the option negotiated 863 * <p> 864 ***/ 865 public void receivedNegotiation(int negotiation_code, int option_code) 866 { 867 if(negotiation_code == TelnetNotificationHandler.RECEIVED_DO) 868 { 869 numdo++; 870 } 871 else if(negotiation_code == TelnetNotificationHandler.RECEIVED_DONT) 872 { 873 numdont++; 874 } 875 else if(negotiation_code == TelnetNotificationHandler.RECEIVED_WILL) 876 { 877 numwill++; 878 } 879 else if(negotiation_code == TelnetNotificationHandler.RECEIVED_WONT) 880 { 881 numwont++; 882 } 883 } 884 885 }