Ejemplo n.º 1
0
  @Test
  public void testReferenceCounts3() {
    ByteBuf c1 = buffer().writeByte(1);
    ByteBuf c2 = buffer().writeByte(2).retain();
    ByteBuf c3 = buffer().writeByte(3).retain(2);

    CompositeByteBuf buf = freeLater(compositeBuffer());
    assertThat(buf.refCnt(), is(1));

    List<ByteBuf> components = new ArrayList<ByteBuf>();
    Collections.addAll(components, c1, c2, c3);
    buf.addComponents(components);

    // Ensure that c[123]'s refCount did not change.
    assertThat(c1.refCnt(), is(1));
    assertThat(c2.refCnt(), is(2));
    assertThat(c3.refCnt(), is(3));

    assertThat(buf.component(0).refCnt(), is(1));
    assertThat(buf.component(1).refCnt(), is(2));
    assertThat(buf.component(2).refCnt(), is(3));

    c3.release(2);
    c2.release();
  }
Ejemplo n.º 2
0
 @Test
 public void testRemoveLastComponent() {
   CompositeByteBuf buf = freeLater(compositeBuffer());
   buf.addComponent(wrappedBuffer(new byte[] {1, 2}));
   assertEquals(1, buf.numComponents());
   buf.removeComponent(0);
   assertEquals(0, buf.numComponents());
 }
Ejemplo n.º 3
0
 @Test
 public void testComponentMustBeSlice() {
   CompositeByteBuf buf = freeLater(compositeBuffer());
   buf.addComponent(buffer(4).setIndex(1, 3));
   assertThat(buf.component(0), is(instanceOf(SlicedByteBuf.class)));
   assertThat(buf.component(0).capacity(), is(2));
   assertThat(buf.component(0).maxCapacity(), is(2));
 }
Ejemplo n.º 4
0
  @Test
  public void testReferenceCounts2() {
    ByteBuf c1 = buffer().writeByte(1);
    ByteBuf c2 = buffer().writeByte(2).retain();
    ByteBuf c3 = buffer().writeByte(3).retain(2);

    CompositeByteBuf bufA = compositeBuffer();
    bufA.addComponents(c1, c2, c3).writerIndex(3);

    CompositeByteBuf bufB = compositeBuffer();
    bufB.addComponents(bufA);

    // Ensure that bufA.refCnt() did not change.
    assertThat(bufA.refCnt(), is(1));

    // Ensure that c[123]'s refCnt did not change.
    assertThat(c1.refCnt(), is(1));
    assertThat(c2.refCnt(), is(2));
    assertThat(c3.refCnt(), is(3));

    // This should decrease bufA.refCnt().
    bufB.release();
    assertThat(bufB.refCnt(), is(0));

    // Ensure bufA.refCnt() changed.
    assertThat(bufA.refCnt(), is(0));

    // Ensure that c[123]'s refCnt also changed due to the deallocation of bufA.
    assertThat(c1.refCnt(), is(0));
    assertThat(c2.refCnt(), is(1));
    assertThat(c3.refCnt(), is(2));

    c3.release(2);
    c2.release();
  }
Ejemplo n.º 5
0
  @Test
  public void testRangedConsolidation() {
    CompositeByteBuf buf = freeLater(compositeBuffer(Integer.MAX_VALUE));
    buf.addComponent(wrappedBuffer(new byte[] {1}));
    buf.addComponent(wrappedBuffer(new byte[] {2, 3}));
    buf.addComponent(wrappedBuffer(new byte[] {4, 5, 6}));
    buf.addComponent(wrappedBuffer(new byte[] {7, 8, 9, 10}));
    buf.consolidate(1, 2);

    assertEquals(3, buf.numComponents());
    assertEquals(wrappedBuffer(new byte[] {1}), buf.component(0));
    assertEquals(wrappedBuffer(new byte[] {2, 3, 4, 5, 6}), buf.component(1));
    assertEquals(wrappedBuffer(new byte[] {7, 8, 9, 10}), buf.component(2));
  }
Ejemplo n.º 6
0
  @Test
  public void testNestedLayout() {
    CompositeByteBuf buf = freeLater(compositeBuffer());
    buf.addComponent(
        compositeBuffer()
            .addComponent(wrappedBuffer(new byte[] {1, 2}))
            .addComponent(wrappedBuffer(new byte[] {3, 4}))
            .slice(1, 2));

    ByteBuffer[] nioBuffers = buf.nioBuffers(0, 2);
    assertThat(nioBuffers.length, is(2));
    assertThat(nioBuffers[0].remaining(), is(1));
    assertThat(nioBuffers[0].get(), is((byte) 2));
    assertThat(nioBuffers[1].remaining(), is(1));
    assertThat(nioBuffers[1].get(), is((byte) 3));
  }
Ejemplo n.º 7
0
  @Test
  public void testFullConsolidation() {
    CompositeByteBuf buf = freeLater(compositeBuffer(Integer.MAX_VALUE));
    buf.addComponent(wrappedBuffer(new byte[] {1}));
    buf.addComponent(wrappedBuffer(new byte[] {2, 3}));
    buf.addComponent(wrappedBuffer(new byte[] {4, 5, 6}));
    buf.consolidate();

    assertEquals(1, buf.numComponents());
    assertTrue(buf.hasArray());
    assertNotNull(buf.array());
    assertEquals(0, buf.arrayOffset());
  }
Ejemplo n.º 8
0
  @Test
  public void testAutoConsolidation() {
    CompositeByteBuf buf = compositeBuffer(2);

    buf.addComponent(wrappedBuffer(new byte[] {1}));
    assertEquals(1, buf.numComponents());

    buf.addComponent(wrappedBuffer(new byte[] {2, 3}));
    assertEquals(2, buf.numComponents());

    buf.addComponent(wrappedBuffer(new byte[] {4, 5, 6}));

    assertEquals(1, buf.numComponents());
    assertTrue(buf.hasArray());
    assertNotNull(buf.array());
    assertEquals(0, buf.arrayOffset());
  }
Ejemplo n.º 9
0
  /** Tests the "getBufferFor" method */
  @Test
  public void testComponentAtOffset() {
    CompositeByteBuf buf =
        (CompositeByteBuf)
            wrappedBuffer(new byte[] {1, 2, 3, 4, 5}, new byte[] {4, 5, 6, 7, 8, 9, 26});

    // Ensure that a random place will be fine
    assertEquals(5, buf.componentAtOffset(2).capacity());

    // Loop through each byte

    byte index = 0;

    while (index < buf.capacity()) {
      ByteBuf _buf = buf.componentAtOffset(index++);
      assertNotNull(_buf);
      assertTrue(_buf.capacity() > 0);
      assertNotNull(_buf.getByte(0));
      assertNotNull(_buf.getByte(_buf.readableBytes() - 1));
    }
  }