diff --git a/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/AbstractByteBufTest.java b/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/AbstractByteBufTest.java index a6b58cd..fe3bab3 100644 --- a/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/AbstractByteBufTest.java +++ b/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/AbstractByteBufTest.java @@ -21,9 +21,9 @@ import io.netty.util.ByteProcessor; import io.netty.util.CharsetUtil; import io.netty.util.IllegalReferenceCountException; import io.netty.util.internal.PlatformDependent; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; @@ -40,6 +40,7 @@ import java.nio.channels.GatheringByteChannel; import java.nio.channels.ScatteringByteChannel; import java.nio.channels.WritableByteChannel; import java.nio.charset.Charset; +import java.time.Duration; import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; @@ -60,15 +61,18 @@ import static io.netty.buffer.Unpooled.directBuffer; import static io.netty.buffer.Unpooled.unreleasableBuffer; import static io.netty.buffer.Unpooled.wrappedBuffer; import static io.netty.util.internal.EmptyArrays.EMPTY_BYTES; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; -import static org.junit.Assume.assumeFalse; -import static org.junit.Assume.assumeTrue; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; +import static org.junit.jupiter.api.Assumptions.assumeFalse; +import static org.junit.jupiter.api.Assumptions.assumeTrue; /** * An abstract test class for channel buffers @@ -93,14 +97,14 @@ public abstract class AbstractByteBufTest { return true; } - @Before + @BeforeEach public void init() { buffer = newBuffer(CAPACITY); seed = System.currentTimeMillis(); random = new Random(seed); } - @After + @AfterEach public void dispose() { if (buffer != null) { assertTrue(buffer.release()); @@ -139,34 +143,22 @@ public abstract class AbstractByteBufTest { assertEquals(0, buffer.readerIndex()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void readerIndexBoundaryCheck1() { - try { - buffer.writerIndex(0); - } catch (IndexOutOfBoundsException e) { - fail(); - } - buffer.readerIndex(-1); + buffer.writerIndex(0); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.readerIndex(-1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void readerIndexBoundaryCheck2() { - try { - buffer.writerIndex(buffer.capacity()); - } catch (IndexOutOfBoundsException e) { - fail(); - } - buffer.readerIndex(buffer.capacity() + 1); + buffer.writerIndex(buffer.capacity()); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.readerIndex(buffer.capacity() + 1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void readerIndexBoundaryCheck3() { - try { - buffer.writerIndex(CAPACITY / 2); - } catch (IndexOutOfBoundsException e) { - fail(); - } - buffer.readerIndex(CAPACITY * 3 / 2); + buffer.writerIndex(CAPACITY / 2); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.readerIndex(CAPACITY * 3 / 2)); } @Test @@ -177,31 +169,23 @@ public abstract class AbstractByteBufTest { buffer.readerIndex(buffer.capacity()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void writerIndexBoundaryCheck1() { - buffer.writerIndex(-1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.writerIndex(-1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void writerIndexBoundaryCheck2() { - try { - buffer.writerIndex(CAPACITY); - buffer.readerIndex(CAPACITY); - } catch (IndexOutOfBoundsException e) { - fail(); - } - buffer.writerIndex(buffer.capacity() + 1); + buffer.writerIndex(CAPACITY); + buffer.readerIndex(CAPACITY); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.writerIndex(buffer.capacity() + 1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void writerIndexBoundaryCheck3() { - try { - buffer.writerIndex(CAPACITY); - buffer.readerIndex(CAPACITY / 2); - } catch (IndexOutOfBoundsException e) { - fail(); - } - buffer.writerIndex(CAPACITY / 4); + buffer.writerIndex(CAPACITY); + buffer.readerIndex(CAPACITY / 2); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.writerIndex(CAPACITY / 4)); } @Test @@ -213,86 +197,81 @@ public abstract class AbstractByteBufTest { buffer.writeBytes(ByteBuffer.wrap(EMPTY_BYTES)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getBooleanBoundaryCheck1() { - buffer.getBoolean(-1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getBoolean(-1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getBooleanBoundaryCheck2() { - buffer.getBoolean(buffer.capacity()); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getBoolean(buffer.capacity())); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getByteBoundaryCheck1() { - buffer.getByte(-1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getByte(-1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getByteBoundaryCheck2() { - buffer.getByte(buffer.capacity()); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getByte(buffer.capacity())); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getShortBoundaryCheck1() { - buffer.getShort(-1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getShort(-1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getShortBoundaryCheck2() { - buffer.getShort(buffer.capacity() - 1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getShort(buffer.capacity() - 1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getMediumBoundaryCheck1() { - buffer.getMedium(-1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getMedium(-1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getMediumBoundaryCheck2() { - buffer.getMedium(buffer.capacity() - 2); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getMedium(buffer.capacity() - 2)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getIntBoundaryCheck1() { - buffer.getInt(-1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getInt(-1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getIntBoundaryCheck2() { - buffer.getInt(buffer.capacity() - 3); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getInt(buffer.capacity() - 3)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getLongBoundaryCheck1() { - buffer.getLong(-1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getLong(-1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getLongBoundaryCheck2() { - buffer.getLong(buffer.capacity() - 7); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getLong(buffer.capacity() - 7)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getByteArrayBoundaryCheck1() { - buffer.getBytes(-1, EMPTY_BYTES); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getBytes(-1, EMPTY_BYTES)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getByteArrayBoundaryCheck2() { - buffer.getBytes(-1, EMPTY_BYTES, 0, 0); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getBytes(-1, EMPTY_BYTES, 0, 0)); } @Test public void getByteArrayBoundaryCheck3() { byte[] dst = new byte[4]; buffer.setInt(0, 0x01020304); - try { - buffer.getBytes(0, dst, -1, 4); - fail(); - } catch (IndexOutOfBoundsException e) { - // Success - } + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getBytes(0, dst, -1, 4)); // No partial copy is expected. assertEquals(0, dst[0]); @@ -305,12 +284,7 @@ public abstract class AbstractByteBufTest { public void getByteArrayBoundaryCheck4() { byte[] dst = new byte[4]; buffer.setInt(0, 0x01020304); - try { - buffer.getBytes(0, dst, 1, 4); - fail(); - } catch (IndexOutOfBoundsException e) { - // Success - } + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getBytes(0, dst, 1, 4)); // No partial copy is expected. assertEquals(0, dst[0]); @@ -319,44 +293,44 @@ public abstract class AbstractByteBufTest { assertEquals(0, dst[3]); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getByteBufferBoundaryCheck() { - buffer.getBytes(-1, ByteBuffer.allocate(0)); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getBytes(-1, ByteBuffer.allocate(0))); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void copyBoundaryCheck1() { - buffer.copy(-1, 0); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.copy(-1, 0)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void copyBoundaryCheck2() { - buffer.copy(0, buffer.capacity() + 1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.copy(0, buffer.capacity() + 1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void copyBoundaryCheck3() { - buffer.copy(buffer.capacity() + 1, 0); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.copy(buffer.capacity() + 1, 0)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void copyBoundaryCheck4() { - buffer.copy(buffer.capacity(), 1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.copy(buffer.capacity(), 1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void setIndexBoundaryCheck1() { - buffer.setIndex(-1, CAPACITY); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.setIndex(-1, CAPACITY)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void setIndexBoundaryCheck2() { - buffer.setIndex(CAPACITY / 2, CAPACITY / 4); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.setIndex(CAPACITY / 2, CAPACITY / 4)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void setIndexBoundaryCheck3() { - buffer.setIndex(0, CAPACITY + 1); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.setIndex(0, CAPACITY + 1)); } @Test @@ -381,9 +355,9 @@ public abstract class AbstractByteBufTest { assertEquals(0, dst.get(3)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void getDirectByteBufferBoundaryCheck() { - buffer.getBytes(-1, ByteBuffer.allocateDirect(0)); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.getBytes(-1, ByteBuffer.allocateDirect(0))); } @Test @@ -1739,12 +1713,7 @@ public abstract class AbstractByteBufTest { @Test public void testWriteZero() { - try { - buffer.writeZero(-1); - fail(); - } catch (IllegalArgumentException e) { - // Expected - } + assertThrows(IllegalArgumentException.class, () -> buffer.writeZero(-1)); buffer.clear(); while (buffer.isWritable()) { @@ -1999,18 +1968,13 @@ public abstract class AbstractByteBufTest { assertEquals(buffer, wrappedBuffer(value).order(LITTLE_ENDIAN)); value[0] ++; - assertFalse(buffer.equals(wrappedBuffer(value))); - assertFalse(buffer.equals(wrappedBuffer(value).order(LITTLE_ENDIAN))); + assertNotEquals(buffer, wrappedBuffer(value)); + assertNotEquals(buffer, wrappedBuffer(value).order(LITTLE_ENDIAN)); } @Test public void testCompareTo() { - try { - buffer.compareTo(null); - fail(); - } catch (NullPointerException e) { - // Expected - } + assertThrows(NullPointerException.class, () -> buffer.compareTo(null)); // Fill the random stuff byte[] value = new byte[32]; @@ -2081,7 +2045,7 @@ public abstract class AbstractByteBufTest { copied.release(); } - @Test(timeout = 10000) + @Test public void testToStringMultipleThreads() throws Throwable { buffer.clear(); buffer.writeBytes("Hello, World!".getBytes(CharsetUtil.ISO_8859_1)); @@ -2105,9 +2069,11 @@ public abstract class AbstractByteBufTest { thread.start(); } - for (Thread thread : threads) { - thread.join(); - } + assertTimeoutPreemptively(Duration.ofSeconds(10), () -> { + for (Thread thread : threads) { + thread.join(); + } + }); Throwable error = errorRef.get(); if (error != null) { @@ -2162,19 +2128,8 @@ public abstract class AbstractByteBufTest { assertEquals(1, buffer.indexOf(1, 4, (byte) 2)); assertEquals(3, buffer.indexOf(4, 1, (byte) 2)); - try { - buffer.indexOf(0, buffer.capacity() + 1, (byte) 0); - fail(); - } catch (IndexOutOfBoundsException expected) { - // expected - } - - try { - buffer.indexOf(buffer.capacity(), -1, (byte) 0); - fail(); - } catch (IndexOutOfBoundsException expected) { - // expected - } + assertThrows(IndexOutOfBoundsException.class, () -> buffer.indexOf(0, buffer.capacity() + 1, (byte) 0)); + assertThrows(IndexOutOfBoundsException.class, () -> buffer.indexOf(buffer.capacity(), -1, (byte) 0)); assertEquals(4, buffer.indexOf(buffer.capacity() + 1, 0, (byte) 1)); assertEquals(0, buffer.indexOf(-1, buffer.capacity(), (byte) 1)); @@ -2184,12 +2139,7 @@ public abstract class AbstractByteBufTest { public void testIndexOfReleaseBuffer() { ByteBuf buffer = releasedBuffer(); if (buffer.capacity() != 0) { - try { - buffer.indexOf(0, 1, (byte) 1); - fail(); - } catch (IllegalReferenceCountException expected) { - // expected - } + assertThrows(IllegalReferenceCountException.class, () -> buffer.indexOf(0, 1, (byte) 1)); } else { assertEquals(-1, buffer.indexOf(0, 1, (byte) 1)); } @@ -2247,12 +2197,7 @@ public abstract class AbstractByteBufTest { buffer.skipBytes(CAPACITY / 4); assertEquals(CAPACITY / 4 * 2, buffer.readerIndex()); - try { - buffer.skipBytes(CAPACITY / 4 + 1); - fail(); - } catch (IndexOutOfBoundsException e) { - // Expected - } + assertThrows(IndexOutOfBoundsException.class, () -> buffer.skipBytes(CAPACITY / 4 + 1)); // Should remain unchanged. assertEquals(CAPACITY / 4 * 2, buffer.readerIndex()); @@ -2559,20 +2504,21 @@ public abstract class AbstractByteBufTest { buffer.release(); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void readByteThrowsIndexOutOfBoundsException() { - final ByteBuf buffer = newBuffer(8); - try { - buffer.writeByte(0); - assertEquals((byte) 0, buffer.readByte()); - buffer.readByte(); - } finally { - buffer.release(); - } + assertThrows(IndexOutOfBoundsException.class, () -> { + final ByteBuf buffer = newBuffer(8); + try { + buffer.writeByte(0); + assertEquals((byte) 0, buffer.readByte()); + buffer.readByte(); + } finally { + buffer.release(); + } + }); } @Test - @SuppressWarnings("ForLoopThatDoesntUseLoopVariable") public void testNioBufferExposeOnlyRegion() { final ByteBuf buffer = newBuffer(8); byte[] data = new byte[8]; @@ -2626,730 +2572,751 @@ public abstract class AbstractByteBufTest { return buffer; } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testDiscardReadBytesAfterRelease() { - releasedBuffer().discardReadBytes(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().discardReadBytes()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testDiscardSomeReadBytesAfterRelease() { - releasedBuffer().discardSomeReadBytes(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().discardSomeReadBytes()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testEnsureWritableAfterRelease() { - releasedBuffer().ensureWritable(16); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().ensureWritable(16)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetBooleanAfterRelease() { - releasedBuffer().getBoolean(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getBoolean(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetByteAfterRelease() { - releasedBuffer().getByte(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getByte(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetUnsignedByteAfterRelease() { - releasedBuffer().getUnsignedByte(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getUnsignedByte(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetShortAfterRelease() { - releasedBuffer().getShort(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getShort(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetShortLEAfterRelease() { - releasedBuffer().getShortLE(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getShortLE(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetUnsignedShortAfterRelease() { - releasedBuffer().getUnsignedShort(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getUnsignedShort(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetUnsignedShortLEAfterRelease() { - releasedBuffer().getUnsignedShortLE(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getUnsignedShortLE(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetMediumAfterRelease() { - releasedBuffer().getMedium(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getMedium(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetMediumLEAfterRelease() { - releasedBuffer().getMediumLE(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getMediumLE(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetUnsignedMediumAfterRelease() { - releasedBuffer().getUnsignedMedium(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getUnsignedMedium(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetIntAfterRelease() { - releasedBuffer().getInt(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getInt(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetIntLEAfterRelease() { - releasedBuffer().getIntLE(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getIntLE(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetUnsignedIntAfterRelease() { - releasedBuffer().getUnsignedInt(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getUnsignedInt(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetUnsignedIntLEAfterRelease() { - releasedBuffer().getUnsignedIntLE(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getUnsignedIntLE(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetLongAfterRelease() { - releasedBuffer().getLong(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getLong(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetLongLEAfterRelease() { - releasedBuffer().getLongLE(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getLongLE(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetCharAfterRelease() { - releasedBuffer().getChar(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getChar(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetFloatAfterRelease() { - releasedBuffer().getFloat(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getFloat(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetFloatLEAfterRelease() { - releasedBuffer().getFloatLE(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getFloatLE(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetDoubleAfterRelease() { - releasedBuffer().getDouble(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getDouble(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetDoubleLEAfterRelease() { - releasedBuffer().getDoubleLE(0); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getDoubleLE(0)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetBytesAfterRelease() { - ByteBuf buffer = buffer(8); - try { - releasedBuffer().getBytes(0, buffer); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(8); + try { + releasedBuffer().getBytes(0, buffer); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetBytesAfterRelease2() { - ByteBuf buffer = buffer(); - try { - releasedBuffer().getBytes(0, buffer, 1); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(); + try { + releasedBuffer().getBytes(0, buffer, 1); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetBytesAfterRelease3() { - ByteBuf buffer = buffer(); - try { - releasedBuffer().getBytes(0, buffer, 0, 1); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(); + try { + releasedBuffer().getBytes(0, buffer, 0, 1); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetBytesAfterRelease4() { - releasedBuffer().getBytes(0, new byte[8]); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getBytes(0, new byte[8])); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetBytesAfterRelease5() { - releasedBuffer().getBytes(0, new byte[8], 0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getBytes(0, new byte[8], 0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetBytesAfterRelease6() { - releasedBuffer().getBytes(0, ByteBuffer.allocate(8)); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getBytes(0, ByteBuffer.allocate(8))); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetBytesAfterRelease7() throws IOException { - releasedBuffer().getBytes(0, new ByteArrayOutputStream(), 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getBytes(0, new ByteArrayOutputStream(), 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testGetBytesAfterRelease8() throws IOException { - releasedBuffer().getBytes(0, new DevNullGatheringByteChannel(), 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().getBytes(0, new DevNullGatheringByteChannel(), 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetBooleanAfterRelease() { - releasedBuffer().setBoolean(0, true); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setBoolean(0, true)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetByteAfterRelease() { - releasedBuffer().setByte(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setByte(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetShortAfterRelease() { - releasedBuffer().setShort(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setShort(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetShortLEAfterRelease() { - releasedBuffer().setShortLE(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setShortLE(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetMediumAfterRelease() { - releasedBuffer().setMedium(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setMedium(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetMediumLEAfterRelease() { - releasedBuffer().setMediumLE(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setMediumLE(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetIntAfterRelease() { - releasedBuffer().setInt(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setInt(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetIntLEAfterRelease() { - releasedBuffer().setIntLE(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setIntLE(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetLongAfterRelease() { - releasedBuffer().setLong(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setLong(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetLongLEAfterRelease() { - releasedBuffer().setLongLE(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setLongLE(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetCharAfterRelease() { - releasedBuffer().setChar(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setChar(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetFloatAfterRelease() { - releasedBuffer().setFloat(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setFloat(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetDoubleAfterRelease() { - releasedBuffer().setDouble(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setDouble(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetBytesAfterRelease() { - ByteBuf buffer = buffer(); - try { - releasedBuffer().setBytes(0, buffer); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(); + try { + releasedBuffer().setBytes(0, buffer); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetBytesAfterRelease2() { - ByteBuf buffer = buffer(); - try { - releasedBuffer().setBytes(0, buffer, 1); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(); + try { + releasedBuffer().setBytes(0, buffer, 1); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetBytesAfterRelease3() { - ByteBuf buffer = buffer(); - try { - releasedBuffer().setBytes(0, buffer, 0, 1); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(); + try { + releasedBuffer().setBytes(0, buffer, 0, 1); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetUsAsciiCharSequenceAfterRelease() { - testSetCharSequenceAfterRelease0(CharsetUtil.US_ASCII); + assertThrows(IllegalReferenceCountException.class, () -> testSetCharSequenceAfterRelease0(CharsetUtil.US_ASCII)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetIso88591CharSequenceAfterRelease() { - testSetCharSequenceAfterRelease0(CharsetUtil.ISO_8859_1); + assertThrows(IllegalReferenceCountException.class, () -> testSetCharSequenceAfterRelease0(CharsetUtil.ISO_8859_1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetUtf8CharSequenceAfterRelease() { - testSetCharSequenceAfterRelease0(CharsetUtil.UTF_8); + assertThrows(IllegalReferenceCountException.class, () -> testSetCharSequenceAfterRelease0(CharsetUtil.UTF_8)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetUtf16CharSequenceAfterRelease() { - testSetCharSequenceAfterRelease0(CharsetUtil.UTF_16); + assertThrows(IllegalReferenceCountException.class, () -> testSetCharSequenceAfterRelease0(CharsetUtil.UTF_16)); } private void testSetCharSequenceAfterRelease0(Charset charset) { releasedBuffer().setCharSequence(0, "x", charset); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetBytesAfterRelease4() { - releasedBuffer().setBytes(0, new byte[8]); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setBytes(0, new byte[8])); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetBytesAfterRelease5() { - releasedBuffer().setBytes(0, new byte[8], 0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setBytes(0, new byte[8], 0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetBytesAfterRelease6() { - releasedBuffer().setBytes(0, ByteBuffer.allocate(8)); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setBytes(0, ByteBuffer.allocate(8))); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetBytesAfterRelease7() throws IOException { - releasedBuffer().setBytes(0, new ByteArrayInputStream(new byte[8]), 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setBytes(0, new ByteArrayInputStream(new byte[8]), 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetBytesAfterRelease8() throws IOException { - releasedBuffer().setBytes(0, new TestScatteringByteChannel(), 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setBytes(0, new TestScatteringByteChannel(), 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSetZeroAfterRelease() { - releasedBuffer().setZero(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().setZero(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBooleanAfterRelease() { - releasedBuffer().readBoolean(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readBoolean()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadByteAfterRelease() { - releasedBuffer().readByte(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readByte()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadUnsignedByteAfterRelease() { - releasedBuffer().readUnsignedByte(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readUnsignedByte()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadShortAfterRelease() { - releasedBuffer().readShort(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readShort()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadShortLEAfterRelease() { - releasedBuffer().readShortLE(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readShortLE()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadUnsignedShortAfterRelease() { - releasedBuffer().readUnsignedShort(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readUnsignedShort()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadUnsignedShortLEAfterRelease() { - releasedBuffer().readUnsignedShortLE(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readUnsignedShortLE()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadMediumAfterRelease() { - releasedBuffer().readMedium(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readMedium()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadMediumLEAfterRelease() { - releasedBuffer().readMediumLE(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readMediumLE()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadUnsignedMediumAfterRelease() { - releasedBuffer().readUnsignedMedium(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readUnsignedMedium()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadUnsignedMediumLEAfterRelease() { - releasedBuffer().readUnsignedMediumLE(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readUnsignedMediumLE()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadIntAfterRelease() { - releasedBuffer().readInt(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readInt()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadIntLEAfterRelease() { - releasedBuffer().readIntLE(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readIntLE()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadUnsignedIntAfterRelease() { - releasedBuffer().readUnsignedInt(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readUnsignedInt()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadUnsignedIntLEAfterRelease() { - releasedBuffer().readUnsignedIntLE(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readUnsignedIntLE()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadLongAfterRelease() { - releasedBuffer().readLong(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readLong()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadLongLEAfterRelease() { - releasedBuffer().readLongLE(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readLongLE()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadCharAfterRelease() { - releasedBuffer().readChar(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readChar()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadFloatAfterRelease() { - releasedBuffer().readFloat(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readFloat()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadFloatLEAfterRelease() { - releasedBuffer().readFloatLE(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readFloatLE()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadDoubleAfterRelease() { - releasedBuffer().readDouble(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readDouble()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadDoubleLEAfterRelease() { - releasedBuffer().readDoubleLE(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readDoubleLE()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBytesAfterRelease() { - releasedBuffer().readBytes(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readBytes(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBytesAfterRelease2() { - ByteBuf buffer = buffer(8); - try { - releasedBuffer().readBytes(buffer); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(8); + try { + releasedBuffer().readBytes(buffer); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBytesAfterRelease3() { - ByteBuf buffer = buffer(8); - try { - releasedBuffer().readBytes(buffer); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(8); + try { + releasedBuffer().readBytes(buffer); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBytesAfterRelease4() { - ByteBuf buffer = buffer(8); - try { - releasedBuffer().readBytes(buffer, 0, 1); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(8); + try { + releasedBuffer().readBytes(buffer, 0, 1); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBytesAfterRelease5() { - releasedBuffer().readBytes(new byte[8]); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readBytes(new byte[8])); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBytesAfterRelease6() { - releasedBuffer().readBytes(new byte[8], 0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readBytes(new byte[8], 0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBytesAfterRelease7() { - releasedBuffer().readBytes(ByteBuffer.allocate(8)); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readBytes(ByteBuffer.allocate(8))); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBytesAfterRelease8() throws IOException { - releasedBuffer().readBytes(new ByteArrayOutputStream(), 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readBytes(new ByteArrayOutputStream(), 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBytesAfterRelease9() throws IOException { - releasedBuffer().readBytes(new ByteArrayOutputStream(), 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readBytes(new ByteArrayOutputStream(), 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testReadBytesAfterRelease10() throws IOException { - releasedBuffer().readBytes(new DevNullGatheringByteChannel(), 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().readBytes(new DevNullGatheringByteChannel(), 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteBooleanAfterRelease() { - releasedBuffer().writeBoolean(true); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeBoolean(true)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteByteAfterRelease() { - releasedBuffer().writeByte(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeByte(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteShortAfterRelease() { - releasedBuffer().writeShort(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeShort(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteShortLEAfterRelease() { - releasedBuffer().writeShortLE(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeShortLE(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteMediumAfterRelease() { - releasedBuffer().writeMedium(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeMedium(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteMediumLEAfterRelease() { - releasedBuffer().writeMediumLE(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeMediumLE(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteIntAfterRelease() { - releasedBuffer().writeInt(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeInt(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteIntLEAfterRelease() { - releasedBuffer().writeIntLE(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeIntLE(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteLongAfterRelease() { - releasedBuffer().writeLong(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeLong(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteLongLEAfterRelease() { - releasedBuffer().writeLongLE(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeLongLE(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteCharAfterRelease() { - releasedBuffer().writeChar(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeChar(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteFloatAfterRelease() { - releasedBuffer().writeFloat(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeFloat(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteFloatLEAfterRelease() { - releasedBuffer().writeFloatLE(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeFloatLE(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteDoubleAfterRelease() { - releasedBuffer().writeDouble(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeDouble(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteDoubleLEAfterRelease() { - releasedBuffer().writeDoubleLE(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeDoubleLE(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteBytesAfterRelease() { - ByteBuf buffer = buffer(8); - try { - releasedBuffer().writeBytes(buffer); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(8); + try { + releasedBuffer().writeBytes(buffer); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteBytesAfterRelease2() { - ByteBuf buffer = copiedBuffer(new byte[8]); - try { - releasedBuffer().writeBytes(buffer, 1); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = copiedBuffer(new byte[8]); + try { + releasedBuffer().writeBytes(buffer, 1); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteBytesAfterRelease3() { - ByteBuf buffer = buffer(8); - try { - releasedBuffer().writeBytes(buffer, 0, 1); - } finally { - buffer.release(); - } + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf buffer = buffer(8); + try { + releasedBuffer().writeBytes(buffer, 0, 1); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteBytesAfterRelease4() { - releasedBuffer().writeBytes(new byte[8]); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeBytes(new byte[8])); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteBytesAfterRelease5() { - releasedBuffer().writeBytes(new byte[8], 0 , 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeBytes(new byte[8], 0 , 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteBytesAfterRelease6() { - releasedBuffer().writeBytes(ByteBuffer.allocate(8)); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeBytes(ByteBuffer.allocate(8))); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteBytesAfterRelease7() throws IOException { - releasedBuffer().writeBytes(new ByteArrayInputStream(new byte[8]), 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeBytes(new ByteArrayInputStream(new byte[8]), 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteBytesAfterRelease8() throws IOException { - releasedBuffer().writeBytes(new TestScatteringByteChannel(), 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeBytes(new TestScatteringByteChannel(), 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteZeroAfterRelease() throws IOException { - releasedBuffer().writeZero(1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().writeZero(1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteUsAsciiCharSequenceAfterRelease() { - testWriteCharSequenceAfterRelease0(CharsetUtil.US_ASCII); + assertThrows(IllegalReferenceCountException.class, () -> testWriteCharSequenceAfterRelease0(CharsetUtil.US_ASCII)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteIso88591CharSequenceAfterRelease() { - testWriteCharSequenceAfterRelease0(CharsetUtil.ISO_8859_1); + assertThrows(IllegalReferenceCountException.class, () -> testWriteCharSequenceAfterRelease0(CharsetUtil.ISO_8859_1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteUtf8CharSequenceAfterRelease() { - testWriteCharSequenceAfterRelease0(CharsetUtil.UTF_8); + assertThrows(IllegalReferenceCountException.class, () -> testWriteCharSequenceAfterRelease0(CharsetUtil.UTF_8)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testWriteUtf16CharSequenceAfterRelease() { - testWriteCharSequenceAfterRelease0(CharsetUtil.UTF_16); + assertThrows(IllegalReferenceCountException.class, () -> testWriteCharSequenceAfterRelease0(CharsetUtil.UTF_16)); } private void testWriteCharSequenceAfterRelease0(Charset charset) { releasedBuffer().writeCharSequence("x", charset); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testForEachByteAfterRelease() { - releasedBuffer().forEachByte(new TestByteProcessor()); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().forEachByte(new TestByteProcessor())); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testForEachByteAfterRelease1() { - releasedBuffer().forEachByte(0, 1, new TestByteProcessor()); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().forEachByte(0, 1, new TestByteProcessor())); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testForEachByteDescAfterRelease() { - releasedBuffer().forEachByteDesc(new TestByteProcessor()); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().forEachByteDesc(new TestByteProcessor())); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testForEachByteDescAfterRelease1() { - releasedBuffer().forEachByteDesc(0, 1, new TestByteProcessor()); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().forEachByteDesc(0, 1, new TestByteProcessor())); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testCopyAfterRelease() { - releasedBuffer().copy(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().copy()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testCopyAfterRelease1() { - releasedBuffer().copy(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().copy()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testNioBufferAfterRelease() { - releasedBuffer().nioBuffer(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().nioBuffer()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testNioBufferAfterRelease1() { - releasedBuffer().nioBuffer(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().nioBuffer(0, 1)); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testInternalNioBufferAfterRelease() { - ByteBuf releasedBuffer = releasedBuffer(); - releasedBuffer.internalNioBuffer(releasedBuffer.readerIndex(), 1); + assertThrows(IllegalReferenceCountException.class, () -> { + ByteBuf releasedBuffer = releasedBuffer(); + releasedBuffer.internalNioBuffer(releasedBuffer.readerIndex(), 1); + }); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testNioBuffersAfterRelease() { - releasedBuffer().nioBuffers(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().nioBuffers()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testNioBuffersAfterRelease2() { - releasedBuffer().nioBuffers(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().nioBuffers(0, 1)); } @Test public void testArrayAfterRelease() { ByteBuf buf = releasedBuffer(); if (buf.hasArray()) { - try { - buf.array(); - fail(); - } catch (IllegalReferenceCountException e) { - // expected - } + assertThrows(IllegalReferenceCountException.class, () -> buf.array()); } } @@ -3357,23 +3324,18 @@ public abstract class AbstractByteBufTest { public void testMemoryAddressAfterRelease() { ByteBuf buf = releasedBuffer(); if (buf.hasMemoryAddress()) { - try { - buf.memoryAddress(); - fail(); - } catch (IllegalReferenceCountException e) { - // expected - } + assertThrows(IllegalReferenceCountException.class, () -> buf.memoryAddress()); } } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSliceAfterRelease() { - releasedBuffer().slice(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().slice()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testSliceAfterRelease2() { - releasedBuffer().slice(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().slice(0, 1)); } private static void assertSliceFailAfterRelease(ByteBuf... bufs) { @@ -3383,13 +3345,8 @@ public abstract class AbstractByteBufTest { } } for (ByteBuf buf : bufs) { - try { - assertEquals(0, buf.refCnt()); - buf.slice(); - fail(); - } catch (IllegalReferenceCountException ignored) { - // as expected - } + assertEquals(0, buf.refCnt()); + assertThrows(IllegalReferenceCountException.class, () -> buf.slice()); } } @@ -3431,14 +3388,14 @@ public abstract class AbstractByteBufTest { assertSliceFailAfterRelease(buf, buf2, buf3); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testRetainedSliceAfterRelease() { - releasedBuffer().retainedSlice(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().retainedSlice()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testRetainedSliceAfterRelease2() { - releasedBuffer().retainedSlice(0, 1); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().retainedSlice(0, 1)); } private static void assertRetainedSliceFailAfterRelease(ByteBuf... bufs) { @@ -3448,13 +3405,8 @@ public abstract class AbstractByteBufTest { } } for (ByteBuf buf : bufs) { - try { - assertEquals(0, buf.refCnt()); - buf.retainedSlice(); - fail(); - } catch (IllegalReferenceCountException ignored) { - // as expected - } + assertEquals(0, buf.refCnt()); + assertThrows(IllegalReferenceCountException.class, () -> buf.retainedSlice()); } } @@ -3496,14 +3448,14 @@ public abstract class AbstractByteBufTest { assertRetainedSliceFailAfterRelease(buf, buf2, buf3); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testDuplicateAfterRelease() { - releasedBuffer().duplicate(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().duplicate()); } - @Test(expected = IllegalReferenceCountException.class) + @Test public void testRetainedDuplicateAfterRelease() { - releasedBuffer().retainedDuplicate(); + assertThrows(IllegalReferenceCountException.class, () -> releasedBuffer().retainedDuplicate()); } private static void assertDuplicateFailAfterRelease(ByteBuf... bufs) { @@ -3513,13 +3465,8 @@ public abstract class AbstractByteBufTest { } } for (ByteBuf buf : bufs) { - try { - assertEquals(0, buf.refCnt()); - buf.duplicate(); - fail(); - } catch (IllegalReferenceCountException ignored) { - // as expected - } + assertEquals(0, buf.refCnt()); + assertThrows(IllegalReferenceCountException.class, () -> buf.duplicate()); } } @@ -3553,13 +3500,8 @@ public abstract class AbstractByteBufTest { } } for (ByteBuf buf : bufs) { - try { - assertEquals(0, buf.refCnt()); - buf.retainedDuplicate(); - fail(); - } catch (IllegalReferenceCountException ignored) { - // as expected - } + assertEquals(0, buf.refCnt()); + assertThrows(IllegalReferenceCountException.class, () -> buf.retainedDuplicate()); } } @@ -3592,14 +3534,14 @@ public abstract class AbstractByteBufTest { assertEquals(0, buf.refCnt()); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testReadSliceOutOfBounds() { - testReadSliceOutOfBounds(false); + assertThrows(IndexOutOfBoundsException.class, () -> testReadSliceOutOfBounds(false)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testReadRetainedSliceOutOfBounds() { - testReadSliceOutOfBounds(true); + assertThrows(IndexOutOfBoundsException.class, () -> testReadSliceOutOfBounds(true)); } private void testReadSliceOutOfBounds(boolean retainedSlice) { @@ -3648,24 +3590,24 @@ public abstract class AbstractByteBufTest { } } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testSetUsAsciiCharSequenceNoExpand() { - testSetCharSequenceNoExpand(CharsetUtil.US_ASCII); + assertThrows(IndexOutOfBoundsException.class, () -> testSetCharSequenceNoExpand(CharsetUtil.US_ASCII)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testSetUtf8CharSequenceNoExpand() { - testSetCharSequenceNoExpand(CharsetUtil.UTF_8); + assertThrows(IndexOutOfBoundsException.class, () -> testSetCharSequenceNoExpand(CharsetUtil.UTF_8)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testSetIso88591CharSequenceNoExpand() { - testSetCharSequenceNoExpand(CharsetUtil.ISO_8859_1); + assertThrows(IndexOutOfBoundsException.class, () -> testSetCharSequenceNoExpand(CharsetUtil.ISO_8859_1)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testSetUtf16CharSequenceNoExpand() { - testSetCharSequenceNoExpand(CharsetUtil.UTF_16); + assertThrows(IndexOutOfBoundsException.class, () -> testSetCharSequenceNoExpand(CharsetUtil.UTF_16)); } private void testSetCharSequenceNoExpand(Charset charset) { @@ -3748,44 +3690,44 @@ public abstract class AbstractByteBufTest { buf.release(); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRetainedSliceIndexOutOfBounds() { - testSliceOutOfBounds(true, true, true); + assertThrows(IndexOutOfBoundsException.class, () -> testSliceOutOfBounds(true, true, true)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testRetainedSliceLengthOutOfBounds() { - testSliceOutOfBounds(true, true, false); + assertThrows(IndexOutOfBoundsException.class, () -> testSliceOutOfBounds(true, true, false)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testMixedSliceAIndexOutOfBounds() { - testSliceOutOfBounds(true, false, true); + assertThrows(IndexOutOfBoundsException.class, () -> testSliceOutOfBounds(true, false, true)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testMixedSliceALengthOutOfBounds() { - testSliceOutOfBounds(true, false, false); + assertThrows(IndexOutOfBoundsException.class, () -> testSliceOutOfBounds(true, false, false)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testMixedSliceBIndexOutOfBounds() { - testSliceOutOfBounds(false, true, true); + assertThrows(IndexOutOfBoundsException.class, () -> testSliceOutOfBounds(false, true, true)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testMixedSliceBLengthOutOfBounds() { - testSliceOutOfBounds(false, true, false); + assertThrows(IndexOutOfBoundsException.class, () -> testSliceOutOfBounds(false, true, false)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testSliceIndexOutOfBounds() { - testSliceOutOfBounds(false, false, true); + assertThrows(IndexOutOfBoundsException.class, () -> testSliceOutOfBounds(false, false, true)); } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testSliceLengthOutOfBounds() { - testSliceOutOfBounds(false, false, false); + assertThrows(IndexOutOfBoundsException.class, () -> testSliceOutOfBounds(false, false, false)); } @Test @@ -4041,14 +3983,14 @@ public abstract class AbstractByteBufTest { testDuplicateCapacityChange(true); } - @Test(expected = UnsupportedOperationException.class) + @Test public void testSliceCapacityChange() { - testSliceCapacityChange(false); + assertThrows(UnsupportedOperationException.class, () -> testSliceCapacityChange(false)); } - @Test(expected = UnsupportedOperationException.class) + @Test public void testRetainedSliceCapacityChange() { - testSliceCapacityChange(true); + assertThrows(UnsupportedOperationException.class, () -> testSliceCapacityChange(true)); } @Test @@ -4523,12 +4465,7 @@ public abstract class AbstractByteBufTest { ByteBuffer dst = direct ? ByteBuffer.allocateDirect(bytes.length) : ByteBuffer.allocate(bytes.length); ByteBuffer readOnlyDst = dst.asReadOnlyBuffer(); - try { - buffer.getBytes(0, readOnlyDst); - fail(); - } catch (ReadOnlyBufferException e) { - // expected - } + assertThrows(ReadOnlyBufferException.class, () -> buffer.getBytes(0, readOnlyDst)); assertEquals(0, readOnlyDst.position()); buffer.release(); } @@ -4674,18 +4611,20 @@ public abstract class AbstractByteBufTest { } } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testGetBytesByteBuffer() { - byte[] bytes = {'a', 'b', 'c', 'd', 'e', 'f', 'g'}; - // Ensure destination buffer is bigger then what is in the ByteBuf. - ByteBuffer nioBuffer = ByteBuffer.allocate(bytes.length + 1); - ByteBuf buffer = newBuffer(bytes.length); - try { - buffer.writeBytes(bytes); - buffer.getBytes(buffer.readerIndex(), nioBuffer); - } finally { - buffer.release(); - } + assertThrows(IndexOutOfBoundsException.class, () -> { + byte[] bytes = {'a', 'b', 'c', 'd', 'e', 'f', 'g'}; + // Ensure destination buffer is bigger then what is in the ByteBuf. + ByteBuffer nioBuffer = ByteBuffer.allocate(bytes.length + 1); + ByteBuf buffer = newBuffer(bytes.length); + try { + buffer.writeBytes(bytes); + buffer.getBytes(buffer.readerIndex(), nioBuffer); + } finally { + buffer.release(); + } + }); } private void testRefCnt0(final boolean parameter) throws Exception { @@ -4840,28 +4779,32 @@ public abstract class AbstractByteBufTest { } } - @Test(expected = IllegalArgumentException.class) + @Test public void testCapacityEnforceMaxCapacity() { - ByteBuf buffer = newBuffer(3, 13); - assertEquals(13, buffer.maxCapacity()); - assertEquals(3, buffer.capacity()); - try { - buffer.capacity(14); - } finally { - buffer.release(); - } + assertThrows(IllegalArgumentException.class, () -> { + ByteBuf buffer = newBuffer(3, 13); + assertEquals(13, buffer.maxCapacity()); + assertEquals(3, buffer.capacity()); + try { + buffer.capacity(14); + } finally { + buffer.release(); + } + }); } - @Test(expected = IllegalArgumentException.class) + @Test public void testCapacityNegative() { - ByteBuf buffer = newBuffer(3, 13); - assertEquals(13, buffer.maxCapacity()); - assertEquals(3, buffer.capacity()); - try { - buffer.capacity(-1); - } finally { - buffer.release(); - } + assertThrows(IllegalArgumentException.class, () -> { + ByteBuf buffer = newBuffer(3, 13); + assertEquals(13, buffer.maxCapacity()); + assertEquals(3, buffer.capacity()); + try { + buffer.capacity(-1); + } finally { + buffer.release(); + } + }); } @Test @@ -4892,24 +4835,26 @@ public abstract class AbstractByteBufTest { } } - @Test(expected = IndexOutOfBoundsException.class) + @Test public void testReaderIndexLargerThanWriterIndex() { - String content1 = "hello"; - String content2 = "world"; - int length = content1.length() + content2.length(); - ByteBuf buffer = newBuffer(length); - buffer.setIndex(0, 0); - buffer.writeCharSequence(content1, CharsetUtil.US_ASCII); - buffer.skipBytes(content1.length()); - buffer.writeCharSequence(content2, CharsetUtil.US_ASCII); - buffer.skipBytes(content2.length()); - assertTrue(buffer.readerIndex() <= buffer.writerIndex()); + assertThrows(IndexOutOfBoundsException.class, () -> { + String content1 = "hello"; + String content2 = "world"; + int length = content1.length() + content2.length(); + ByteBuf buffer = newBuffer(length); + buffer.setIndex(0, 0); + buffer.writeCharSequence(content1, CharsetUtil.US_ASCII); + buffer.skipBytes(content1.length()); + buffer.writeCharSequence(content2, CharsetUtil.US_ASCII); + buffer.skipBytes(content2.length()); + assertTrue(buffer.readerIndex() <= buffer.writerIndex()); - try { - buffer.readerIndex(buffer.writerIndex() + 1); - } finally { - buffer.release(); - } + try { + buffer.readerIndex(buffer.writerIndex() + 1); + } finally { + buffer.release(); + } + }); } @Test @@ -4930,10 +4875,7 @@ public abstract class AbstractByteBufTest { buffer.writerIndex(buffer.readerIndex()); buffer.writeByte(1); try { - buffer.ensureWritable(Integer.MAX_VALUE); - fail(); - } catch (IndexOutOfBoundsException e) { - // expected + assertThrows(IndexOutOfBoundsException.class, () -> buffer.ensureWritable(Integer.MAX_VALUE)); } finally { buffer.release(); } diff --git a/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/ByteBufAdaptorTest.java b/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/ByteBufAdaptorTest.java index 3cc8d9d..6b83159 100644 --- a/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/ByteBufAdaptorTest.java +++ b/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/ByteBufAdaptorTest.java @@ -19,27 +19,29 @@ import io.netty.buffer.ByteBuf; import io.netty.buffer.api.BufferAllocator; import io.netty.buffer.api.MemoryManagers; import io.netty.buffer.api.adaptor.ByteBufAllocatorAdaptor; -import org.junit.AfterClass; -import org.junit.Ignore; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Disabled; import java.util.Optional; -import static org.junit.Assume.assumeTrue; +import static org.junit.jupiter.api.Assumptions.assumeTrue; public abstract class ByteBufAdaptorTest extends AbstractByteBufTest { static ByteBufAllocatorAdaptor alloc; static void setUpAllocator(String name) { Optional managers = MemoryManagers.lookupImplementation(name); - assumeTrue(managers.isPresent()); + assumeTrue(managers.isPresent(), () -> "Memory implementation '" + name + "' not found."); BufferAllocator onheap = MemoryManagers.using(managers.get(), BufferAllocator::pooledHeap); BufferAllocator offheap = MemoryManagers.using(managers.get(), BufferAllocator::pooledHeap); alloc = new ByteBufAllocatorAdaptor(onheap, offheap); } - @AfterClass + @AfterAll public static void tearDownAllocator() throws Exception { - alloc.close(); + if (alloc != null) { + alloc.close(); + } } @Override @@ -47,50 +49,50 @@ public abstract class ByteBufAdaptorTest extends AbstractByteBufTest { return alloc.buffer(capacity, capacity); } - @Ignore("This test codifies that asking to reading 0 bytes from an empty but unclosed stream should return -1, " + + @Disabled("This test codifies that asking to reading 0 bytes from an empty but unclosed stream should return -1, " + "which is just weird.") @Override public void testStreamTransfer1() throws Exception { } - @Ignore("Relies on capacity and max capacity being separate things.") + @Disabled("Relies on capacity and max capacity being separate things.") @Override public void testCapacityIncrease() { } - @Ignore("Decreasing capacity not supported in new API.") + @Disabled("Decreasing capacity not supported in new API.") @Override public void testCapacityDecrease() { } - @Ignore("Decreasing capacity not supported in new API.") + @Disabled("Decreasing capacity not supported in new API.") @Override public void testCapacityNegative() { throw new IllegalArgumentException(); // Can't ignore tests annotated with throws expectation? } - @Ignore("Decreasing capacity not supported in new API.") + @Disabled("Decreasing capacity not supported in new API.") @Override public void testCapacityEnforceMaxCapacity() { throw new IllegalArgumentException(); // Can't ignore tests annotated with throws expectation? } - @Ignore("Decreasing capacity not supported in new API.") + @Disabled("Decreasing capacity not supported in new API.") @Override public void testMaxFastWritableBytes() { } - @Ignore("Impossible to expose entire memory as a ByteBuffer using new API.") + @Disabled("Impossible to expose entire memory as a ByteBuffer using new API.") @Override public void testNioBufferExposeOnlyRegion() { } - @Ignore("Impossible to expose entire memory as a ByteBuffer using new API.") + @Disabled("Impossible to expose entire memory as a ByteBuffer using new API.") @Override public void testToByteBuffer2() { } - @Ignore("No longer allowed to allocate 0 sized buffers, except for composite buffers with no components.") + @Disabled("No longer allowed to allocate 0 sized buffers, except for composite buffers with no components.") @Override public void testLittleEndianWithExpand() { } diff --git a/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/MemSegByteBufAdaptorTest.java b/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/MemSegByteBufAdaptorTest.java index ebd34d7..78468d1 100644 --- a/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/MemSegByteBufAdaptorTest.java +++ b/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/MemSegByteBufAdaptorTest.java @@ -15,10 +15,10 @@ */ package io.netty.buffer.api.tests.adaptor; -import org.junit.BeforeClass; +import org.junit.jupiter.api.BeforeAll; public class MemSegByteBufAdaptorTest extends ByteBufAdaptorTest { - @BeforeClass + @BeforeAll public static void setUpAllocator() { setUpAllocator("MemorySegment"); } diff --git a/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/NioByteBufAdaptorTest.java b/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/NioByteBufAdaptorTest.java index 34d5637..de0f4e1 100644 --- a/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/NioByteBufAdaptorTest.java +++ b/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/NioByteBufAdaptorTest.java @@ -15,10 +15,10 @@ */ package io.netty.buffer.api.tests.adaptor; -import org.junit.BeforeClass; +import org.junit.jupiter.api.BeforeAll; public class NioByteBufAdaptorTest extends ByteBufAdaptorTest { - @BeforeClass + @BeforeAll public static void setUpAllocator() { setUpAllocator("ByteBuffer"); } diff --git a/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/UnsafeByteBufAdaptorTest.java b/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/UnsafeByteBufAdaptorTest.java index f7535c3..ae56013 100644 --- a/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/UnsafeByteBufAdaptorTest.java +++ b/buffer-tests/src/test/java/io/netty/buffer/api/tests/adaptor/UnsafeByteBufAdaptorTest.java @@ -15,10 +15,10 @@ */ package io.netty.buffer.api.tests.adaptor; -import org.junit.BeforeClass; +import org.junit.jupiter.api.BeforeAll; public class UnsafeByteBufAdaptorTest extends ByteBufAdaptorTest { - @BeforeClass + @BeforeAll public static void setUpAllocator() { setUpAllocator("Unsafe"); }