tags/2.5/src/test/java/org/mockftpserver/core/session/DefaultSessionTest.java - platform/external/mockftpserver - Git at Google

 /*
  * Copyright 2007 the original author or authors.
  *
  * 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.mockftpserver.core.session;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.mockftpserver.core.MockFtpServerException;
 import org.mockftpserver.core.command.Command;
 import org.mockftpserver.core.socket.StubServerSocket;
 import org.mockftpserver.core.socket.StubServerSocketFactory;
 import org.mockftpserver.core.socket.StubSocket;
 import org.mockftpserver.core.socket.StubSocketFactory;
 import org.mockftpserver.core.util.AssertFailedException;
 import org.mockftpserver.test.AbstractTestCase;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.InetAddress;
 import java.net.SocketTimeoutException;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;

 /**
  * Tests for the DefaultSession class
  *
  * @version $Revision$ - $Date$
  *
  * @author Chris Mair
  */
 public final class DefaultSessionTest extends AbstractTestCase {

     private static final Logger LOG = LoggerFactory.getLogger(DefaultSessionTest.class);
     private static final String DATA = "sample data 123";
     private static final int PORT = 197;
     private static final String NAME1 = "name1";
     private static final String NAME2 = "name2";
     private static final Object VALUE = "value";

     private DefaultSession session;
     private ByteArrayOutputStream outputStream;
     private Map commandHandlerMap;
     private StubSocket stubSocket;
     private InetAddress clientHost;

     /**
      * Perform initialization before each test
      *
      * @see org.mockftpserver.test.AbstractTestCase#setUp()
      */
     protected void setUp() throws Exception {
         super.setUp();

         commandHandlerMap = new HashMap();
         outputStream = new ByteArrayOutputStream();
         session = createDefaultSession("");
         clientHost = InetAddress.getLocalHost();
     }

     /**
      * @see org.mockftpserver.test.AbstractTestCase#tearDown()
      */
     protected void tearDown() throws Exception {
         super.tearDown();
     }

     /**
      * Test the Constructor when the control socket is null
      */
     public void testConstructor_NullControlSocket() {
         try {
             new DefaultSession(null, commandHandlerMap);
             fail("Expected AssertFailedException");
         }
         catch (AssertFailedException expected) {
             LOG.info("Expected: " + expected);
         }
     }

     /**
      * Test the Constructor when the command handler Map is null
      */
     public void testConstructor_NullCommandHandlerMap() {
         try {
             new DefaultSession(stubSocket, null);
             fail("Expected AssertFailedException");
         }
         catch (AssertFailedException expected) {
             LOG.info("Expected: " + expected);
         }
     }

     /**
      * Test the setClientDataPort() method
      */
     public void testSetClientDataPort() {
         StubSocket stubSocket = createTestSocket("");
         StubSocketFactory stubSocketFactory = new StubSocketFactory(stubSocket);
         session.socketFactory = stubSocketFactory;
         session.setClientDataPort(PORT);
         session.setClientDataHost(clientHost);
         session.openDataConnection();
         assertEquals("data port", PORT, stubSocketFactory.requestedDataPort);
     }

     /**
      * Test the setClientDataPort() method after the session was in passive data mode
      */
     public void testSetClientDataPort_AfterPassiveConnectionMode() throws IOException {
         StubServerSocket stubServerSocket = new StubServerSocket(PORT);
         StubServerSocketFactory stubServerSocketFactory = new StubServerSocketFactory(stubServerSocket);
         session.serverSocketFactory = stubServerSocketFactory;

         session.switchToPassiveMode();
         assertFalse("server socket closed", stubServerSocket.isClosed());
         assertNotNull("passiveModeDataSocket", session.passiveModeDataSocket);
         session.setClientDataPort(PORT);

         // Make sure that any passive mode connection info is cleared out
         assertTrue("server socket closed", stubServerSocket.isClosed());
         assertNull("passiveModeDataSocket should be null", session.passiveModeDataSocket);
     }

     /**
      * Test the setClientHost() method
      */
     public void testSetClientHost() throws Exception {
         StubSocket stubSocket = createTestSocket("");
         StubSocketFactory stubSocketFactory = new StubSocketFactory(stubSocket);
         session.socketFactory = stubSocketFactory;
         session.setClientDataHost(clientHost);
         session.openDataConnection();
         assertEquals("client host", clientHost, stubSocketFactory.requestedHost);
     }

     /**
      * Test the openDataConnection(), setClientDataPort() and setClientDataHost() methods
      */
     public void testOpenDataConnection() {
         StubSocket stubSocket = createTestSocket("");
         StubSocketFactory stubSocketFactory = new StubSocketFactory(stubSocket);
         session.socketFactory = stubSocketFactory;

         // Use default client data port
         session.setClientDataHost(clientHost);
         session.openDataConnection();
         assertEquals("data port", DefaultSession.DEFAULT_CLIENT_DATA_PORT, stubSocketFactory.requestedDataPort);
         assertEquals("client host", clientHost, stubSocketFactory.requestedHost);

         // Set client data port explicitly
         session.setClientDataPort(PORT);
         session.setClientDataHost(clientHost);
         session.openDataConnection();
         assertEquals("data port", PORT, stubSocketFactory.requestedDataPort);
         assertEquals("client host", clientHost, stubSocketFactory.requestedHost);
     }

     /**
      * Test the OpenDataConnection method, when in passive mode and no incoming connection is
      * initiated
      */
     public void testOpenDataConnection_PassiveMode_NoConnection() throws IOException {

         StubServerSocket stubServerSocket = new StubServerSocket(PORT);
         StubServerSocketFactory stubServerSocketFactory = new StubServerSocketFactory(stubServerSocket);
         session.serverSocketFactory = stubServerSocketFactory;

         session.switchToPassiveMode();

         try {
             session.openDataConnection();
             fail("Expected MockFtpServerException");
         }
         catch (MockFtpServerException expected) {
             LOG.info("Expected: " + expected);
             assertSame("cause", SocketTimeoutException.class, expected.getCause().getClass());
         }
     }

     /**
      * Test the OpenDataConnection method, when the clientHost has not been set
      */
     public void testOpenDataConnection_NullClientHost() {
         try {
             session.openDataConnection();
             fail("Expected AssertFailedException");
         }
         catch (AssertFailedException expected) {
             LOG.info("Expected: " + expected);
         }
     }

     /**
      * Test the readData() method
      */
     public void testReadData() {
         StubSocket stubSocket = createTestSocket(DATA);
         session.socketFactory = new StubSocketFactory(stubSocket);
         session.setClientDataHost(clientHost);

         session.openDataConnection();
         byte[] data = session.readData();
         LOG.info("data=[" + new String(data) + "]");
         assertEquals("data", DATA.getBytes(), data);
     }

     /**
      * Test the readData() method after switching to passive mode
      */
     public void testReadData_PassiveMode() throws IOException {
         StubSocket stubSocket = createTestSocket(DATA);
         StubServerSocket stubServerSocket = new StubServerSocket(PORT, stubSocket);
         StubServerSocketFactory stubServerSocketFactory = new StubServerSocketFactory(stubServerSocket);
         session.serverSocketFactory = stubServerSocketFactory;

         session.switchToPassiveMode();
         session.openDataConnection();
         byte[] data = session.readData();
         LOG.info("data=[" + new String(data) + "]");
         assertEquals("data", DATA.getBytes(), data);
     }

     /**
      * Test the readData(int) method
      */
     public void testReadData_NumBytes() {
         final int NUM_BYTES = 5;
         final String EXPECTED_DATA = DATA.substring(0, NUM_BYTES);
         StubSocket stubSocket = createTestSocket(DATA);
         session.socketFactory = new StubSocketFactory(stubSocket);
         session.setClientDataHost(clientHost);

         session.openDataConnection();
         byte[] data = session.readData(NUM_BYTES);
         LOG.info("data=[" + new String(data) + "]");
         assertEquals("data", EXPECTED_DATA.getBytes(), data);
     }

     public void testReadData_NumBytes_AskForMoreBytesThanThereAre() {
         StubSocket stubSocket = createTestSocket(DATA);
         session.socketFactory = new StubSocketFactory(stubSocket);
         session.setClientDataHost(clientHost);

         session.openDataConnection();
         byte[] data = session.readData(10000);
         LOG.info("data=[" + new String(data) + "]");
         assertEquals("data", DATA.getBytes(), data);
     }

     /**
      * Test the closeDataConnection() method
      */
     public void testCloseDataConnection() {
         StubSocket stubSocket = createTestSocket(DATA);
         session.socketFactory = new StubSocketFactory(stubSocket);

         session.setClientDataHost(clientHost);
         session.openDataConnection();
         session.closeDataConnection();
         assertTrue("client data socket should be closed", stubSocket.isClosed());
     }

     /**
      * Test the switchToPassiveMode() method
      */
     public void testSwitchToPassiveMode() throws IOException {
         StubServerSocket stubServerSocket = new StubServerSocket(PORT);
         StubServerSocketFactory stubServerSocketFactory = new StubServerSocketFactory(stubServerSocket);
         session.serverSocketFactory = stubServerSocketFactory;

         assertNull("passiveModeDataSocket starts out null", session.passiveModeDataSocket);
         int port = session.switchToPassiveMode();
         assertSame("passiveModeDataSocket", stubServerSocket, session.passiveModeDataSocket);
         assertEquals("port", PORT, port);
     }

     /**
      * Test the getServerHost() method
      */
     public void testGetServerHost() {
         assertEquals("host", DEFAULT_HOST, session.getServerHost());
     }

     /**
      * Test the getClientHost() method when the session is not yet started
      */
     public void testGetClientHost_NotRunning() {
         assertNull("null", session.getClientHost());
     }

     /**
      * Test the parseCommand() method
      */
     public void testParseCommand() {
         Command command = session.parseCommand("LIST");
         assertEquals("command name", "LIST", command.getName());
         assertEquals("command parameters", EMPTY, command.getParameters());

         command = session.parseCommand("USER user123");
         assertEquals("command name", "USER", command.getName());
         assertEquals("command parameters", array("user123"), command.getParameters());

         command = session.parseCommand("PORT 127,0,0,1,17,37");
         assertEquals("command name", "PORT", command.getName());
         assertEquals("command parameters", new String[] { "127", "0", "0", "1", "17", "37" }, command
                 .getParameters());
     }

     /**
      * Test the parseCommand() method, passing in an empty command String
      */
     public void testParseCommand_EmptyCommandString() {
         try {
             session.parseCommand("");
             fail("Expected AssertFailedException");
         }
         catch (AssertFailedException expected) {
             LOG.info("Expected: " + expected);
         }
     }

     /**
      * Test the sendData() method, as well as the openDataConnection() and closeDataConnection()
      */
     public void testSendData() {
         StubSocket stubSocket = createTestSocket("1234567890 abcdef");
         session.socketFactory = new StubSocketFactory(stubSocket);

         session.setClientDataHost(clientHost);
         session.openDataConnection();
         session.sendData(DATA.getBytes(), DATA.length());
         LOG.info("output=[" + outputStream.toString() + "]");
         assertEquals("output", DATA, outputStream.toString());
     }

     /**
      * Test the SendData() method, passing in a null byte[]
      */
     public void testSendData_Null() {

         try {
             session.sendData(null, 1);
             fail("Expected AssertFailedException");
         }
         catch (AssertFailedException expected) {
             LOG.info("Expected: " + expected);
         }
     }

     /**
      * Test the SendReply(int,String) method, passing in an invalid reply code
      */
     public void testSendReply_InvalidReplyCode() {

         try {
             session.sendReply(-66, "text");
             fail("Expected AssertFailedException");
         }
         catch (AssertFailedException expected) {
             LOG.info("Expected: " + expected);
         }
     }

     /**
      * Test the getAttribute() and setAttribute() methods
      */
     public void testGetAndSetAttribute() {
         assertNull("name does not exist yet", session.getAttribute(NAME1));
         session.setAttribute(NAME1, VALUE);
         session.setAttribute(NAME2, null);
         assertEquals("NAME1", VALUE, session.getAttribute(NAME1));
         assertNull("NAME2", session.getAttribute(NAME2));
         assertNull("no such name", session.getAttribute("noSuchName"));
     }

     /**
      * Test the getAttribute() method, passing in a null name
      */
     public void testGetAttribute_Null() {
         try {
             session.getAttribute(null);
             fail("Expected AssertFailedException");
         }
         catch (AssertFailedException expected) {
             LOG.info("Expected: " + expected);
         }
     }

     /**
      * Test the setAttribute() method, passing in a null name
      */
     public void testSetAttribute_NullName() {
         try {
             session.setAttribute(null, VALUE);
             fail("Expected AssertFailedException");
         }
         catch (AssertFailedException expected) {
             LOG.info("Expected: " + expected);
         }
     }

     /**
      * Test the removeAttribute()
      */
     public void testRemoveAttribute() {
         session.removeAttribute("noSuchName");      // do nothing
         session.setAttribute(NAME1, VALUE);
         session.removeAttribute(NAME1);
         assertNull("NAME1", session.getAttribute(NAME1));
     }

     /**
      * Test the removeAttribute() method, passing in a null name
      */
     public void testRemoveAttribute_Null() {
         try {
             session.removeAttribute(null);
             fail("Expected AssertFailedException");
         }
         catch (AssertFailedException expected) {
             LOG.info("Expected: " + expected);
         }
     }

     /**
      * Test the getAttributeNames()
      */
     public void testGetAttributeNames() {
         assertEquals("No names yet", Collections.EMPTY_SET, session.getAttributeNames());
         session.setAttribute(NAME1, VALUE);
         assertEquals("1", Collections.singleton(NAME1), session.getAttributeNames());
         session.setAttribute(NAME2, VALUE);
         assertEquals("2", set(NAME1, NAME2), session.getAttributeNames());
     }

     // -------------------------------------------------------------------------
     // Internal Helper Methods
     // -------------------------------------------------------------------------

     /**
      * Create and return a DefaultSession object that reads from an InputStream with the specified
      * contents and writes to the predefined outputStrean ByteArrayOutputStream. Also, save the
      * StubSocket being used in the stubSocket attribute.
      *
      * @param inputStreamContents - the contents of the input stream
      * @return the DefaultSession
      */
     private DefaultSession createDefaultSession(String inputStreamContents) {
         stubSocket = createTestSocket(inputStreamContents);
         return new DefaultSession(stubSocket, commandHandlerMap);
     }

     /**
      * Create and return a StubSocket that reads from an InputStream with the specified contents and
      * writes to the predefined outputStrean ByteArrayOutputStream.
      *
      * @param inputStreamContents - the contents of the input stream
      * @return the StubSocket
      */
     private StubSocket createTestSocket(String inputStreamContents) {
         InputStream inputStream = new ByteArrayInputStream(inputStreamContents.getBytes());
         StubSocket stubSocket = new StubSocket(inputStream, outputStream);
         stubSocket._setLocalAddress(DEFAULT_HOST);
         return stubSocket;
     }

 }
	/*
	* Copyright 2007 the original author or authors.
	*
	* 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.mockftpserver.core.session;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;
	import org.mockftpserver.core.MockFtpServerException;
	import org.mockftpserver.core.command.Command;
	import org.mockftpserver.core.socket.StubServerSocket;
	import org.mockftpserver.core.socket.StubServerSocketFactory;
	import org.mockftpserver.core.socket.StubSocket;
	import org.mockftpserver.core.socket.StubSocketFactory;
	import org.mockftpserver.core.util.AssertFailedException;
	import org.mockftpserver.test.AbstractTestCase;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.net.InetAddress;
	import java.net.SocketTimeoutException;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.Map;

	/**
	* Tests for the DefaultSession class
	*
	* @version $Revision$ - $Date$
	*
	* @author Chris Mair
	*/
	public final class DefaultSessionTest extends AbstractTestCase {

	private static final Logger LOG = LoggerFactory.getLogger(DefaultSessionTest.class);
	private static final String DATA = "sample data 123";
	private static final int PORT = 197;
	private static final String NAME1 = "name1";
	private static final String NAME2 = "name2";
	private static final Object VALUE = "value";

	private DefaultSession session;
	private ByteArrayOutputStream outputStream;
	private Map commandHandlerMap;
	private StubSocket stubSocket;
	private InetAddress clientHost;

	/**
	* Perform initialization before each test
	*
	* @see org.mockftpserver.test.AbstractTestCase#setUp()
	*/
	protected void setUp() throws Exception {
	super.setUp();

	commandHandlerMap = new HashMap();
	outputStream = new ByteArrayOutputStream();
	session = createDefaultSession("");
	clientHost = InetAddress.getLocalHost();
	}

	/**
	* @see org.mockftpserver.test.AbstractTestCase#tearDown()
	*/
	protected void tearDown() throws Exception {
	super.tearDown();
	}

	/**
	* Test the Constructor when the control socket is null
	*/
	public void testConstructor_NullControlSocket() {
	try {
	new DefaultSession(null, commandHandlerMap);
	fail("Expected AssertFailedException");
	}
	catch (AssertFailedException expected) {
	LOG.info("Expected: " + expected);
	}
	}

	/**
	* Test the Constructor when the command handler Map is null
	*/
	public void testConstructor_NullCommandHandlerMap() {
	try {
	new DefaultSession(stubSocket, null);
	fail("Expected AssertFailedException");
	}
	catch (AssertFailedException expected) {
	LOG.info("Expected: " + expected);
	}
	}

	/**
	* Test the setClientDataPort() method
	*/
	public void testSetClientDataPort() {
	StubSocket stubSocket = createTestSocket("");
	StubSocketFactory stubSocketFactory = new StubSocketFactory(stubSocket);
	session.socketFactory = stubSocketFactory;
	session.setClientDataPort(PORT);
	session.setClientDataHost(clientHost);
	session.openDataConnection();
	assertEquals("data port", PORT, stubSocketFactory.requestedDataPort);
	}

	/**
	* Test the setClientDataPort() method after the session was in passive data mode
	*/
	public void testSetClientDataPort_AfterPassiveConnectionMode() throws IOException {
	StubServerSocket stubServerSocket = new StubServerSocket(PORT);
	StubServerSocketFactory stubServerSocketFactory = new StubServerSocketFactory(stubServerSocket);
	session.serverSocketFactory = stubServerSocketFactory;

	session.switchToPassiveMode();
	assertFalse("server socket closed", stubServerSocket.isClosed());
	assertNotNull("passiveModeDataSocket", session.passiveModeDataSocket);
	session.setClientDataPort(PORT);

	// Make sure that any passive mode connection info is cleared out
	assertTrue("server socket closed", stubServerSocket.isClosed());
	assertNull("passiveModeDataSocket should be null", session.passiveModeDataSocket);
	}

	/**
	* Test the setClientHost() method
	*/
	public void testSetClientHost() throws Exception {
	StubSocket stubSocket = createTestSocket("");
	StubSocketFactory stubSocketFactory = new StubSocketFactory(stubSocket);
	session.socketFactory = stubSocketFactory;
	session.setClientDataHost(clientHost);
	session.openDataConnection();
	assertEquals("client host", clientHost, stubSocketFactory.requestedHost);
	}

	/**
	* Test the openDataConnection(), setClientDataPort() and setClientDataHost() methods
	*/
	public void testOpenDataConnection() {
	StubSocket stubSocket = createTestSocket("");
	StubSocketFactory stubSocketFactory = new StubSocketFactory(stubSocket);
	session.socketFactory = stubSocketFactory;

	// Use default client data port
	session.setClientDataHost(clientHost);
	session.openDataConnection();
	assertEquals("data port", DefaultSession.DEFAULT_CLIENT_DATA_PORT, stubSocketFactory.requestedDataPort);
	assertEquals("client host", clientHost, stubSocketFactory.requestedHost);

	// Set client data port explicitly
	session.setClientDataPort(PORT);
	session.setClientDataHost(clientHost);
	session.openDataConnection();
	assertEquals("data port", PORT, stubSocketFactory.requestedDataPort);
	assertEquals("client host", clientHost, stubSocketFactory.requestedHost);
	}

	/**
	* Test the OpenDataConnection method, when in passive mode and no incoming connection is
	* initiated
	*/
	public void testOpenDataConnection_PassiveMode_NoConnection() throws IOException {

	StubServerSocket stubServerSocket = new StubServerSocket(PORT);
	StubServerSocketFactory stubServerSocketFactory = new StubServerSocketFactory(stubServerSocket);
	session.serverSocketFactory = stubServerSocketFactory;

	session.switchToPassiveMode();

	try {
	session.openDataConnection();
	fail("Expected MockFtpServerException");
	}
	catch (MockFtpServerException expected) {
	LOG.info("Expected: " + expected);
	assertSame("cause", SocketTimeoutException.class, expected.getCause().getClass());
	}
	}

	/**
	* Test the OpenDataConnection method, when the clientHost has not been set
	*/
	public void testOpenDataConnection_NullClientHost() {
	try {
	session.openDataConnection();
	fail("Expected AssertFailedException");
	}
	catch (AssertFailedException expected) {
	LOG.info("Expected: " + expected);
	}
	}

	/**
	* Test the readData() method
	*/
	public void testReadData() {
	StubSocket stubSocket = createTestSocket(DATA);
	session.socketFactory = new StubSocketFactory(stubSocket);
	session.setClientDataHost(clientHost);

	session.openDataConnection();
	byte[] data = session.readData();
	LOG.info("data=[" + new String(data) + "]");
	assertEquals("data", DATA.getBytes(), data);
	}

	/**
	* Test the readData() method after switching to passive mode
	*/
	public void testReadData_PassiveMode() throws IOException {
	StubSocket stubSocket = createTestSocket(DATA);
	StubServerSocket stubServerSocket = new StubServerSocket(PORT, stubSocket);
	StubServerSocketFactory stubServerSocketFactory = new StubServerSocketFactory(stubServerSocket);
	session.serverSocketFactory = stubServerSocketFactory;

	session.switchToPassiveMode();
	session.openDataConnection();
	byte[] data = session.readData();
	LOG.info("data=[" + new String(data) + "]");
	assertEquals("data", DATA.getBytes(), data);
	}

	/**
	* Test the readData(int) method
	*/
	public void testReadData_NumBytes() {
	final int NUM_BYTES = 5;
	final String EXPECTED_DATA = DATA.substring(0, NUM_BYTES);
	StubSocket stubSocket = createTestSocket(DATA);
	session.socketFactory = new StubSocketFactory(stubSocket);
	session.setClientDataHost(clientHost);

	session.openDataConnection();
	byte[] data = session.readData(NUM_BYTES);
	LOG.info("data=[" + new String(data) + "]");
	assertEquals("data", EXPECTED_DATA.getBytes(), data);
	}

	public void testReadData_NumBytes_AskForMoreBytesThanThereAre() {
	StubSocket stubSocket = createTestSocket(DATA);
	session.socketFactory = new StubSocketFactory(stubSocket);
	session.setClientDataHost(clientHost);

	session.openDataConnection();
	byte[] data = session.readData(10000);
	LOG.info("data=[" + new String(data) + "]");
	assertEquals("data", DATA.getBytes(), data);
	}

	/**
	* Test the closeDataConnection() method
	*/
	public void testCloseDataConnection() {
	StubSocket stubSocket = createTestSocket(DATA);
	session.socketFactory = new StubSocketFactory(stubSocket);

	session.setClientDataHost(clientHost);
	session.openDataConnection();
	session.closeDataConnection();
	assertTrue("client data socket should be closed", stubSocket.isClosed());
	}

	/**
	* Test the switchToPassiveMode() method
	*/
	public void testSwitchToPassiveMode() throws IOException {
	StubServerSocket stubServerSocket = new StubServerSocket(PORT);
	StubServerSocketFactory stubServerSocketFactory = new StubServerSocketFactory(stubServerSocket);
	session.serverSocketFactory = stubServerSocketFactory;

	assertNull("passiveModeDataSocket starts out null", session.passiveModeDataSocket);
	int port = session.switchToPassiveMode();
	assertSame("passiveModeDataSocket", stubServerSocket, session.passiveModeDataSocket);
	assertEquals("port", PORT, port);
	}

	/**
	* Test the getServerHost() method
	*/
	public void testGetServerHost() {
	assertEquals("host", DEFAULT_HOST, session.getServerHost());
	}

	/**
	* Test the getClientHost() method when the session is not yet started
	*/
	public void testGetClientHost_NotRunning() {
	assertNull("null", session.getClientHost());
	}

	/**
	* Test the parseCommand() method
	*/
	public void testParseCommand() {
	Command command = session.parseCommand("LIST");
	assertEquals("command name", "LIST", command.getName());
	assertEquals("command parameters", EMPTY, command.getParameters());

	command = session.parseCommand("USER user123");
	assertEquals("command name", "USER", command.getName());
	assertEquals("command parameters", array("user123"), command.getParameters());

	command = session.parseCommand("PORT 127,0,0,1,17,37");
	assertEquals("command name", "PORT", command.getName());
	assertEquals("command parameters", new String[] { "127", "0", "0", "1", "17", "37" }, command
	.getParameters());
	}

	/**
	* Test the parseCommand() method, passing in an empty command String
	*/
	public void testParseCommand_EmptyCommandString() {
	try {
	session.parseCommand("");
	fail("Expected AssertFailedException");
	}
	catch (AssertFailedException expected) {
	LOG.info("Expected: " + expected);
	}
	}

	/**
	* Test the sendData() method, as well as the openDataConnection() and closeDataConnection()
	*/
	public void testSendData() {
	StubSocket stubSocket = createTestSocket("1234567890 abcdef");
	session.socketFactory = new StubSocketFactory(stubSocket);

	session.setClientDataHost(clientHost);
	session.openDataConnection();
	session.sendData(DATA.getBytes(), DATA.length());
	LOG.info("output=[" + outputStream.toString() + "]");
	assertEquals("output", DATA, outputStream.toString());
	}

	/**
	* Test the SendData() method, passing in a null byte[]
	*/
	public void testSendData_Null() {

	try {
	session.sendData(null, 1);
	fail("Expected AssertFailedException");
	}
	catch (AssertFailedException expected) {
	LOG.info("Expected: " + expected);
	}
	}

	/**
	* Test the SendReply(int,String) method, passing in an invalid reply code
	*/
	public void testSendReply_InvalidReplyCode() {

	try {
	session.sendReply(-66, "text");
	fail("Expected AssertFailedException");
	}
	catch (AssertFailedException expected) {
	LOG.info("Expected: " + expected);
	}
	}

	/**
	* Test the getAttribute() and setAttribute() methods
	*/
	public void testGetAndSetAttribute() {
	assertNull("name does not exist yet", session.getAttribute(NAME1));
	session.setAttribute(NAME1, VALUE);
	session.setAttribute(NAME2, null);
	assertEquals("NAME1", VALUE, session.getAttribute(NAME1));
	assertNull("NAME2", session.getAttribute(NAME2));
	assertNull("no such name", session.getAttribute("noSuchName"));
	}

	/**
	* Test the getAttribute() method, passing in a null name
	*/
	public void testGetAttribute_Null() {
	try {
	session.getAttribute(null);
	fail("Expected AssertFailedException");
	}
	catch (AssertFailedException expected) {
	LOG.info("Expected: " + expected);
	}
	}

	/**
	* Test the setAttribute() method, passing in a null name
	*/
	public void testSetAttribute_NullName() {
	try {
	session.setAttribute(null, VALUE);
	fail("Expected AssertFailedException");
	}
	catch (AssertFailedException expected) {
	LOG.info("Expected: " + expected);
	}
	}

	/**
	* Test the removeAttribute()
	*/
	public void testRemoveAttribute() {
	session.removeAttribute("noSuchName"); // do nothing
	session.setAttribute(NAME1, VALUE);
	session.removeAttribute(NAME1);
	assertNull("NAME1", session.getAttribute(NAME1));
	}

	/**
	* Test the removeAttribute() method, passing in a null name
	*/
	public void testRemoveAttribute_Null() {
	try {
	session.removeAttribute(null);
	fail("Expected AssertFailedException");
	}
	catch (AssertFailedException expected) {
	LOG.info("Expected: " + expected);
	}
	}

	/**
	* Test the getAttributeNames()
	*/
	public void testGetAttributeNames() {
	assertEquals("No names yet", Collections.EMPTY_SET, session.getAttributeNames());
	session.setAttribute(NAME1, VALUE);
	assertEquals("1", Collections.singleton(NAME1), session.getAttributeNames());
	session.setAttribute(NAME2, VALUE);
	assertEquals("2", set(NAME1, NAME2), session.getAttributeNames());
	}

	// -------------------------------------------------------------------------
	// Internal Helper Methods
	// -------------------------------------------------------------------------

	/**
	* Create and return a DefaultSession object that reads from an InputStream with the specified
	* contents and writes to the predefined outputStrean ByteArrayOutputStream. Also, save the
	* StubSocket being used in the stubSocket attribute.
	*
	* @param inputStreamContents - the contents of the input stream
	* @return the DefaultSession
	*/
	private DefaultSession createDefaultSession(String inputStreamContents) {
	stubSocket = createTestSocket(inputStreamContents);
	return new DefaultSession(stubSocket, commandHandlerMap);
	}

	/**
	* Create and return a StubSocket that reads from an InputStream with the specified contents and
	* writes to the predefined outputStrean ByteArrayOutputStream.
	*
	* @param inputStreamContents - the contents of the input stream
	* @return the StubSocket
	*/
	private StubSocket createTestSocket(String inputStreamContents) {
	InputStream inputStream = new ByteArrayInputStream(inputStreamContents.getBytes());
	StubSocket stubSocket = new StubSocket(inputStream, outputStream);
	stubSocket._setLocalAddress(DEFAULT_HOST);
	return stubSocket;
	}

	}