Home | History | Annotate | Download | only in internal 
      1 /*
      2  * Copyright 2014 The gRPC Authors
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package io.grpc.internal;
     18 
     19 import static com.google.common.base.Charsets.UTF_8;
     20 import static org.junit.Assert.assertArrayEquals;
     21 import static org.junit.Assert.assertEquals;
     22 
     23 import java.io.ByteArrayOutputStream;
     24 import java.nio.ByteBuffer;
     25 import java.util.Arrays;
     26 import org.junit.Test;
     27 import org.junit.runner.RunWith;
     28 import org.junit.runners.JUnit4;
     29 
     30 /**
     31  * Abstract base class for tests of {@link ReadableBuffer} subclasses.
     32  */
     33 @RunWith(JUnit4.class)
     34 public abstract class ReadableBufferTestBase {
     35   // Use a long string to ensure that any chunking/splitting works correctly.
     36   protected static final String msg = repeatUntilLength("hello", 8 * 1024);
     37 
     38   @Test
     39   public void bufferShouldReadAllBytes() {
     40     ReadableBuffer buffer = buffer();
     41     for (int ix = 0; ix < msg.length(); ++ix) {
     42       assertEquals(msg.length() - ix, buffer.readableBytes());
     43       assertEquals(msg.charAt(ix), buffer.readUnsignedByte());
     44     }
     45     assertEquals(0, buffer.readableBytes());
     46   }
     47 
     48   @Test
     49   public void readToArrayShouldSucceed() {
     50     ReadableBuffer buffer = buffer();
     51     byte[] array = new byte[msg.length()];
     52     buffer.readBytes(array, 0, array.length);
     53     assertArrayEquals(msg.getBytes(UTF_8), array);
     54     assertEquals(0, buffer.readableBytes());
     55   }
     56 
     57   @Test
     58   public void partialReadToArrayShouldSucceed() {
     59     ReadableBuffer buffer = buffer();
     60     byte[] array = new byte[msg.length()];
     61     buffer.readBytes(array, 1, 2);
     62     assertArrayEquals(new byte[] {'h', 'e'}, Arrays.copyOfRange(array, 1, 3));
     63     assertEquals(msg.length() - 2, buffer.readableBytes());
     64   }
     65 
     66   @Test
     67   public void readToStreamShouldSucceed() throws Exception {
     68     ReadableBuffer buffer = buffer();
     69     ByteArrayOutputStream stream = new ByteArrayOutputStream();
     70     buffer.readBytes(stream, msg.length());
     71     assertArrayEquals(msg.getBytes(UTF_8), stream.toByteArray());
     72     assertEquals(0, buffer.readableBytes());
     73   }
     74 
     75   @Test
     76   public void partialReadToStreamShouldSucceed() throws Exception {
     77     ReadableBuffer buffer = buffer();
     78     ByteArrayOutputStream stream = new ByteArrayOutputStream();
     79     buffer.readBytes(stream, 2);
     80     assertArrayEquals(new byte[]{'h', 'e'}, Arrays.copyOfRange(stream.toByteArray(), 0, 2));
     81     assertEquals(msg.length() - 2, buffer.readableBytes());
     82   }
     83 
     84   @Test
     85   public void readToByteBufferShouldSucceed() {
     86     ReadableBuffer buffer = buffer();
     87     ByteBuffer byteBuffer = ByteBuffer.allocate(msg.length());
     88     buffer.readBytes(byteBuffer);
     89     byteBuffer.flip();
     90     byte[] array = new byte[msg.length()];
     91     byteBuffer.get(array);
     92     assertArrayEquals(msg.getBytes(UTF_8), array);
     93     assertEquals(0, buffer.readableBytes());
     94   }
     95 
     96   @Test
     97   public void partialReadToByteBufferShouldSucceed() {
     98     ReadableBuffer buffer = buffer();
     99     ByteBuffer byteBuffer = ByteBuffer.allocate(2);
    100     buffer.readBytes(byteBuffer);
    101     byteBuffer.flip();
    102     byte[] array = new byte[2];
    103     byteBuffer.get(array);
    104     assertArrayEquals(new byte[]{'h', 'e'}, array);
    105     assertEquals(msg.length() - 2, buffer.readableBytes());
    106   }
    107 
    108   @Test
    109   public void partialReadToReadableBufferShouldSucceed() {
    110     ReadableBuffer buffer = buffer();
    111     ReadableBuffer newBuffer = buffer.readBytes(2);
    112     assertEquals(2, newBuffer.readableBytes());
    113     assertEquals(msg.length() - 2, buffer.readableBytes());
    114     byte[] array = new byte[2];
    115     newBuffer.readBytes(array, 0, 2);
    116     assertArrayEquals(new byte[] {'h', 'e'}, Arrays.copyOfRange(array, 0, 2));
    117   }
    118 
    119   protected abstract ReadableBuffer buffer();
    120 
    121   private static String repeatUntilLength(String toRepeat, int length) {
    122     StringBuilder buf = new StringBuilder();
    123     while (buf.length() < length) {
    124       buf.append(toRepeat);
    125     }
    126     buf.setLength(length);
    127     return buf.toString();
    128   }
    129 }
    130