| /* |
| * Copyright 2003-2004 The Apache Software Foundation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.commons.net.telnet; |
| import junit.framework.TestCase; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.PipedInputStream; |
| import java.io.PipedOutputStream; |
| |
| /*** |
| * JUnit test class for TelnetClient.s |
| * Implements protocol compliance tests |
| * <p> |
| * @author Bruno D'Avanzo |
| ***/ |
| public class TelnetClientTest |
| extends TestCase implements TelnetNotificationHandler |
| { |
| /** |
| * Handy holder to hold both sides of the connection |
| * used in testing for clarity. |
| */ |
| private class TestConnection { |
| TelnetTestSimpleServer server; |
| TelnetClient client; |
| int port; |
| TestConnection( |
| TelnetTestSimpleServer server, |
| TelnetClient client, |
| int port) |
| { |
| this.server = server; |
| this.client = client; |
| this.port = port; |
| } |
| protected void close() { |
| TelnetClientTest.this.closeConnection( |
| this.server, this.client, this.port); |
| } |
| } |
| |
| // four connections with different properties |
| // to use in tests. |
| private TestConnection STANDARD; |
| private TestConnection OPTIONS; |
| private TestConnection ANSI; |
| private TestConnection NOREAD; |
| |
| private int NUM_CONNECTIONS = 4; |
| |
| |
| protected int numdo = 0; |
| protected int numdont = 0; |
| protected int numwill = 0; |
| protected int numwont = 0; |
| |
| /*** |
| * main for running the test. |
| ***/ |
| public static void main(String args[]) |
| { |
| junit.textui.TestRunner.run(TelnetClientTest.class); |
| } |
| |
| /*** |
| * open connections needed for the tests for the test. |
| ***/ |
| protected void setUp() throws Exception |
| { |
| super.setUp(); |
| for (int port = 3333, socket = 0; socket < NUM_CONNECTIONS && port < 4000; port++) |
| { |
| TelnetTestSimpleServer server = null; |
| TelnetClient client = null; |
| try { |
| server = new TelnetTestSimpleServer(port); |
| switch (socket) { |
| case 0: |
| client = new TelnetClient(); |
| // redundant but makes code clearer. |
| client.setReaderThread(true); |
| break; |
| case 1: |
| client = new TelnetClient(); |
| TerminalTypeOptionHandler ttopt = |
| new TerminalTypeOptionHandler("VT100", false, false, true, false); |
| EchoOptionHandler echoopt = |
| new EchoOptionHandler(true, false, true, false); |
| SuppressGAOptionHandler gaopt = |
| new SuppressGAOptionHandler(true, true, true, true); |
| |
| client.addOptionHandler(ttopt); |
| client.addOptionHandler(echoopt); |
| client.addOptionHandler(gaopt); |
| break; |
| case 2: |
| client = new TelnetClient("ANSI"); |
| break; |
| case 3: |
| client = new TelnetClient(); |
| client.setReaderThread(false); |
| break; |
| } |
| client.connect("127.0.0.1", port); |
| switch (socket) { |
| case 0: |
| STANDARD = new TestConnection(server, client, port); |
| break; |
| case 1: |
| OPTIONS = new TestConnection(server, client, port); |
| break; |
| case 2: |
| ANSI = new TestConnection(server, client, port); |
| break; |
| case 3: |
| NOREAD = new TestConnection(server, client, port); |
| break; |
| |
| } |
| |
| // only increment socket number on success |
| socket++; |
| } catch (IOException e) { |
| closeConnection(server, client, port); |
| System.err.println("failed to open client-server connection on port " + port); |
| } |
| } |
| Thread.sleep(1000); |
| } |
| |
| /* |
| * @throws java.lang.Exception |
| */ |
| protected void tearDown() throws Exception { |
| NOREAD.close(); |
| ANSI.close(); |
| OPTIONS.close(); |
| STANDARD.close(); |
| try { |
| Thread.sleep(1000); |
| } catch (InterruptedException ie) { |
| //do nothing |
| } |
| super.tearDown(); |
| } |
| |
| |
| |
| void closeConnection(TelnetTestSimpleServer server, TelnetClient client, int port) { |
| if (server != null) { |
| server.disconnect(); |
| server.stop(); |
| } |
| try { |
| if (client != null) { |
| client.disconnect(); |
| } |
| } catch (IOException e) { |
| System.err.println("failed to close client-server connection on port " + port); |
| System.err.println("ERROR in closeConnection(), "+ e.getMessage()); |
| } |
| |
| } |
| |
| /*** |
| * tests the initial condition of the sessions |
| ***/ |
| public void testInitial() throws Exception |
| { |
| boolean connect1_ok = false; |
| boolean connect2_ok = false; |
| boolean connect3_ok = false; |
| boolean init2_ok = false; |
| boolean add_invalid_ok1 = false; |
| boolean add_invalid_ok2 = false; |
| byte buffread2[] = new byte[9]; |
| byte expected2[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, |
| (byte) TelnetOption.ECHO, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD, |
| }; |
| |
| SimpleOptionHandler hand = new SimpleOptionHandler(550); |
| try |
| { |
| STANDARD.client.addOptionHandler(hand); |
| } |
| catch (Exception e) |
| { |
| add_invalid_ok1 = true; |
| } |
| |
| try |
| { |
| OPTIONS.client.addOptionHandler(hand); |
| } |
| catch (Exception e) |
| { |
| add_invalid_ok2 = true; |
| } |
| |
| InputStream is1 = STANDARD.server.getInputStream(); |
| Thread.sleep(1000); |
| if(is1.available() == 0) |
| { |
| connect1_ok = true; |
| } |
| |
| Thread.sleep(1000); |
| InputStream is2 = OPTIONS.server.getInputStream(); |
| if(is2.available() == 9) |
| { |
| is2.read(buffread2); |
| connect2_ok = true; |
| |
| if(equalBytes(buffread2, expected2)) |
| init2_ok = true; |
| } |
| |
| InputStream is3 = ANSI.server.getInputStream(); |
| Thread.sleep(1000); |
| if(is3.available() == 0) |
| { |
| connect3_ok = true; |
| } |
| |
| |
| assertTrue(connect1_ok); |
| assertTrue(connect2_ok); |
| assertTrue(connect3_ok); |
| assertTrue(!STANDARD.client.getLocalOptionState(TelnetOption.ECHO)); |
| assertTrue(!STANDARD.client.getRemoteOptionState(TelnetOption.ECHO)); |
| assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.ECHO)); |
| assertTrue(!OPTIONS.client.getRemoteOptionState(TelnetOption.ECHO)); |
| assertTrue(!ANSI.client.getLocalOptionState(TelnetOption.TERMINAL_TYPE)); |
| assertTrue(!ANSI.client.getRemoteOptionState(TelnetOption.TERMINAL_TYPE)); |
| assertTrue(init2_ok); |
| assertTrue(add_invalid_ok1); |
| assertTrue(add_invalid_ok2); |
| } |
| |
| /*** |
| * protocol compliance test for option negotiation |
| ***/ |
| public void testOptionNegotiation() throws Exception |
| { |
| boolean negotiation1_ok = false; |
| byte buffread1[] = new byte[6]; |
| byte send1[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, (byte) 15, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, (byte) 15, |
| }; |
| byte expected1[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, (byte) 15, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, (byte) 15, |
| }; |
| |
| boolean negotiation2_ok = false; |
| byte buffread2[] = new byte[9]; |
| byte send2[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, |
| (byte) TelnetOption.TERMINAL_TYPE, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, |
| (byte) TelnetOption.ECHO, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD |
| }; |
| byte expected2[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, |
| (byte) TelnetOption.TERMINAL_TYPE, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, |
| (byte) TelnetOption.ECHO, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD |
| }; |
| |
| byte buffread2b[] = new byte[11]; |
| byte send2b[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.SB, |
| (byte) TelnetOption.TERMINAL_TYPE, |
| (byte) 1, (byte) TelnetCommand.IAC, (byte) TelnetCommand.SE, |
| }; |
| byte expected2b[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.SB, |
| (byte) TelnetOption.TERMINAL_TYPE, |
| (byte) 0, (byte) 'V', (byte) 'T', (byte) '1', (byte) '0', |
| (byte) '0', |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.SE, |
| }; |
| |
| boolean negotiation3_ok = false; |
| byte buffread3[] = new byte[6]; |
| byte send3[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, |
| (byte) TelnetOption.TERMINAL_TYPE, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD |
| }; |
| byte expected3[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, |
| (byte) TelnetOption.TERMINAL_TYPE, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD |
| }; |
| byte buffread3b[] = new byte[10]; |
| byte send3b[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.SB, |
| (byte) TelnetOption.TERMINAL_TYPE, |
| (byte) 1, (byte) TelnetCommand.IAC, (byte) TelnetCommand.SE, |
| }; |
| byte expected3b[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.SB, |
| (byte) TelnetOption.TERMINAL_TYPE, |
| (byte) 0, (byte) 'A', (byte) 'N', (byte) 'S', (byte) 'I', |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.SE, |
| }; |
| |
| |
| InputStream is1 = STANDARD.server.getInputStream(); |
| OutputStream os1 = STANDARD.server.getOutputStream(); |
| is1.skip(is1.available()); |
| os1.write(send1); |
| os1.flush(); |
| Thread.sleep(1000); |
| if(is1.available() == 6) |
| { |
| is1.read(buffread1); |
| |
| if(equalBytes(buffread1, expected1)) |
| negotiation1_ok = true; |
| } |
| |
| InputStream is2 = OPTIONS.server.getInputStream(); |
| OutputStream os2 = OPTIONS.server.getOutputStream(); |
| Thread.sleep(1000); |
| is2.skip(is2.available()); |
| os2.write(send2); |
| os2.flush(); |
| Thread.sleep(1000); |
| if(is2.available() == 9) |
| { |
| is2.read(buffread2); |
| |
| if(equalBytes(buffread2, expected2)) |
| negotiation2_ok = true; |
| |
| if(negotiation2_ok) |
| { |
| negotiation2_ok = false; |
| os2.write(send2b); |
| os2.flush(); |
| Thread.sleep(1000); |
| if(is2.available() == 11) |
| { |
| is2.read(buffread2b); |
| |
| if(equalBytes(buffread2b, expected2b)) |
| negotiation2_ok = true; |
| } |
| } |
| } |
| |
| InputStream is3 = ANSI.server.getInputStream(); |
| OutputStream os3 = ANSI.server.getOutputStream(); |
| Thread.sleep(1000); |
| is3.skip(is3.available()); |
| os3.write(send3); |
| os3.flush(); |
| Thread.sleep(1000); |
| if(is3.available() == 6) |
| { |
| is3.read(buffread3); |
| |
| if(equalBytes(buffread3, expected3)) |
| negotiation3_ok = true; |
| |
| if(negotiation3_ok) |
| { |
| negotiation3_ok = false; |
| os3.write(send3b); |
| os3.flush(); |
| Thread.sleep(1000); |
| if(is3.available() == 10) |
| { |
| is3.read(buffread3b); |
| if(equalBytes(buffread3b, expected3b)) |
| negotiation3_ok = true; |
| } |
| } |
| } |
| |
| assertTrue(negotiation1_ok); |
| assertTrue(negotiation2_ok); |
| assertTrue(negotiation3_ok); |
| assertTrue(!STANDARD.client.getLocalOptionState(15)); |
| assertTrue(!STANDARD.client.getRemoteOptionState(15)); |
| assertTrue(!STANDARD.client.getLocalOptionState(TelnetOption.TERMINAL_TYPE)); |
| assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.ECHO)); |
| assertTrue(!OPTIONS.client.getRemoteOptionState(TelnetOption.ECHO)); |
| assertTrue(OPTIONS.client.getLocalOptionState(TelnetOption.SUPPRESS_GO_AHEAD)); |
| assertTrue(!OPTIONS.client.getRemoteOptionState(TelnetOption.SUPPRESS_GO_AHEAD)); |
| assertTrue(OPTIONS.client.getLocalOptionState(TelnetOption.TERMINAL_TYPE)); |
| assertTrue(ANSI.client.getLocalOptionState(TelnetOption.TERMINAL_TYPE)); |
| assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.ECHO)); |
| } |
| |
| |
| /*** |
| * protocol compliance test for option renegotiation |
| ***/ |
| public void testOptionRenegotiation() throws Exception |
| { |
| boolean negotiation1_ok = false; |
| |
| byte buffread[] = new byte[6]; |
| byte send[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, |
| (byte) TelnetOption.ECHO, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD |
| }; |
| byte expected[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD |
| }; |
| |
| byte buffread2[] = new byte[3]; |
| byte send2[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, |
| (byte) TelnetOption.ECHO, |
| }; |
| byte expected2[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, |
| (byte) TelnetOption.ECHO, |
| }; |
| |
| |
| InputStream is = OPTIONS.server.getInputStream(); |
| OutputStream os = OPTIONS.server.getOutputStream(); |
| Thread.sleep(1000); |
| is.skip(is.available()); |
| os.write(send); |
| os.flush(); |
| Thread.sleep(1000); |
| if(is.available() == 6) |
| { |
| is.read(buffread); |
| |
| if(equalBytes(buffread, expected)) |
| negotiation1_ok = true; |
| |
| if(negotiation1_ok) |
| { |
| negotiation1_ok = false; |
| os.write(send2); |
| os.flush(); |
| Thread.sleep(1000); |
| if(is.available() == 3) |
| { |
| is.read(buffread2); |
| if(equalBytes(buffread2, expected2)) |
| negotiation1_ok = true; |
| } |
| } |
| } |
| |
| assertTrue(negotiation1_ok); |
| assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.ECHO)); |
| } |
| |
| /*** |
| * test of option negotiation notification |
| ***/ |
| public void testNotification() throws Exception |
| { |
| byte buffread1[] = new byte[6]; |
| byte send1[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, (byte) 15, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, (byte) 15, |
| }; |
| |
| byte buffread2[] = new byte[9]; |
| byte send2[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, |
| (byte) TelnetOption.TERMINAL_TYPE, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, |
| (byte) TelnetOption.ECHO, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD |
| }; |
| |
| byte buffread2b[] = new byte[11]; |
| |
| |
| numdo = 0; |
| numdont = 0; |
| numwill = 0; |
| numwont = 0; |
| OPTIONS.client.registerNotifHandler(this); |
| |
| InputStream is1 = STANDARD.server.getInputStream(); |
| OutputStream os1 = STANDARD.server.getOutputStream(); |
| is1.skip(is1.available()); |
| os1.write(send1); |
| os1.flush(); |
| Thread.sleep(500); |
| if(is1.available() > 0) |
| { |
| is1.read(buffread1); |
| } |
| |
| InputStream is2 = OPTIONS.server.getInputStream(); |
| OutputStream os2 = OPTIONS.server.getOutputStream(); |
| Thread.sleep(500); |
| is2.skip(is2.available()); |
| os2.write(send2); |
| os2.flush(); |
| Thread.sleep(500); |
| if(is2.available() > 0) |
| { |
| is2.read(buffread2); |
| Thread.sleep(1000); |
| if(is2.available() > 0) |
| { |
| is2.read(buffread2b); |
| } |
| } |
| |
| |
| assertTrue(numdo == 2); |
| assertTrue(numdont == 1); |
| assertTrue(numwont == 1); |
| assertTrue(numwill == 0); |
| } |
| |
| |
| /*** |
| * protocol compliance test in case of option handler removal |
| ***/ |
| public void testDeleteOptionHandler() throws Exception |
| { |
| boolean remove_ok = false; |
| boolean remove_invalid_ok1 = false; |
| boolean remove_invalid_ok2 = false; |
| |
| byte buffread[] = new byte[6]; |
| byte send[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, |
| (byte) TelnetOption.ECHO, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD |
| }; |
| |
| byte expected[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, |
| (byte) TelnetOption.SUPPRESS_GO_AHEAD |
| }; |
| |
| InputStream is = OPTIONS.server.getInputStream(); |
| OutputStream os = OPTIONS.server.getOutputStream(); |
| Thread.sleep(1000); |
| is.skip(is.available()); |
| os.write(send); |
| os.flush(); |
| Thread.sleep(1000); |
| if(is.available() == 0) |
| { |
| OPTIONS.client.deleteOptionHandler(TelnetOption.SUPPRESS_GO_AHEAD); |
| Thread.sleep(1000); |
| if(is.available() == 6) |
| { |
| is.read(buffread); |
| if(equalBytes(buffread, expected)) |
| remove_ok = true; |
| } |
| } |
| |
| try |
| { |
| OPTIONS.client.deleteOptionHandler(TelnetOption.SUPPRESS_GO_AHEAD); |
| } |
| catch (Exception e) |
| { |
| remove_invalid_ok1 = true; |
| } |
| |
| try |
| { |
| OPTIONS.client.deleteOptionHandler(550); |
| } |
| catch (Exception e) |
| { |
| remove_invalid_ok2 = true; |
| } |
| |
| assertTrue(remove_ok); |
| assertTrue(remove_invalid_ok1); |
| assertTrue(remove_invalid_ok2); |
| assertTrue(OPTIONS.client.getLocalOptionState(TelnetOption.ECHO)); |
| assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.SUPPRESS_GO_AHEAD)); |
| assertTrue(!OPTIONS.client.getLocalOptionState(TelnetOption.SUPPRESS_GO_AHEAD)); |
| } |
| |
| |
| /*** |
| * test of AYT functionality |
| ***/ |
| public void testAYT() throws Exception |
| { |
| boolean ayt_true_ok = false; |
| boolean ayt_false_ok = false; |
| |
| |
| byte AYT[] = { (byte) TelnetCommand.IAC, (byte) TelnetCommand.AYT }; |
| byte response[] = |
| { (byte) '[', (byte) 'Y', (byte) 'e', (byte) 's', (byte) ']' }; |
| String inputs[] = new String[1]; |
| String outputs[] = new String[1]; |
| inputs[0] = new String (AYT); |
| outputs[0] = new String (response); |
| |
| |
| OutputStream os = ANSI.server.getOutputStream(); |
| InputStream is = ANSI.server.getInputStream(); |
| TelnetTestResponder tr = |
| new TelnetTestResponder(is, os, inputs, outputs, 30000); |
| assertNotNull(tr); |
| boolean res1 = ANSI.client.sendAYT(2000); |
| |
| if(res1 == true) |
| ayt_true_ok=true; |
| |
| Thread.sleep(1000); |
| is.skip(is.available()); |
| |
| boolean res2 = ANSI.client.sendAYT(2000); |
| |
| if(res2 == false) |
| ayt_false_ok=true; |
| |
| |
| assertTrue(ayt_true_ok); |
| assertTrue(ayt_false_ok); |
| } |
| |
| /*** |
| * test of Spy functionality |
| ***/ |
| public void testSpy() throws Exception |
| { |
| boolean test1spy_ok = false; |
| boolean test2spy_ok = false; |
| boolean stopspy_ok = false; |
| byte expected1[] = |
| { (byte) 't', (byte) 'e', (byte) 's', (byte) 't', (byte) '1' }; |
| byte expected2[] = |
| { (byte) 't', (byte) 'e', (byte) 's', (byte) 't', (byte) '2' }; |
| |
| |
| PipedOutputStream po = new PipedOutputStream(); |
| PipedInputStream pi = new PipedInputStream(po); |
| |
| OutputStream os = STANDARD.server.getOutputStream(); |
| OutputStream ostc = STANDARD.client.getOutputStream(); |
| |
| STANDARD.client.registerSpyStream(po); |
| |
| os.write("test1".getBytes()); |
| os.flush(); |
| |
| Thread.sleep(1000); |
| byte buffer[] = new byte[5]; |
| |
| if(pi.available() == 5) |
| { |
| pi.read(buffer); |
| if(equalBytes(buffer, expected1)) |
| test1spy_ok = true; |
| } |
| |
| ostc.write("test2".getBytes()); |
| ostc.flush(); |
| |
| Thread.sleep(1000); |
| |
| if(pi.available() == 5) |
| { |
| pi.read(buffer); |
| if(equalBytes(buffer, expected2)) |
| test2spy_ok = true; |
| } |
| |
| STANDARD.client.stopSpyStream(); |
| os.write("test1".getBytes()); |
| os.flush(); |
| ostc.write("test2".getBytes()); |
| ostc.flush(); |
| Thread.sleep(1000); |
| if(pi.available() == 0) |
| { |
| stopspy_ok = true; |
| } |
| |
| |
| assertTrue(test1spy_ok); |
| assertTrue(test2spy_ok); |
| assertTrue(stopspy_ok); |
| } |
| |
| /*** |
| * test of setReaderThread |
| ***/ |
| public void testSetReaderThread() throws Exception |
| { |
| boolean negotiation1_ok = false; |
| boolean negotiation2_ok = false; |
| boolean read_ok = false; |
| byte buffread1[] = new byte[6]; |
| byte send1[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DO, (byte) 15, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WILL, (byte) 15, |
| }; |
| byte expected1[] = |
| { |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.WONT, (byte) 15, |
| (byte) TelnetCommand.IAC, (byte) TelnetCommand.DONT, (byte) 15, |
| }; |
| |
| |
| InputStream is1 = NOREAD.server.getInputStream(); |
| OutputStream os1 = NOREAD.server.getOutputStream(); |
| is1.skip(is1.available()); |
| os1.write(send1); |
| os1.flush(); |
| os1.write("A".getBytes()); |
| os1.flush(); |
| Thread.sleep(1000); |
| InputStream instr = NOREAD.client.getInputStream(); |
| byte[] buff = new byte[4]; |
| int ret_read = 0; |
| |
| ret_read = instr.read(buff); |
| if((ret_read == 1) && (buff[0] == 'A')) |
| { |
| read_ok = true; |
| } |
| |
| // if(is1.available() == 6) |
| //{ |
| is1.read(buffread1); |
| |
| if(equalBytes(buffread1, expected1)) |
| negotiation1_ok = true; |
| //} |
| |
| |
| InputStream is2 = STANDARD.server.getInputStream(); |
| OutputStream os2 = STANDARD.server.getOutputStream(); |
| Thread.sleep(1000); |
| is2.skip(is2.available()); |
| os2.write(send1); |
| os2.flush(); |
| Thread.sleep(1000); |
| //if(is2.available() == 6) |
| //{ |
| is2.read(buffread1); |
| |
| if(equalBytes(buffread1, expected1)) |
| negotiation2_ok = true; |
| //} |
| |
| assertTrue(!NOREAD.client.getReaderThread()); |
| assertTrue(STANDARD.client.getReaderThread()); |
| assertTrue("Expected read_ok to be true, got " + read_ok, read_ok); |
| assertTrue("Expected negotiation1_ok to be true, got " + negotiation1_ok, negotiation1_ok); |
| assertTrue("Expected negotiation2_ok to be true, got " + negotiation2_ok, negotiation2_ok); |
| } |
| |
| |
| /*** |
| * Helper method. compares two arrays of int |
| ***/ |
| protected boolean equalBytes(byte a1[], byte a2[]) |
| { |
| if(a1.length != a2.length) |
| { |
| return(false); |
| } |
| else |
| { |
| boolean result = true; |
| for(int ii=0; ii<a1.length; ii++) |
| { |
| |
| if(a1[ii]!= a2[ii]) |
| result = false; |
| } |
| return(result); |
| } |
| } |
| |
| /*** |
| * Callback method called when TelnetClient receives an option |
| * negotiation command. |
| * <p> |
| * @param negotiation_code - type of negotiation command received |
| * (RECEIVED_DO, RECEIVED_DONT, RECEIVED_WILL, RECEIVED_WONT) |
| * <p> |
| * @param option_code - code of the option negotiated |
| * <p> |
| ***/ |
| public void receivedNegotiation(int negotiation_code, int option_code) |
| { |
| if(negotiation_code == TelnetNotificationHandler.RECEIVED_DO) |
| { |
| numdo++; |
| } |
| else if(negotiation_code == TelnetNotificationHandler.RECEIVED_DONT) |
| { |
| numdont++; |
| } |
| else if(negotiation_code == TelnetNotificationHandler.RECEIVED_WILL) |
| { |
| numwill++; |
| } |
| else if(negotiation_code == TelnetNotificationHandler.RECEIVED_WONT) |
| { |
| numwont++; |
| } |
| } |
| |
| } |
