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

Add common tests for ByteBufAllocator / AbstractByteBufAllocator implementations.

Browse Source 
Motivation:

We not had tests for ByteBufAllocator implementations in general.

Modifications:

Added ByteBufAllocatorTest, AbstractByteBufAllocatorTest and UnpooledByteBufAllocatorTest

Result:

More tests for allocator implementations.
This commit is contained in:
Norman Maurer 2017-01-26 12:15:10 +01:00
parent d576fca0dd
commit e6b9cf4675
7 changed files with 298 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
buffer/src/main/java/io/netty/buffer/AbstractByteBufAllocator.java
View File

@ -25,8 +25,10 @@ import io.netty.util.internal.StringUtil;
* Skeletal {@link ByteBufAllocator} implementation to extend.
*/
public abstract class AbstractByteBufAllocator implements ByteBufAllocator {
private static final int DEFAULT_INITIAL_CAPACITY = 256;
static final int DEFAULT_INITIAL_CAPACITY = 256;
static final int DEFAULT_MAX_CAPACITY = Integer.MAX_VALUE;
static final int DEFAULT_MAX_COMPONENTS = 16;
static final int CALCULATE_THRESHOLD = 1048576 * 4; // 4 MiB page
protected static ByteBuf toLeakAwareBuffer(ByteBuf buf) {
ResourceLeakTracker<ByteBuf> leak;
@ -141,12 +143,12 @@ public abstract class AbstractByteBufAllocator implements ByteBufAllocator {
@Override
public ByteBuf heapBuffer() {
return heapBuffer(DEFAULT_INITIAL_CAPACITY, Integer.MAX_VALUE);
return heapBuffer(DEFAULT_INITIAL_CAPACITY, DEFAULT_MAX_CAPACITY);
}
@Override
public ByteBuf heapBuffer(int initialCapacity) {
return heapBuffer(initialCapacity, Integer.MAX_VALUE);
return heapBuffer(initialCapacity, DEFAULT_MAX_CAPACITY);
}
@Override
@ -160,12 +162,12 @@ public abstract class AbstractByteBufAllocator implements ByteBufAllocator {
@Override
public ByteBuf directBuffer() {
return directBuffer(DEFAULT_INITIAL_CAPACITY, Integer.MAX_VALUE);
return directBuffer(DEFAULT_INITIAL_CAPACITY, DEFAULT_MAX_CAPACITY);
}
@Override
public ByteBuf directBuffer(int initialCapacity) {
return directBuffer(initialCapacity, Integer.MAX_VALUE);
return directBuffer(initialCapacity, DEFAULT_MAX_CAPACITY);
}
@Override

6
buffer/src/main/java/io/netty/buffer/CompositeByteBuf.java
View File

@ -53,7 +53,7 @@ public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements
private boolean freed;
public CompositeByteBuf(ByteBufAllocator alloc, boolean direct, int maxNumComponents) {
super(Integer.MAX_VALUE);
super(AbstractByteBufAllocator.DEFAULT_MAX_CAPACITY);
if (alloc == null) {
throw new NullPointerException("alloc");
}
@ -69,7 +69,7 @@ public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements
CompositeByteBuf(
ByteBufAllocator alloc, boolean direct, int maxNumComponents, ByteBuf[] buffers, int offset, int len) {
super(Integer.MAX_VALUE);
super(AbstractByteBufAllocator.DEFAULT_MAX_CAPACITY);
if (alloc == null) {
throw new NullPointerException("alloc");
}
@ -90,7 +90,7 @@ public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements
public CompositeByteBuf(
ByteBufAllocator alloc, boolean direct, int maxNumComponents, Iterable<ByteBuf> buffers) {
super(Integer.MAX_VALUE);
super(AbstractByteBufAllocator.DEFAULT_MAX_CAPACITY);
if (alloc == null) {
throw new NullPointerException("alloc");
}

2
buffer/src/main/java/io/netty/buffer/FixedCompositeByteBuf.java
View File

@ -42,7 +42,7 @@ final class FixedCompositeByteBuf extends AbstractReferenceCountedByteBuf {
private final boolean direct;
FixedCompositeByteBuf(ByteBufAllocator allocator, ByteBuf... buffers) {
super(Integer.MAX_VALUE);
super(AbstractByteBufAllocator.DEFAULT_MAX_CAPACITY);
if (buffers.length == 0) {
this.buffers = EMPTY;
order = ByteOrder.BIG_ENDIAN;

32
buffer/src/test/java/io/netty/buffer/AbstractByteBufAllocatorTest.java Normal file
View File

@ -0,0 +1,32 @@
/*
* Copyright 2017 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.buffer;
public abstract class AbstractByteBufAllocatorTest extends ByteBufAllocatorTest {
@Override
protected abstract AbstractByteBufAllocator newAllocator(boolean preferDirect);
@Override
protected final int defaultMaxCapacity() {
return AbstractByteBufAllocator.DEFAULT_MAX_CAPACITY;
}
@Override
protected final int defaultMaxComponents() {
return AbstractByteBufAllocator.DEFAULT_MAX_COMPONENTS;
}
}

225
buffer/src/test/java/io/netty/buffer/ByteBufAllocatorTest.java Normal file
View File

@ -0,0 +1,225 @@
/*
* Copyright 2017 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.buffer;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public abstract class ByteBufAllocatorTest {
protected abstract int defaultMaxCapacity();
protected abstract int defaultMaxComponents();
protected abstract ByteBufAllocator newAllocator(boolean preferDirect);
@Test
public void testBuffer() {
testBuffer(true);
testBuffer(false);
}
private void testBuffer(boolean preferDirect) {
ByteBufAllocator allocator = newAllocator(preferDirect);
ByteBuf buffer = allocator.buffer(1);
try {
assertBuffer(buffer, preferDirect, 1, defaultMaxCapacity());
} finally {
buffer.release();
}
}
@Test
public void testBufferWithCapacity() {
testBufferWithCapacity(true, 8);
testBufferWithCapacity(false, 8);
}
private void testBufferWithCapacity(boolean preferDirect, int maxCapacity) {
ByteBufAllocator allocator = newAllocator(preferDirect);
ByteBuf buffer = allocator.buffer(1, maxCapacity);
try {
assertBuffer(buffer, preferDirect, 1, maxCapacity);
} finally {
buffer.release();
}
}
@Test
public void testHeapBuffer() {
testHeapBuffer(true);
testHeapBuffer(false);
}
private void testHeapBuffer(boolean preferDirect) {
ByteBufAllocator allocator = newAllocator(preferDirect);
ByteBuf buffer = allocator.heapBuffer(1);
try {
assertBuffer(buffer, false, 1, defaultMaxCapacity());
} finally {
buffer.release();
}
}
@Test
public void testHeapBufferMaxCapacity() {
testHeapBuffer(true, 8);
testHeapBuffer(false, 8);
}
private void testHeapBuffer(boolean preferDirect, int maxCapacity) {
ByteBufAllocator allocator = newAllocator(preferDirect);
ByteBuf buffer = allocator.heapBuffer(1, maxCapacity);
try {
assertBuffer(buffer, false, 1, maxCapacity);
} finally {
buffer.release();
}
}
@Test
public void testDirectBuffer() {
testDirectBuffer(true);
testDirectBuffer(false);
}
private void testDirectBuffer(boolean preferDirect) {
ByteBufAllocator allocator = newAllocator(preferDirect);
ByteBuf buffer = allocator.directBuffer(1);
try {
assertBuffer(buffer, true, 1, defaultMaxCapacity());
} finally {
buffer.release();
}
}
@Test
public void testDirectBufferMaxCapacity() {
testDirectBuffer(true, 8);
testDirectBuffer(false, 8);
}
private void testDirectBuffer(boolean preferDirect, int maxCapacity) {
ByteBufAllocator allocator = newAllocator(preferDirect);
ByteBuf buffer = allocator.directBuffer(1, maxCapacity);
try {
assertBuffer(buffer, true, 1, maxCapacity);
} finally {
buffer.release();
}
}
@Test
public void testCompositeBuffer() {
testCompositeBuffer(true);
testCompositeBuffer(false);
}
private void testCompositeBuffer(boolean preferDirect) {
ByteBufAllocator allocator = newAllocator(preferDirect);
CompositeByteBuf buffer = allocator.compositeBuffer();
try {
assertCompositeByteBuf(buffer, defaultMaxComponents());
} finally {
buffer.release();
}
}
@Test
public void testCompositeBufferWithCapacity() {
testCompositeHeapBufferWithCapacity(true, 8);
testCompositeHeapBufferWithCapacity(false, 8);
}
@Test
public void testCompositeHeapBuffer() {
testCompositeHeapBuffer(true);
testCompositeHeapBuffer(false);
}
private void testCompositeHeapBuffer(boolean preferDirect) {
ByteBufAllocator allocator = newAllocator(preferDirect);
CompositeByteBuf buffer = allocator.compositeHeapBuffer();
try {
assertCompositeByteBuf(buffer, defaultMaxComponents());
} finally {
buffer.release();
}
}
@Test
public void testCompositeHeapBufferWithCapacity() {
testCompositeHeapBufferWithCapacity(true, 8);
testCompositeHeapBufferWithCapacity(false, 8);
}
private void testCompositeHeapBufferWithCapacity(boolean preferDirect, int maxNumComponents) {
ByteBufAllocator allocator = newAllocator(preferDirect);
CompositeByteBuf buffer = allocator.compositeHeapBuffer(maxNumComponents);
try {
assertCompositeByteBuf(buffer, maxNumComponents);
} finally {
buffer.release();
}
}
@Test
public void testCompositeDirectBuffer() {
testCompositeDirectBuffer(true);
testCompositeDirectBuffer(false);
}
private void testCompositeDirectBuffer(boolean preferDirect) {
ByteBufAllocator allocator = newAllocator(preferDirect);
CompositeByteBuf buffer = allocator.compositeDirectBuffer();
try {
assertCompositeByteBuf(buffer, defaultMaxComponents());
} finally {
buffer.release();
}
}
@Test
public void testCompositeDirectBufferWithCapacity() {
testCompositeDirectBufferWithCapacity(true, 8);
testCompositeDirectBufferWithCapacity(false, 8);
}
private void testCompositeDirectBufferWithCapacity(boolean preferDirect, int maxNumComponents) {
ByteBufAllocator allocator = newAllocator(preferDirect);
CompositeByteBuf buffer = allocator.compositeDirectBuffer(maxNumComponents);
try {
assertCompositeByteBuf(buffer, maxNumComponents);
} finally {
buffer.release();
}
}
private static void assertBuffer(
ByteBuf buffer, boolean expectedDirect, int expectedCapacity, int expectedMaxCapacity) {
assertEquals(expectedDirect, buffer.isDirect());
assertEquals(expectedCapacity, buffer.capacity());
assertEquals(expectedMaxCapacity, buffer.maxCapacity());
}
private void assertCompositeByteBuf(
CompositeByteBuf buffer, int expectedMaxNumComponents) {
assertEquals(0, buffer.numComponents());
assertEquals(expectedMaxNumComponents, buffer.maxNumComponents());
assertBuffer(buffer, false, 0, defaultMaxCapacity());
}
}

7
buffer/src/test/java/io/netty/buffer/PooledByteBufAllocatorTest.java
View File

@ -35,7 +35,12 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class PooledByteBufAllocatorTest {
public class PooledByteBufAllocatorTest extends AbstractByteBufAllocatorTest {
@Override
protected AbstractByteBufAllocator newAllocator(boolean preferDirect) {
return new PooledByteBufAllocator(preferDirect);
}
@Test
public void testArenaMetricsNoCache() {

24
buffer/src/test/java/io/netty/buffer/UnpooledByteBufAllocatorTest.java Normal file
View File

@ -0,0 +1,24 @@
/*
* Copyright 2017 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.buffer;
public class UnpooledByteBufAllocatorTest extends AbstractByteBufAllocatorTest {
@Override
protected AbstractByteBufAllocator newAllocator(boolean preferDirect) {
return new UnpooledByteBufAllocator(preferDirect);
}
}