public void testWritePartialMsg() throws Exception {
    assertEquals(0, SENT.size());
    assertEquals(0, STATS.getSent());

    Message m = q("reaalllllllllly long query");
    SINK.resize(m.getTotalLength() - 20);

    WRITER.send(m);
    assertEquals(1, STATS.getSent());
    assertTrue(WRITER.handleWrite()); // still stuff left to write.
    assertTrue(SINK.interested());
    assertEquals(
        1, SENT.size()); // it's sent, even though the other side didn't receive it fully yet.
    assertEquals(buffer(m), buffer(SENT.next()));

    ByteBuffer buffer = ByteBuffer.allocate(m.getTotalLength());
    buffer.put(SINK.getBuffer());
    SINK.resize(100000);

    assertFalse(WRITER.handleWrite());
    assertFalse(SINK.interested());
    buffer.put(SINK.getBuffer());
    Message in = read((ByteBuffer) buffer.flip());
    assertEquals(buffer(m), buffer(in));
  }
 private Message read(ByteBuffer buffer) throws Exception {
   ByteArrayInputStream in =
       new ByteArrayInputStream(buffer.array(), buffer.position(), buffer.limit());
   Message m = read(in);
   buffer.position(buffer.position() + m.getTotalLength());
   return m;
 }
  public void testSimpleWrite() throws Exception {
    Message one, two, three;
    one = q("query one");
    two = g(7123);
    three = s(8134);

    assertEquals(0, STATS.getSent());
    assertFalse(SINK.interested());

    WRITER.send(one);
    WRITER.send(two);
    WRITER.send(three);
    assertEquals(3, STATS.getSent());

    assertTrue(SINK.interested());

    assertEquals(0, SENT.size());

    assertFalse(WRITER.handleWrite()); // nothing left to write.
    assertEquals(3, SENT.size());

    ByteBuffer buffer = SINK.getBuffer();
    assertEquals(
        one.getTotalLength() + two.getTotalLength() + three.getTotalLength(), buffer.limit());
    ByteArrayInputStream in = new ByteArrayInputStream(buffer.array(), 0, buffer.limit());
    Message in1, in2, in3;
    in1 = read(in);
    in2 = read(in);
    in3 = read(in);
    assertEquals(-1, in.read());

    assertEquals(buffer(one), buffer(in1));
    assertEquals(buffer(two), buffer(in2));
    assertEquals(buffer(three), buffer(in3));
    assertEquals(buffer(one), buffer(SENT.next()));
    assertEquals(buffer(two), buffer(SENT.next()));
    assertEquals(buffer(three), buffer(SENT.next()));

    assertFalse(SINK.interested());
    assertEquals(3, STATS.getSent());
  }
  public void testWritePartialAndMore() throws Exception {
    Message out1 = q("first long query");
    Message out2 = q("second long query");
    Message out3 = q("third long query");
    assertEquals(0, STATS.getSent());

    SINK.resize(out1.getTotalLength() + 20);
    WRITER.send(out1);
    WRITER.send(out2);
    assertEquals(2, STATS.getSent());

    assertEquals(0, SENT.size());
    assertTrue(WRITER.handleWrite());
    assertTrue(SINK.interested());
    assertEquals(2, SENT.size()); // two were sent, one was received.
    assertEquals(buffer(out1), buffer(SENT.next()));
    assertEquals(buffer(out2), buffer(SENT.next()));

    ByteBuffer buffer = ByteBuffer.allocate(1000);
    buffer.put(SINK.getBuffer()).flip();
    SINK.resize(10000);

    Message in1 = read(buffer);
    assertTrue(buffer.hasRemaining());
    assertEquals(20, buffer.remaining());
    buffer.compact();

    WRITER.send(out3);
    assertEquals(3, STATS.getSent());
    assertFalse(WRITER.handleWrite());
    assertEquals(1, SENT.size());
    assertEquals(buffer(out3), buffer(SENT.next()));
    assertFalse(SINK.interested());
    buffer.put(SINK.getBuffer()).flip();

    Message in2 = read(buffer);
    Message in3 = read(buffer);
    assertTrue(!buffer.hasRemaining());
    assertEquals(buffer(out2), buffer(in2));
    assertEquals(buffer(out3), buffer(in3));
  }