andreacavalli/netty5
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Correctly release all buffers in UnpooledTest

Browse Source 
Motivation:

We not correctly released all buffers in the UnpooledTest and so showed "bad" way of handling buffers to people that inspect our code to understand when a buffer needs to be released.

Modifications:

Explicit release all buffers.

Result:

Cleaner and more correct code.
This commit is contained in:
Norman Maurer 2017-04-18 19:51:24 +02:00
parent 8b13d9656a
commit b662afeece
1 changed files with 188 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

331
buffer/src/test/java/io/netty/buffer/UnpooledTest.java
View File

@ -15,20 +15,17 @@
*/ */
package io.netty.buffer; package io.netty.buffer;
import org.junit.After;
import org.junit.Test; import org.junit.Test;
import org.mockito.Mockito; import org.mockito.Mockito;
import java.io.InputStream; import java.io.InputStream;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
import java.nio.channels.ScatteringByteChannel; import java.nio.channels.ScatteringByteChannel;
import java.util.ArrayDeque;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
import java.util.Queue;
import static io.netty.buffer.Unpooled.*; import static io.netty.buffer.Unpooled.*;
import static io.netty.util.internal.EmptyArrays.*; import static io.netty.util.internal.EmptyArrays.*;
@ -42,27 +39,6 @@ public class UnpooledTest {
private static final ByteBuf[] EMPTY_BYTE_BUFS = new ByteBuf[0]; private static final ByteBuf[] EMPTY_BYTE_BUFS = new ByteBuf[0];
private static final byte[][] EMPTY_BYTES_2D = new byte[0][]; private static final byte[][] EMPTY_BYTES_2D = new byte[0][];
private static final Queue<ByteBuf> freeLaterQueue = new ArrayDeque<ByteBuf>();
protected ByteBuf freeLater(ByteBuf buf) {
freeLaterQueue.add(buf);
return buf;
}
@After
public void tearDown() {
for (;;) {
ByteBuf buf = freeLaterQueue.poll();
if (buf == null) {
break;
}
if (buf.refCnt() > 0) {
buf.release(buf.refCnt());
}
}
}
@Test @Test
public void testCompositeWrappedBuffer() { public void testCompositeWrappedBuffer() {
ByteBuf header = buffer(12); ByteBuf header = buffer(12);
@ -95,9 +71,11 @@ public class UnpooledTest {
map.put(new byte[] { -1, -1, -1, (byte) 0xE1 }, 1); map.put(new byte[] { -1, -1, -1, (byte) 0xE1 }, 1);
for (Entry<byte[], Integer> e: map.entrySet()) { for (Entry<byte[], Integer> e: map.entrySet()) {
ByteBuf buffer = wrappedBuffer(e.getKey());
assertEquals( assertEquals(
e.getValue().intValue(), e.getValue().intValue(),
ByteBufUtil.hashCode(wrappedBuffer(e.getKey()))); ByteBufUtil.hashCode(buffer));
buffer.release();
} }
} }
@ -109,46 +87,64 @@ public class UnpooledTest {
a = wrappedBuffer(new byte[] { 1 }); a = wrappedBuffer(new byte[] { 1 });
b = wrappedBuffer(new byte[] { 1, 2 }); b = wrappedBuffer(new byte[] { 1, 2 });
assertFalse(ByteBufUtil.equals(a, b)); assertFalse(ByteBufUtil.equals(a, b));
a.release();
b.release();
// Same content, same firstIndex, short length. // Same content, same firstIndex, short length.
a = wrappedBuffer(new byte[] { 1, 2, 3 }); a = wrappedBuffer(new byte[] { 1, 2, 3 });
b = wrappedBuffer(new byte[] { 1, 2, 3 }); b = wrappedBuffer(new byte[] { 1, 2, 3 });
assertTrue(ByteBufUtil.equals(a, b)); assertTrue(ByteBufUtil.equals(a, b));
a.release();
b.release();
// Same content, different firstIndex, short length. // Same content, different firstIndex, short length.
a = wrappedBuffer(new byte[] { 1, 2, 3 }); a = wrappedBuffer(new byte[] { 1, 2, 3 });
b = wrappedBuffer(new byte[] { 0, 1, 2, 3, 4 }, 1, 3); b = wrappedBuffer(new byte[] { 0, 1, 2, 3, 4 }, 1, 3);
assertTrue(ByteBufUtil.equals(a, b)); assertTrue(ByteBufUtil.equals(a, b));
a.release();
b.release();
// Different content, same firstIndex, short length. // Different content, same firstIndex, short length.
a = wrappedBuffer(new byte[] { 1, 2, 3 }); a = wrappedBuffer(new byte[] { 1, 2, 3 });
b = wrappedBuffer(new byte[] { 1, 2, 4 }); b = wrappedBuffer(new byte[] { 1, 2, 4 });
assertFalse(ByteBufUtil.equals(a, b)); assertFalse(ByteBufUtil.equals(a, b));
a.release();
b.release();
// Different content, different firstIndex, short length. // Different content, different firstIndex, short length.
a = wrappedBuffer(new byte[] { 1, 2, 3 }); a = wrappedBuffer(new byte[] { 1, 2, 3 });
b = wrappedBuffer(new byte[] { 0, 1, 2, 4, 5 }, 1, 3); b = wrappedBuffer(new byte[] { 0, 1, 2, 4, 5 }, 1, 3);
assertFalse(ByteBufUtil.equals(a, b)); assertFalse(ByteBufUtil.equals(a, b));
a.release();
b.release();
// Same content, same firstIndex, long length. // Same content, same firstIndex, long length.
a = wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); a = wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
b = wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); b = wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
assertTrue(ByteBufUtil.equals(a, b)); assertTrue(ByteBufUtil.equals(a, b));
a.release();
b.release();
// Same content, different firstIndex, long length. // Same content, different firstIndex, long length.
a = wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); a = wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
b = wrappedBuffer(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, 1, 10); b = wrappedBuffer(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, 1, 10);
assertTrue(ByteBufUtil.equals(a, b)); assertTrue(ByteBufUtil.equals(a, b));
a.release();
b.release();
// Different content, same firstIndex, long length. // Different content, same firstIndex, long length.
a = wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); a = wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
b = wrappedBuffer(new byte[] { 1, 2, 3, 4, 6, 7, 8, 5, 9, 10 }); b = wrappedBuffer(new byte[] { 1, 2, 3, 4, 6, 7, 8, 5, 9, 10 });
assertFalse(ByteBufUtil.equals(a, b)); assertFalse(ByteBufUtil.equals(a, b));
a.release();
b.release();
// Different content, different firstIndex, long length. // Different content, different firstIndex, long length.
a = wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); a = wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
b = wrappedBuffer(new byte[] { 0, 1, 2, 3, 4, 6, 7, 8, 5, 9, 10, 11 }, 1, 10); b = wrappedBuffer(new byte[] { 0, 1, 2, 3, 4, 6, 7, 8, 5, 9, 10, 11 }, 1, 10);
assertFalse(ByteBufUtil.equals(a, b)); assertFalse(ByteBufUtil.equals(a, b));
a.release();
b.release();
} }
@Test @Test
@ -182,50 +178,55 @@ public class UnpooledTest {
} }
} }
} }
for (ByteBuf buffer: expected) {
buffer.release();
}
} }
@Test @Test
public void shouldReturnEmptyBufferWhenLengthIsZero() { public void shouldReturnEmptyBufferWhenLengthIsZero() {
assertSame(EMPTY_BUFFER, wrappedBuffer(EMPTY_BYTES)); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(EMPTY_BYTES));
assertSame(EMPTY_BUFFER, wrappedBuffer(new byte[8], 0, 0)); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(new byte[8], 0, 0));
assertSame(EMPTY_BUFFER, wrappedBuffer(new byte[8], 8, 0)); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(new byte[8], 8, 0));
assertSame(EMPTY_BUFFER, wrappedBuffer(ByteBuffer.allocateDirect(0))); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(ByteBuffer.allocateDirect(0)));
assertSame(EMPTY_BUFFER, wrappedBuffer(EMPTY_BUFFER)); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(EMPTY_BUFFER));
assertSame(EMPTY_BUFFER, wrappedBuffer(EMPTY_BYTES_2D)); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(EMPTY_BYTES_2D));
assertSame(EMPTY_BUFFER, wrappedBuffer(new byte[][] { EMPTY_BYTES })); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(new byte[][] { EMPTY_BYTES }));
assertSame(EMPTY_BUFFER, wrappedBuffer(EMPTY_BYTE_BUFFERS)); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(EMPTY_BYTE_BUFFERS));
assertSame(EMPTY_BUFFER, wrappedBuffer(new ByteBuffer[] { ByteBuffer.allocate(0) })); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(new ByteBuffer[] { ByteBuffer.allocate(0) }));
assertSame(EMPTY_BUFFER, wrappedBuffer(ByteBuffer.allocate(0), ByteBuffer.allocate(0))); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(ByteBuffer.allocate(0), ByteBuffer.allocate(0)));
assertSame(EMPTY_BUFFER, wrappedBuffer(EMPTY_BYTE_BUFS)); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(EMPTY_BYTE_BUFS));
assertSame(EMPTY_BUFFER, wrappedBuffer(new ByteBuf[] { buffer(0) })); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(new ByteBuf[] { buffer(0) }));
assertSame(EMPTY_BUFFER, wrappedBuffer(buffer(0), buffer(0))); assertSameAndRelease(EMPTY_BUFFER, wrappedBuffer(buffer(0), buffer(0)));
assertSame(EMPTY_BUFFER, copiedBuffer(EMPTY_BYTES)); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(EMPTY_BYTES));
assertSame(EMPTY_BUFFER, copiedBuffer(new byte[8], 0, 0)); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(new byte[8], 0, 0));
assertSame(EMPTY_BUFFER, copiedBuffer(new byte[8], 8, 0)); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(new byte[8], 8, 0));
assertSame(EMPTY_BUFFER, copiedBuffer(ByteBuffer.allocateDirect(0))); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(ByteBuffer.allocateDirect(0)));
assertSame(EMPTY_BUFFER, copiedBuffer(EMPTY_BUFFER)); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(EMPTY_BUFFER));
assertSame(EMPTY_BUFFER, copiedBuffer(EMPTY_BYTES_2D)); assertSame(EMPTY_BUFFER, copiedBuffer(EMPTY_BYTES_2D));
assertSame(EMPTY_BUFFER, copiedBuffer(new byte[][] { EMPTY_BYTES })); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(new byte[][] { EMPTY_BYTES }));
assertSame(EMPTY_BUFFER, copiedBuffer(EMPTY_BYTE_BUFFERS)); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(EMPTY_BYTE_BUFFERS));
assertSame(EMPTY_BUFFER, copiedBuffer(new ByteBuffer[] { ByteBuffer.allocate(0) })); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(new ByteBuffer[] { ByteBuffer.allocate(0) }));
assertSame(EMPTY_BUFFER, copiedBuffer(ByteBuffer.allocate(0), ByteBuffer.allocate(0))); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(ByteBuffer.allocate(0), ByteBuffer.allocate(0)));
assertSame(EMPTY_BUFFER, copiedBuffer(EMPTY_BYTE_BUFS)); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(EMPTY_BYTE_BUFS));
assertSame(EMPTY_BUFFER, copiedBuffer(new ByteBuf[] { buffer(0) })); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(new ByteBuf[] { buffer(0) }));
assertSame(EMPTY_BUFFER, copiedBuffer(buffer(0), buffer(0))); assertSameAndRelease(EMPTY_BUFFER, copiedBuffer(buffer(0), buffer(0)));
} }
@Test @Test
public void testCompare2() { public void testCompare2() {
assertTrue(ByteBufUtil.compare( ByteBuf expected = wrappedBuffer(new byte[]{(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF});
wrappedBuffer(new byte[]{(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF}), ByteBuf actual = wrappedBuffer(new byte[]{(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00});
wrappedBuffer(new byte[]{(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00})) assertTrue(ByteBufUtil.compare(expected, actual) > 0);
> 0); expected.release();
actual.release();
assertTrue(ByteBufUtil.compare( expected = wrappedBuffer(new byte[]{(byte) 0xFF});
wrappedBuffer(new byte[]{(byte) 0xFF}), actual = wrappedBuffer(new byte[]{(byte) 0x00});
wrappedBuffer(new byte[]{(byte) 0x00})) assertTrue(ByteBufUtil.compare(expected, actual) > 0);
> 0); expected.release();
actual.release();
} }
@Test @Test
@ -243,44 +244,32 @@ public class UnpooledTest {
@Test @Test
public void testWrappedBuffer() { public void testWrappedBuffer() {
assertEquals(16, freeLater(wrappedBuffer(ByteBuffer.allocateDirect(16))).capacity()); ByteBuf buffer = wrappedBuffer(ByteBuffer.allocateDirect(16));
assertEquals(16, buffer.capacity());
buffer.release();
assertEquals( assertEqualsAndRelease(
wrappedBuffer(new byte[] { 1, 2, 3 }), wrappedBuffer(new byte[] { 1, 2, 3 }),
wrappedBuffer(new byte[][] { new byte[] { 1, 2, 3 } })); wrappedBuffer(new byte[][] { new byte[] { 1, 2, 3 } }));
assertEquals( assertEqualsAndRelease(
wrappedBuffer(new byte[] { 1, 2, 3 }), wrappedBuffer(new byte[] { 1, 2, 3 }),
freeLater(wrappedBuffer( wrappedBuffer(new byte[] { 1 }, new byte[] { 2 }, new byte[] { 3 }));
new byte[] { 1 },
new byte[] { 2 },
new byte[] { 3 })));
assertEquals( assertEqualsAndRelease(wrappedBuffer(new byte[] { 1, 2, 3 }),
wrappedBuffer(new byte[] { 1, 2, 3 }), wrappedBuffer(new ByteBuf[] { wrappedBuffer(new byte[] { 1, 2, 3 }) }));
wrappedBuffer(new ByteBuf[] {
wrappedBuffer(new byte[] { 1, 2, 3 })
}));
assertEquals( assertEqualsAndRelease(
wrappedBuffer(new byte[] { 1, 2, 3 }), wrappedBuffer(new byte[] { 1, 2, 3 }),
freeLater(wrappedBuffer( wrappedBuffer(wrappedBuffer(new byte[] { 1 }),
wrappedBuffer(new byte[] { 1 }), wrappedBuffer(new byte[] { 2 }), wrappedBuffer(new byte[] { 3 })));
wrappedBuffer(new byte[] { 2 }),
wrappedBuffer(new byte[] { 3 }))));
assertEquals( assertEqualsAndRelease(wrappedBuffer(new byte[] { 1, 2, 3 }),
wrappedBuffer(new byte[] { 1, 2, 3 }), wrappedBuffer(new ByteBuffer[] { ByteBuffer.wrap(new byte[] { 1, 2, 3 }) }));
wrappedBuffer(new ByteBuffer[] {
ByteBuffer.wrap(new byte[] { 1, 2, 3 })
}));
assertEquals( assertEqualsAndRelease(wrappedBuffer(new byte[] { 1, 2, 3 }),
wrappedBuffer(new byte[] { 1, 2, 3 }), wrappedBuffer(ByteBuffer.wrap(new byte[] { 1 }),
freeLater(wrappedBuffer( ByteBuffer.wrap(new byte[] { 2 }), ByteBuffer.wrap(new byte[] { 3 })));
ByteBuffer.wrap(new byte[] { 1 }),
ByteBuffer.wrap(new byte[] { 2 }),
ByteBuffer.wrap(new byte[] { 3 }))));
} }
@Test @Test
@ -321,60 +310,57 @@ public class UnpooledTest {
@Test @Test
public void testCopiedBuffer() { public void testCopiedBuffer() {
assertEquals(16, copiedBuffer(ByteBuffer.allocateDirect(16)).capacity()); ByteBuf copied = copiedBuffer(ByteBuffer.allocateDirect(16));
assertEquals(16, copied.capacity());
copied.release();
assertEquals( assertEqualsAndRelease(wrappedBuffer(new byte[] { 1, 2, 3 }),
wrappedBuffer(new byte[] { 1, 2, 3 }),
copiedBuffer(new byte[][] { new byte[] { 1, 2, 3 } })); copiedBuffer(new byte[][] { new byte[] { 1, 2, 3 } }));
assertEquals( assertEqualsAndRelease(wrappedBuffer(new byte[] { 1, 2, 3 }),
wrappedBuffer(new byte[] { 1, 2, 3 }), copiedBuffer(new byte[] { 1 }, new byte[] { 2 }, new byte[] { 3 }));
copiedBuffer(
new byte[] { 1 },
new byte[] { 2 },
new byte[] { 3 }));
assertEquals( assertEqualsAndRelease(wrappedBuffer(new byte[] { 1, 2, 3 }),
wrappedBuffer(new byte[] { 1, 2, 3 }), copiedBuffer(new ByteBuf[] { wrappedBuffer(new byte[] { 1, 2, 3 })}));
copiedBuffer(new ByteBuf[] {
wrappedBuffer(new byte[] { 1, 2, 3 })
}));
assertEquals( assertEqualsAndRelease(wrappedBuffer(new byte[] { 1, 2, 3 }),
wrappedBuffer(new byte[] { 1, 2, 3 }), copiedBuffer(wrappedBuffer(new byte[] { 1 }),
copiedBuffer( wrappedBuffer(new byte[] { 2 }), wrappedBuffer(new byte[] { 3 })));
wrappedBuffer(new byte[] { 1 }),
wrappedBuffer(new byte[] { 2 }),
wrappedBuffer(new byte[] { 3 })));
assertEquals( assertEqualsAndRelease(wrappedBuffer(new byte[] { 1, 2, 3 }),
wrappedBuffer(new byte[] { 1, 2, 3 }), copiedBuffer(new ByteBuffer[] { ByteBuffer.wrap(new byte[] { 1, 2, 3 }) }));
copiedBuffer(new ByteBuffer[] {
ByteBuffer.wrap(new byte[] { 1, 2, 3 })
}));
assertEquals( assertEqualsAndRelease(wrappedBuffer(new byte[] { 1, 2, 3 }),
wrappedBuffer(new byte[] { 1, 2, 3 }), copiedBuffer(ByteBuffer.wrap(new byte[] { 1 }),
copiedBuffer( ByteBuffer.wrap(new byte[] { 2 }), ByteBuffer.wrap(new byte[] { 3 })));
ByteBuffer.wrap(new byte[] { 1 }), }
ByteBuffer.wrap(new byte[] { 2 }),
ByteBuffer.wrap(new byte[] { 3 }))); private static void assertEqualsAndRelease(ByteBuf expected, ByteBuf actual) {
assertEquals(expected, actual);
expected.release();
actual.release();
}
private static void assertSameAndRelease(ByteBuf expected, ByteBuf actual) {
assertEquals(expected, actual);
expected.release();
actual.release();
} }
@Test @Test
public void testHexDump() { public void testHexDump() {
assertEquals("", ByteBufUtil.hexDump(EMPTY_BUFFER)); assertEquals("", ByteBufUtil.hexDump(EMPTY_BUFFER));
assertEquals("123456", ByteBufUtil.hexDump(wrappedBuffer( ByteBuf buffer = wrappedBuffer(new byte[]{ 0x12, 0x34, 0x56 });
new byte[]{ assertEquals("123456", ByteBufUtil.hexDump(buffer));
0x12, 0x34, 0x56 buffer.release();
})));
assertEquals("1234567890abcdef", ByteBufUtil.hexDump(wrappedBuffer( buffer = wrappedBuffer(new byte[]{
new byte[]{ 0x12, 0x34, 0x56, 0x78,
0x12, 0x34, 0x56, 0x78, (byte) 0x90, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF
(byte) 0x90, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF });
}))); assertEquals("1234567890abcdef", ByteBufUtil.hexDump(buffer));
buffer.release();
} }
@Test @Test
@ -467,6 +453,7 @@ public class UnpooledTest {
// Expected // Expected
} }
Mockito.verifyZeroInteractions(scatteringByteChannel); Mockito.verifyZeroInteractions(scatteringByteChannel);
buf.release();
} }
@Test @Test
@ -475,6 +462,7 @@ public class UnpooledTest {
assertEquals(4, buffer.capacity()); assertEquals(4, buffer.capacity());
assertEquals(42, buffer.readInt()); assertEquals(42, buffer.readInt());
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
} }
@Test @Test
@ -484,9 +472,15 @@ public class UnpooledTest {
assertEquals(1, buffer.readInt()); assertEquals(1, buffer.readInt());
assertEquals(4, buffer.readInt()); assertEquals(4, buffer.readInt());
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
assertEquals(0, copyInt(null).capacity()); buffer = copyInt(null);
assertEquals(0, copyInt(new int[] {}).capacity()); assertEquals(0, buffer.capacity());
buffer.release();
buffer = copyInt(new int[] {});
assertEquals(0, buffer.capacity());
buffer.release();
} }
@Test @Test
@ -495,6 +489,7 @@ public class UnpooledTest {
assertEquals(2, buffer.capacity()); assertEquals(2, buffer.capacity());
assertEquals(42, buffer.readShort()); assertEquals(42, buffer.readShort());
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
} }
@Test @Test
@ -504,9 +499,15 @@ public class UnpooledTest {
assertEquals(1, buffer.readShort()); assertEquals(1, buffer.readShort());
assertEquals(4, buffer.readShort()); assertEquals(4, buffer.readShort());
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
assertEquals(0, copyShort((short[]) null).capacity()); buffer = copyShort((short[]) null);
assertEquals(0, copyShort(new short[] {}).capacity()); assertEquals(0, buffer.capacity());
buffer.release();
buffer = copyShort(new short[] {});
assertEquals(0, buffer.capacity());
buffer.release();
} }
@Test @Test
@ -516,9 +517,15 @@ public class UnpooledTest {
assertEquals(1, buffer.readShort()); assertEquals(1, buffer.readShort());
assertEquals(4, buffer.readShort()); assertEquals(4, buffer.readShort());
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
assertEquals(0, copyShort((int[]) null).capacity()); buffer = copyShort((int[]) null);
assertEquals(0, copyShort(new int[] {}).capacity()); assertEquals(0, buffer.capacity());
buffer.release();
buffer = copyShort(new int[] {});
assertEquals(0, buffer.capacity());
buffer.release();
} }
@Test @Test
@ -527,6 +534,7 @@ public class UnpooledTest {
assertEquals(3, buffer.capacity()); assertEquals(3, buffer.capacity());
assertEquals(42, buffer.readMedium()); assertEquals(42, buffer.readMedium());
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
} }
@Test @Test
@ -536,9 +544,15 @@ public class UnpooledTest {
assertEquals(1, buffer.readMedium()); assertEquals(1, buffer.readMedium());
assertEquals(4, buffer.readMedium()); assertEquals(4, buffer.readMedium());
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
buffer = copyMedium(null);
assertEquals(0, copyMedium(null).capacity()); assertEquals(0, copyMedium(null).capacity());
assertEquals(0, copyMedium(new int[] {}).capacity()); buffer.release();
buffer = copyMedium(new int[] {});
assertEquals(0, buffer.capacity());
buffer.release();
} }
@Test @Test
@ -547,6 +561,7 @@ public class UnpooledTest {
assertEquals(8, buffer.capacity()); assertEquals(8, buffer.capacity());
assertEquals(42, buffer.readLong()); assertEquals(42, buffer.readLong());
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
} }
@Test @Test
@ -556,9 +571,15 @@ public class UnpooledTest {
assertEquals(1, buffer.readLong()); assertEquals(1, buffer.readLong());
assertEquals(4, buffer.readLong()); assertEquals(4, buffer.readLong());
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
assertEquals(0, copyLong(null).capacity()); buffer = copyLong(null);
assertEquals(0, copyLong(new long[] {}).capacity()); assertEquals(0, buffer.capacity());
buffer.release();
buffer = copyLong(new long[] {});
assertEquals(0, buffer.capacity());
buffer.release();
} }
@Test @Test
@ -567,6 +588,7 @@ public class UnpooledTest {
assertEquals(4, buffer.capacity()); assertEquals(4, buffer.capacity());
assertEquals(42, buffer.readFloat(), 0.01); assertEquals(42, buffer.readFloat(), 0.01);
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
} }
@Test @Test
@ -576,9 +598,15 @@ public class UnpooledTest {
assertEquals(1, buffer.readFloat(), 0.01); assertEquals(1, buffer.readFloat(), 0.01);
assertEquals(4, buffer.readFloat(), 0.01); assertEquals(4, buffer.readFloat(), 0.01);
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
assertEquals(0, copyFloat(null).capacity()); buffer = copyFloat(null);
assertEquals(0, copyFloat(new float[] {}).capacity()); assertEquals(0, buffer.capacity());
buffer.release();
buffer = copyFloat(new float[] {});
assertEquals(0, buffer.capacity());
buffer.release();
} }
@Test @Test
@ -587,6 +615,7 @@ public class UnpooledTest {
assertEquals(8, buffer.capacity()); assertEquals(8, buffer.capacity());
assertEquals(42, buffer.readDouble(), 0.01); assertEquals(42, buffer.readDouble(), 0.01);
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
} }
@Test @Test
@ -596,9 +625,15 @@ public class UnpooledTest {
assertEquals(1, buffer.readDouble(), 0.01); assertEquals(1, buffer.readDouble(), 0.01);
assertEquals(4, buffer.readDouble(), 0.01); assertEquals(4, buffer.readDouble(), 0.01);
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
assertEquals(0, copyDouble(null).capacity()); buffer = copyDouble(null);
assertEquals(0, copyDouble(new double[] {}).capacity()); assertEquals(0, buffer.capacity());
buffer.release();
buffer = copyDouble(new double[] {});
assertEquals(0, buffer.capacity());
buffer.release();
} }
@Test @Test
@ -608,9 +643,15 @@ public class UnpooledTest {
assertTrue(buffer.readBoolean()); assertTrue(buffer.readBoolean());
assertFalse(buffer.readBoolean()); assertFalse(buffer.readBoolean());
assertFalse(buffer.isReadable()); assertFalse(buffer.isReadable());
buffer.release();
assertEquals(0, copyBoolean(null).capacity()); buffer = copyBoolean(null);
assertEquals(0, copyBoolean(new boolean[] {}).capacity()); assertEquals(0, buffer.capacity());
buffer.release();
buffer = copyBoolean(new boolean[] {});
assertEquals(0, buffer.capacity());
buffer.release();
} }
@Test @Test
@ -629,8 +670,12 @@ public class UnpooledTest {
@Test(expected = IllegalArgumentException.class) @Test(expected = IllegalArgumentException.class)
public void skipBytesNegativeLength() { public void skipBytesNegativeLength() {
ByteBuf buf = freeLater(buffer(8)); ByteBuf buf = buffer(8);
buf.skipBytes(-1); try {
buf.skipBytes(-1);
} finally {
buf.release();
}
} }
// See https://github.com/netty/netty/issues/5597 // See https://github.com/netty/netty/issues/5597