io.netty.util.IllegalReferenceCountException Java Examples

@Test(expected = IllegalReferenceCountException.class)
public void testReadBytesAfterRelease3() {
    ByteBuf buffer = buffer(8);
    try {
        releasedBuffer().readBytes(buffer);
    } finally {
        buffer.release();
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void shouldErrorOnReleasecontentOfArrayChildReferenceCounted() throws Exception {
    ByteBuf buf = Unpooled.buffer();
    buf.writeBytes(byteBufOf("*2\r\n"));
    buf.writeBytes(byteBufOf("$3\r\nFoo\r\n$3\r\nBar\r\n"));
    assertTrue(channel.writeInbound(buf));

    ArrayRedisMessage msg = channel.readInbound();

    List<RedisMessage> children = msg.children();
    ByteBuf childBuf = ((FullBulkStringRedisMessage) children.get(0)).content();
    ReferenceCountUtil.release(msg);
    ReferenceCountUtil.release(childBuf);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void shouldErrorOnReleaseArrayChildReferenceCounted() throws Exception {
    ByteBuf buf = Unpooled.buffer();
    buf.writeBytes(byteBufOf("*2\r\n"));
    buf.writeBytes(byteBufOf("*3\r\n:1\r\n:2\r\n:3\r\n"));
    buf.writeBytes(byteBufOf("$3\r\nFoo\r\n"));
    assertTrue(channel.writeInbound(buf));

    ArrayRedisMessage msg = channel.readInbound();

    List<RedisMessage> children = msg.children();
    ReferenceCountUtil.release(msg);
    ReferenceCountUtil.release(children.get(1));
}
 

@Test
public void testArrayAfterRelease() {
    ByteBuf buf = releasedBuffer();
    if (buf.hasArray()) {
        try {
            buf.array();
            fail();
        } catch (IllegalReferenceCountException e) {
            // expected
        }
    }
}
 

@Override
public ByteBuf content() {
    if (data.refCnt() <= 0) {
        throw new IllegalReferenceCountException(data.refCnt());
    }
    return data;
}
 

@Override
public ByteBuf content() {
    if (content.refCnt() <= 0) {
        throw new IllegalReferenceCountException(content.refCnt());
    }
    return content;
}
 

@Override
public void dispose() {
    int last = getAndDecrement();
    if (last <= 0) {
        throw new IllegalReferenceCountException(last);
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void shouldErrorOnDoubleReleaseArrayReferenceCounted() throws Exception {
    ByteBuf buf = Unpooled.buffer();
    buf.writeBytes(byteBufOf("*2\r\n"));
    buf.writeBytes(byteBufOf("*3\r\n:1\r\n:2\r\n:3\r\n"));
    buf.writeBytes(byteBufOf("*2\r\n+Foo\r\n-Bar\r\n"));
    assertTrue(channel.writeInbound(buf));

    ArrayRedisMessage msg = channel.readInbound();

    ReferenceCountUtil.release(msg);
    ReferenceCountUtil.release(msg);
}
 

@Override
public ByteBuf content() {
    final ByteBuf data = (ByteBuf) super.payload();
    if (data.refCnt() <= 0) {
        throw new IllegalReferenceCountException(data.refCnt());
    }
    return data;
}
 

@Override
public ByteBuf content() {
    int count = refCnt();
    if (count <= 0) {
        throw new IllegalReferenceCountException(count);
    }

    return content;
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testSetBytesAfterRelease3() {
    ByteBuf buffer = buffer();
    try {
        releasedBuffer().setBytes(0, buffer, 0, 1);
    } finally {
        buffer.release();
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testWriteBytesAfterRelease() {
    ByteBuf buffer = buffer(8);
    try {
        releasedBuffer().writeBytes(buffer);
    } finally {
        buffer.release();
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testRetainOverflow() {
    AbstractReferenceCountedByteBuf referenceCounted = newReferenceCounted();
    referenceCounted.setRefCnt(Integer.MAX_VALUE);
    assertEquals(Integer.MAX_VALUE, referenceCounted.refCnt());
    referenceCounted.retain();
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testRetainResurrect() {
    AbstractReferenceCountedByteBuf referenceCounted = newReferenceCounted();
    assertTrue(referenceCounted.release());
    assertEquals(0, referenceCounted.refCnt());
    referenceCounted.retain();
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testRetainResurrect2() {
    AbstractReferenceCountedByteBuf referenceCounted = newReferenceCounted();
    assertTrue(referenceCounted.release());
    assertEquals(0, referenceCounted.refCnt());
    referenceCounted.retain(2);
}
 

@Override
public ByteBuf content() {
    int count = refCnt();
    if (count <= 0) {
        throw new IllegalReferenceCountException(count);
    }

    return content;
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testWriteBytesAfterRelease3() {
    ByteBuf buffer = buffer(8);
    try {
        releasedBuffer().writeBytes(buffer, 0, 1);
    } finally {
        buffer.release();
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testGetBytesAfterRelease2() {
    ByteBuf buffer = buffer();
    try {
        releasedBuffer().getBytes(0, buffer, 1);
    } finally {
        buffer.release();
    }
}
 

@Override
public void dispose() {
    int refCnt;

    do {
        refCnt = get();

        if (refCnt <= 0) {
            throw new IllegalReferenceCountException(refCnt);
        }
    } while (!compareAndSet(refCnt, refCnt - 1));
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testSetBooleanAfterRelease() {
    releasedBuffer().setBoolean(0, true);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testGetBytesAfterRelease5() {
    releasedBuffer().getBytes(0, new byte[8], 0, 1);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testSetBytesAfterRelease5() {
    releasedBuffer().setBytes(0, new byte[8], 0, 1);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testGetDoubleLEAfterRelease() {
    releasedBuffer().getDoubleLE(0);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testGetDoubleAfterRelease() {
    releasedBuffer().getDouble(0);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testWriteUsAsciiCharSequenceAfterRelease() {
    testWriteCharSequenceAfterRelease0(CharsetUtil.US_ASCII);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testGetBytesAfterRelease8() throws IOException {
    releasedBuffer().getBytes(0, new DevNullGatheringByteChannel(), 1);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testSetByteAfterRelease() {
    releasedBuffer().setByte(0, 1);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testWriteZeroAfterRelease() throws IOException {
    releasedBuffer().writeZero(1);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testWriteFloatLEAfterRelease() {
    releasedBuffer().writeFloatLE(1);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testGetBytesAfterRelease6() {
    releasedBuffer().getBytes(0, ByteBuffer.allocate(8));
}