View Javadoc
   /************************************************************
   *                     Copyright                            *
   * Portions of this software are Copyright (c) 1993 - 2002, *
   * Chad Z. Hower (Kudzu) and the Indy Pit Crew              *
   *  - http://www.nevrona.com/Indy/                          *
   ************************************************************/
   package org.indy;
   
   import java.io.BufferedInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InterruptedIOException;
  
  import java.net.Socket;
  
  import java.util.Random;
  
  import junit.framework.TestCase;
  
  import org.indy.io.IOHandlerSocket;
  import org.indy.io.PeerDisconnectedException;
  
  
  /***
   * DOCUMENT ME!
   *
   * @version $Revision$
   * @author $author$
   */
  public class TestTCPClient extends TestCase {
    /*
     *  Server Executors
     */
    final TCPServerExecuteListener ServerExecuteBound = new TCPServerExecuteListener() {
      public void onExecute(TCPServer sender, TCPServerConnection connection)
                     throws IndyException {
        try {
          String ip = connection.readLine();
          int port = 0;
  
          try {
            port = Integer.parseInt(connection.readLine());
          }
           catch (NumberFormatException nfe) {
            port = 0;
          }
  
          String peerIP = ((IOHandlerSocket) connection.getIOHandler()).getPeerIP();
          int peerPort = ((IOHandlerSocket) connection.getIOHandler()).getPeerPort();
  
          if (ip.equals(peerIP) && (port == peerPort)) {
            //System.err.println("WRITING DONE");
            connection.writeLine("DONE");
          }
          else {
            System.err.println("WRITING ERROR");
            connection.writeLine("ERROR");
          }
        }
         finally {
          connection.disconnect();
        }
      }
    };
  
    final TCPServerExecuteListener ServerExecuteConnectGetAll = 
        new TCPServerExecuteListener() {
      public void onExecute(TCPServer sender, TCPServerConnection connection)
                     throws IndyException {
        try {
          for (int i = 0; i < 4; i++) {
            connection.write(
                "ABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789_abcdefghijklmnopqrstuvwxyz");
          }
  
          connection.getIOHandler().flush();
        }
         finally {
          connection.disconnect();
        }
      }
    };
  
    final TCPServerExecuteListener ServerExecuteDisconnect = 
        new TCPServerExecuteListener() {
      public void onExecute(TCPServer sender, TCPServerConnection connection)
                     throws IndyException {
        try {
          Thread.currentThread().sleep(1000);
        }
         catch (InterruptedException ie) {
        }
  
        connection.disconnect();
      }
    };
  
    final TCPServerExecuteListener ServerExecuteNagle = new TCPServerExecuteListener() {
      public void onExecute(TCPServer sender, TCPServerConnection connection)
                    throws IndyException {
       try {
         String line = null;
 
         while (true) {
           if (connection.readLine().equals("DONE")) {
             break;
           }
         }
 
         for (int i = 0; i < 64; i++) {
           connection.writeLine("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
         }
 
         connection.writeLine("DONE");
       }
        finally {
         connection.disconnect();
       }
     }
   };
 
   final TCPServerExecuteListener ServerExecuteReadAll = 
       new TCPServerExecuteListener() {
     public void onExecute(TCPServer sender, TCPServerConnection connection)
                    throws IndyException {
       try {
         //while (connection.isConnected()) {
         //    connection.readFromStack(false);
         // }
         while (connection.isConnected()) {
           connection.allData();
         }
       }
        catch (Exception ex) {
         throw new IndyException(ex);
       }
     }
   };
 
   final TCPServerExecuteListener ServerExecuteReuse = new TCPServerExecuteListener() {
     public void onExecute(TCPServer sender, TCPServerConnection connection)
                    throws IndyException {
       if (connection.isConnected()) {
         connection.readLine();
         connection.writeLine("DONE");
       }
     }
   };
 
   TCPClient client = null;
   TCPServer server = new TCPServer();
 
   /***
    * Creates a new TestTCPClient object.
    *
    * @param s DOCUMENT ME!
    */
   public TestTCPClient(String s) {
     super(s);
   }
 
   /***
    *  The JUnit setup method
    */
   protected void setUp() {
     client = new TCPClient();
 
     //server.setDefaultPort(6666);
     try {
       server.setActive(true);
     }
      catch (Exception ex) {
       ex.printStackTrace();
       fail(ex.getMessage());
     }
   }
 
   /***
    *  Main method for individual runs
    *
    *@param  arg  The command line arguments
    */
   public static void main(String[] arg) {
     junit.swingui.TestRunner.run(TestTCPClient.class);
   }
 
   /***
    *  The teardown method for JUnit
    */
   public void tearDown() {
     try {
       if (client.isConnected()) {
         client.disconnect();
       }
 
       server.addServerExecuteListener(null);
       server.setActive(false);
     }
      catch (IndyException ie) {
       ie.printStackTrace();
     }
      finally {
       client = null;
     }
   }
 
   /***
    *  A unit test for JUnit
    */
   public void testClientReuse() {
     server.addServerExecuteListener(ServerExecuteReuse);
 
     client.setHost("127.0.0.1");
     client.setPort(6666);
 
     for (int i = 0; i < 5; i++) {
       try {
         System.err.println(i);
         client.connect();
         client.writeLine("QUIT\n");
 
         String data = client.readLine();
 
         System.err.println(data);
         assertEquals("Connection #" + i, "DONE", data);
       }
        catch (IndyException ie) {
         ie.printStackTrace();
         fail("Indy Exception thrown: " + ie.getMessage());
       }
        catch (Exception e) {
         e.printStackTrace();
       }
        finally {
         try {
           client.disconnect();
         }
          catch (IndyException ie) {
           ie.printStackTrace();
         }
       }
     }
   }
 
   /***
    *  A unit test for JUnit
    */
   public void testClientBound() {
     server.addServerExecuteListener(ServerExecuteBound);
 
 
     //while(true){}
     client.setHost("127.0.0.1");
     client.setPort(6666);
 
     client.setBoundIP("127.0.0.1");
     client.setBoundPort(0);
 
     try {
       client.connect();
       assertEquals("Testing Bound IP", "127.0.0.1", client.getBoundIP());
       client.writeLine(client.getBoundIP());
       client.writeLine(String.valueOf(client.getBoundPort()));
       assertEquals("Testing Server Receipt of Bound IP / Port", "DONE", 
                    client.readLine());
     }
      catch (IndyException ie) {
       ie.printStackTrace();
       fail("Indy Exception thrown: " + ie.getMessage());
     }
      finally {
       try {
         client.disconnect();
       }
        catch (IndyException ie) {
         ie.printStackTrace();
       }
     }
 
     client.setBoundIP(null);
 
     Random r = new Random();
 
     int port = 15000 + r.nextInt(10000);
     client.setBoundPort(port);
 
     try {
       client.connect();
       assertEquals("Testing Bound Port", port, client.getBoundPort());
       client.writeLine(client.getBoundIP());
       client.writeLine(String.valueOf(client.getBoundPort()));
       assertEquals("Testing Server Receipt of Bound IP / Port", "DONE", 
                    client.readLine());
     }
      catch (IndyException ie) {
       ie.printStackTrace();
       fail("Indy Exception thrown: " + ie.getMessage());
     }
      finally {
       try {
         client.disconnect();
       }
        catch (IndyException ie) {
         ie.printStackTrace();
       }
     }
 
     client.setBoundIP("127.0.0.1");
     client.setBoundPort(15000 + r.nextInt(10000));
 
     try {
       client.connect();
       assertEquals("Testing Bound IP and Port", "127.0.0.1", 
                    client.getBoundIP());
       client.writeLine(client.getBoundIP());
       client.writeLine(String.valueOf(client.getBoundPort()));
       assertEquals("Testing Server Receipt of Bound IP / Port", "DONE", 
                    client.readLine());
     }
      catch (IndyException ie) {
       ie.printStackTrace();
       fail("Indy Exception thrown: " + ie.getMessage());
     }
      finally {
       try {
         client.disconnect();
       }
        catch (IndyException ie) {
         ie.printStackTrace();
       }
     }
   }
 
   /***
    *  A unit test for JUnit
    */
   public void testClientConnectGetAll() {
     server.addServerExecuteListener(ServerExecuteConnectGetAll);
     client.setBoundIP(null);
     client.setBoundPort(0);
     client.setHost("127.0.0.1");
     client.setPort(6666);
 
     String s = client.connectAndGetAll();
 
 
     // System.err.println(s);
     assertEquals("Connect and get all test", 256, s.length());
   }
 
   // public void testClientNagle(){
   //  }
   // public void testClientConnectionTimeout(){}
 
   /***
    *  A unit test for JUnit
    */
 
   /* public void testClientForGracefulDisconnectOnly() {
        server.setExecutor(ServerExecuteDisconnect);
   
        client.setHost("127.0.0.1");
        client.setPort(6666);
   
        try {
            client.connect();
   
            client.checkForGracefulDisconnect(true);
   
        }
        catch (ConnectionClosedGracefullyException e) {
            e.printStackTrace();
        }
        catch (IndyException ie) {
            fail(ie.getMessage());
        }
        finally {
            try {
                client.disconnect();
            }
            catch (IndyException ide) {
                ide.printStackTrace();
            }
        }
    }*/
 
   /***
    *  Description of the Method
    */
   public void ntestSomething() {
     server.addServerExecuteListener(ServerExecuteReuse);
 
     try {
       Socket s = new Socket("127.0.0.1", 6666);
 
       InputStream inS = new BufferedInputStream(s.getInputStream());
 
       s.getOutputStream().write("Hello\n".getBytes());
       s.getInputStream().read(new byte[5], 0, 5);
 
       s.setSoTimeout(250);
 
       //long start = System.currentTimeMillis();
       while (inS.available() == 0) {
         try {
           inS.mark(0);
 
           int read = inS.read();
 
           System.err.println(read);
 
           if (read == -1) {
             break;
           }
           else {
             inS.reset();
           }
         }
          catch (InterruptedIOException iioe) {
           //iioe.printStackTrace();
         }
       }
 
       //System.err.println(((System.currentTimeMillis()-start) / 1000)  + " seconds");
     }
      catch (IOException ioe) {
       fail(ioe.getMessage());
     }
   }
 
   /***
    *  A unit test for JUnit
    */
   public void testClientForGracefulDisconnectRead() {
     server.addServerExecuteListener(ServerExecuteDisconnect);
 
     client.setHost("127.0.0.1");
     client.setPort(6666);
 
     try {
       client.setReadTimeOut(0);
       client.connect(1000);
 
       while (true) {
         client.readLine();
       }
     }
      catch (PeerDisconnectedException ide) {
       //ide.printStackTrace();
       return;
     }
      catch (IndyException ie) {
       fail(ie.getMessage());
     }
      finally {
       try {
         client.disconnect();
       }
        catch (IndyException ide) {
         ide.printStackTrace();
       }
     }
   }
 
   /***
    * DOCUMENT ME!
    */
   public void testClientTimeTests() {
   }
 }