closeStartTag() throws java.io.IOException; private void writeNamespaceDeclar() throws java.io.IOException; public XmlSerializer endTag(String, String) throws java.io.IOException; public XmlSerializer text(String) throws java.io.IOException; public XmlSerializer text(char[], int, int) throws java.io.IOException; public void cdsect(String) throws java.io.IOException; public void entityRef(String) throws java.io.IOException; public void processingInstructio(String) throws java.io.IOException; public void comment(String)...

        } catch (IOException ex) { }
        return connection.getHeaderField(index);
    }

    public Object getContent() throws IOException {
        try {
            handshake();
        } catch (IOException ex) { }
        return connection.getContent();
    }

    public Object getContent(Class[] classes) throws IOException {
        try {
            handshake();
        } catch (IOException ex) { }

  public void testMethodsThrowWhenClosed() throws IOException {
    CharSequenceReader reader = new CharSequenceReader("");
    reader.close();

    assertThrows(IOException.class, () -> reader.read());

    assertThrows(IOException.class, () -> reader.read(new char[10]));

    assertThrows(IOException.class, () -> reader.read(new char[10], 0, 10));

    assertThrows(IOException.class, () -> reader.read(CharBuffer.allocate(10)));

            return out;
          }
        });
    assertExpectedBytes(out.toByteArray());
  }

  public void testIsEmpty() throws IOException {
    assertEquals(expected.length == 0, source.isEmpty());
  }

  public void testSize() throws IOException {
    assertEquals(expected.length, source.size());
  }

  public void testSizeIfKnown() throws IOException {

        this.dis.readFully(b, off, len);
    }


    public char readChar () throws IOException {
        align(2);
        return this.dis.readChar();
    }


    public byte readByte () throws IOException {
        return this.dis.readByte();
    }


    public short readShort () throws IOException {
        align(2);

   *     methods
   * @throws IOException if {@code swallowIOException} is false and {@code close} throws an {@code
   *     IOException}.
   */
  public static void close(@CheckForNull Closeable closeable, boolean swallowIOException)
      throws IOException {
    if (closeable == null) {
      return;
    }
    try {
      closeable.close();
    } catch (IOException e) {
      if (swallowIOException) {

    protected abstract void makeKey( Request request ) throws IOException;
    protected abstract Request peekKey() throws IOException;
    protected abstract void doSend( Request request ) throws IOException;
    protected abstract void doRecv( Response response ) throws IOException;
    protected abstract void doSkip() throws IOException;

    public synchronized void sendrecv( Request request,

  }

  public void testWrite_bytes() throws IOException {
    assertArrayEquals(new byte[0], sink.getBytes());
    sink.write(bytes);

    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());
    assertArrayEquals(bytes, sink.getBytes());
  }

  public void testWriteFrom_inputStream() throws IOException {
    ByteArrayInputStream in = new ByteArrayInputStream(bytes);
    sink.writeFrom(in);

  }

  @Override
  public void readFully(byte[] b) throws IOException {
    ByteStreams.readFully(this, b);
  }

  @Override
  public void readFully(byte[] b, int off, int len) throws IOException {
    ByteStreams.readFully(this, b, off, len);
  }

  @Override
  public int skipBytes(int n) throws IOException {
    return (int) in.skip(n);
  }

  @CanIgnoreReturnValue // to skip a byte

    protected abstract long makeKey ( Request request ) throws IOException;


    protected abstract Long peekKey () throws IOException;


    protected abstract void doSend ( Request request ) throws IOException;


    protected abstract void doRecv ( Response response ) throws IOException;


    protected abstract void doSkip ( Long key ) throws IOException;


    /**
     *