Add test coverage for mark&reset and getByteBuffer for CompositeReada…

…bleByteBuffer.

core/src/test/java/io/grpc/internal/CompositeReadableBufferTest.java

@@ -17,13 +17,19 @@
 package io.grpc.internal;
 
 import static com.google.common.base.Charsets.UTF_8;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.nio.InvalidMarkException;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -153,6 +159,128 @@ public void readStreamShouldSucceed() throws IOException {
     assertEquals(EXPECTED_VALUE, new String(bos.toByteArray(), UTF_8));
   }
 
+  @Test
+  public void resetUnmarkedShouldThrow() {
+    try {
+      composite.reset();
+      fail();
+    } catch (InvalidMarkException expected) {
+    }
+  }
+
+  @Test
+  public void markAndResetWithSkipBytesShouldSucceed() {
+    composite.mark();
+    composite.skipBytes(EXPECTED_VALUE.length() / 2);
+    composite.reset();
+    assertEquals(EXPECTED_VALUE.length(), composite.readableBytes());
+  }
+
+  @Test
+  public void markAndResetWithReadUnsignedByteShouldSucceed() {
+    composite.readUnsignedByte();
+    composite.mark();
+    int b = composite.readUnsignedByte();
+    composite.reset();
+    assertEquals(EXPECTED_VALUE.length() - 1, composite.readableBytes());
+    assertEquals(b, composite.readUnsignedByte());
+  }
+
+  @Test
+  public void markAndResetWithReadByteArrayShouldSucceed() {
+    composite.mark();
+    byte[] first = new byte[EXPECTED_VALUE.length()];
+    composite.readBytes(first, 0, EXPECTED_VALUE.length());
+    composite.reset();
+    assertEquals(EXPECTED_VALUE.length(), composite.readableBytes());
+    byte[] second = new byte[EXPECTED_VALUE.length()];
+    composite.readBytes(second, 0, EXPECTED_VALUE.length());
+    assertArrayEquals(first, second);
+  }
+
+  @Test
+  public void markAndResetWithReadByteBufferShouldSucceed() {
+    byte[] first = new byte[EXPECTED_VALUE.length()];
+    composite.mark();
+    composite.readBytes(ByteBuffer.wrap(first));
+    composite.reset();
+    byte[] second = new byte[EXPECTED_VALUE.length()];
+    assertEquals(EXPECTED_VALUE.length(), composite.readableBytes());
+    composite.readBytes(ByteBuffer.wrap(second));
+    assertArrayEquals(first, second);
+  }
+
+  @Test
+  public void markAndResetWithReadStreamShouldSucceed() throws IOException {
+    ByteArrayOutputStream first = new ByteArrayOutputStream();
+    composite.mark();
+    composite.readBytes(first, EXPECTED_VALUE.length() / 2);
+    composite.reset();
+    assertEquals(EXPECTED_VALUE.length(), composite.readableBytes());
+    ByteArrayOutputStream second = new ByteArrayOutputStream();
+    composite.readBytes(second, EXPECTED_VALUE.length() / 2);
+    assertArrayEquals(first.toByteArray(), second.toByteArray());
+  }
+
+  @Test
+  public void markAndResetWithReadReadableBufferShouldSucceed() {
+    composite.readBytes(EXPECTED_VALUE.length() / 2);
+    int remaining = composite.readableBytes();
+    composite.mark();
+    ReadableBuffer first = composite.readBytes(1);
+    composite.reset();
+    assertEquals(remaining, composite.readableBytes());
+    ReadableBuffer second = composite.readBytes(1);
+    assertEquals(first.readUnsignedByte(), second.readUnsignedByte());
+  }
+
+  @Test
+  public void markAgainShouldOverwritePreviousMark() {
+    composite.mark();
+    composite.skipBytes(EXPECTED_VALUE.length() / 2);
+    int remaining = composite.readableBytes();
+    composite.mark();
+    composite.skipBytes(1);
+    composite.reset();
+    assertEquals(remaining, composite.readableBytes());
+  }
+
+  @Test
+  public void bufferAddedAfterMarkedShouldBeIncluded() {
+    composite = new CompositeReadableBuffer();
+    composite.mark();
+    splitAndAdd(EXPECTED_VALUE);
+    composite.skipBytes(EXPECTED_VALUE.length() / 2);
+    composite.reset();
+    assertEquals(EXPECTED_VALUE.length(), composite.readableBytes());
+  }
+
+  @Test
+  public void canUseByteBufferOnlyAllComponentsSupportUsingByteBuffer() {
+    composite = new CompositeReadableBuffer();
+    ReadableBuffer buffer1 = mock(ReadableBuffer.class);
+    ReadableBuffer buffer2 = mock(ReadableBuffer.class);
+    ReadableBuffer buffer3 = mock(ReadableBuffer.class);
+    when(buffer1.canUseByteBuffer()).thenReturn(true);
+    when(buffer2.canUseByteBuffer()).thenReturn(true);
+    when(buffer3.canUseByteBuffer()).thenReturn(false);
+    composite.addBuffer(buffer1);
+    assertTrue(composite.canUseByteBuffer());
+    composite.addBuffer(buffer2);
+    assertTrue(composite.canUseByteBuffer());
+    composite.addBuffer(buffer3);
+    assertFalse(composite.canUseByteBuffer());
+  }
+
+  @Test
+  public void getByteBufferDelegatesToComponents() {
+    composite = new CompositeReadableBuffer();
+    ReadableBuffer buffer = mock(ReadableBuffer.class);
+    composite.addBuffer(buffer);
+    composite.getByteBuffer();
+    verify(buffer).getByteBuffer();
+  }
+
   @Test
   public void closeShouldCloseBuffers() {
     composite = new CompositeReadableBuffer();