@Test
 public void testStaleWhenClosed() throws Exception {
   conn.bind(socket);
   conn.ensureOpen();
   conn.close();
   Assert.assertTrue(conn.isStale());
 }
  @Test
  public void testSetSocketTimeout() throws Exception {
    conn.bind(socket);

    conn.setSocketTimeout(123);

    Mockito.verify(socket, Mockito.times(1)).setSoTimeout(123);
  }
  @Test
  public void testGetSocketTimeoutException() throws Exception {
    Assert.assertEquals(-1, conn.getSocketTimeout());

    Mockito.when(socket.getSoTimeout()).thenThrow(new SocketException());
    conn.bind(socket);

    Assert.assertEquals(-1, conn.getSocketTimeout());
  }
  @Test
  public void testSetSocketTimeoutException() throws Exception {
    conn.bind(socket);

    Mockito.doThrow(new SocketException()).when(socket).setSoTimeout(Mockito.anyInt());

    conn.setSocketTimeout(123);

    Mockito.verify(socket, Mockito.times(1)).setSoTimeout(123);
  }
  @Test
  public void testNotStaleWhenHasData() throws Exception {
    final ByteArrayInputStream instream =
        Mockito.spy(new ByteArrayInputStream(new byte[] {1, 2, 3, 4, 5}));
    Mockito.when(socket.getInputStream()).thenReturn(instream);

    conn.bind(socket);
    conn.ensureOpen();

    Assert.assertFalse(conn.isStale());
  }
  @Test
  public void testAwaitInputNoData() throws Exception {
    final InputStream instream = Mockito.mock(InputStream.class);
    Mockito.when(socket.getInputStream()).thenReturn(instream);
    Mockito.when(instream.read(Mockito.<byte[]>any(), Mockito.anyInt(), Mockito.anyInt()))
        .thenReturn(-1);

    conn.bind(socket);
    conn.ensureOpen();

    Assert.assertFalse(conn.awaitInput(432));
  }
  @Test
  public void testStaleWhenIOError() throws Exception {
    final InputStream instream = Mockito.mock(InputStream.class);
    Mockito.when(socket.getInputStream()).thenReturn(instream);
    Mockito.when(instream.read(Mockito.<byte[]>any(), Mockito.anyInt(), Mockito.anyInt()))
        .thenThrow(new SocketException());

    conn.bind(socket);
    conn.ensureOpen();

    Assert.assertTrue(conn.isStale());
  }
  @Test
  public void testConnectionShutdown() throws Exception {
    final InputStream instream = Mockito.mock(InputStream.class);
    final OutputStream outstream = Mockito.mock(OutputStream.class);
    Mockito.when(socket.getInputStream()).thenReturn(instream);
    Mockito.when(socket.getOutputStream()).thenReturn(outstream);

    conn.bind(socket);
    conn.ensureOpen();
    conn.getSessionOutputBuffer().write(0);

    Assert.assertTrue(conn.isOpen());

    conn.shutdown();

    Assert.assertFalse(conn.isOpen());

    Mockito.verify(outstream, Mockito.never())
        .write(Mockito.<byte[]>any(), Mockito.anyInt(), Mockito.anyInt());
    Mockito.verify(socket, Mockito.never()).shutdownInput();
    Mockito.verify(socket, Mockito.never()).shutdownOutput();
    Mockito.verify(socket, Mockito.times(1)).close();

    conn.close();
    Mockito.verify(socket, Mockito.times(1)).close();

    conn.shutdown();
    Mockito.verify(socket, Mockito.times(2)).close();
  }
 @Test
 public void testPrepareOutputIdentity() throws Exception {
   final HttpResponse message = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
   final OutputStream outstream = conn.prepareOutput(message);
   Assert.assertNotNull(outstream);
   Assert.assertTrue((outstream instanceof IdentityOutputStream));
 }
  @Test
  public void testAwaitInputInBuffer() throws Exception {
    final ByteArrayInputStream instream =
        Mockito.spy(new ByteArrayInputStream(new byte[] {1, 2, 3, 4, 5}));
    Mockito.when(socket.getInputStream()).thenReturn(instream);

    conn.bind(socket);
    conn.ensureOpen();
    conn.getSessionInputBuffer().read();

    Assert.assertTrue(conn.awaitInput(432));

    Mockito.verify(socket, Mockito.never()).setSoTimeout(Mockito.anyInt());
    Mockito.verify(instream, Mockito.times(1))
        .read(Mockito.<byte[]>any(), Mockito.anyInt(), Mockito.anyInt());
  }
 @Test
 public void testPrepareOutputLengthDelimited() throws Exception {
   final HttpResponse message = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
   message.addHeader("Content-Length", "10");
   final OutputStream outstream = conn.prepareOutput(message);
   Assert.assertNotNull(outstream);
   Assert.assertTrue((outstream instanceof ContentLengthOutputStream));
 }
 @Test
 public void testPrepareOutputChunked() throws Exception {
   final HttpResponse message = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
   message.addHeader("Transfer-Encoding", "chunked");
   final OutputStream outstream = conn.prepareOutput(message);
   Assert.assertNotNull(outstream);
   Assert.assertTrue((outstream instanceof ChunkedOutputStream));
 }
  @Test
  public void testSocketBind() throws Exception {
    final InetAddress localAddress = InetAddress.getByAddress(new byte[] {127, 0, 0, 1});
    final int localPort = 8888;
    final InetAddress remoteAddress = InetAddress.getByAddress(new byte[] {10, 0, 0, 2});
    final int remotePort = 80;
    final InetSocketAddress localSockAddress = new InetSocketAddress(localAddress, localPort);
    final InetSocketAddress remoteSockAddress = new InetSocketAddress(remoteAddress, remotePort);
    Mockito.when(socket.getLocalSocketAddress()).thenReturn(localSockAddress);
    Mockito.when(socket.getRemoteSocketAddress()).thenReturn(remoteSockAddress);
    Mockito.when(socket.getLocalAddress()).thenReturn(localAddress);
    Mockito.when(socket.getLocalPort()).thenReturn(localPort);
    Mockito.when(socket.getInetAddress()).thenReturn(remoteAddress);
    Mockito.when(socket.getPort()).thenReturn(remotePort);
    conn.bind(socket);

    Assert.assertEquals("127.0.0.1:8888<->10.0.0.2:80", conn.toString());
    Assert.assertTrue(conn.isOpen());
    Assert.assertEquals(8888, conn.getLocalPort());
    Assert.assertEquals(80, conn.getRemotePort());
    Assert.assertEquals(
        InetAddress.getByAddress(new byte[] {127, 0, 0, 1}), conn.getLocalAddress());
    Assert.assertEquals(
        InetAddress.getByAddress(new byte[] {10, 0, 0, 2}), conn.getRemoteAddress());
  }
 @Test
 public void testPrepareInputIdentity() throws Exception {
   final HttpResponse message = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
   final HttpEntity entity = conn.prepareInput(message);
   Assert.assertNotNull(entity);
   Assert.assertFalse(entity.isChunked());
   Assert.assertEquals(-1, entity.getContentLength());
   final InputStream instream = entity.getContent();
   Assert.assertNotNull(instream);
   Assert.assertTrue((instream instanceof IdentityInputStream));
 }
 @Test
 public void testBasics() throws Exception {
   Assert.assertFalse(conn.isOpen());
   Assert.assertEquals(-1, conn.getLocalPort());
   Assert.assertEquals(-1, conn.getRemotePort());
   Assert.assertEquals(null, conn.getLocalAddress());
   Assert.assertEquals(null, conn.getRemoteAddress());
   Assert.assertEquals("[Not bound]", conn.toString());
 }
 @Test
 public void testPrepareInputLengthDelimited() throws Exception {
   final HttpResponse message = new BasicHttpResponse(HttpVersion.HTTP_1_1, 200, "OK");
   message.addHeader("Content-Length", "10");
   message.addHeader("Content-Type", "stuff");
   message.addHeader("Content-Encoding", "identity");
   final HttpEntity entity = conn.prepareInput(message);
   Assert.assertNotNull(entity);
   Assert.assertFalse(entity.isChunked());
   Assert.assertEquals(10, entity.getContentLength());
   final Header ct = entity.getContentType();
   Assert.assertNotNull(ct);
   Assert.assertEquals("stuff", ct.getValue());
   final Header ce = entity.getContentEncoding();
   Assert.assertNotNull(ce);
   Assert.assertEquals("identity", ce.getValue());
   final InputStream instream = entity.getContent();
   Assert.assertNotNull(instream);
   Assert.assertTrue((instream instanceof ContentLengthInputStream));
 }
 public void bind(Socket socket) throws IOException {
   super.bind(socket);
 }