/*
* 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, isDirectExpected(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, isDirectExpected(preferDirect), 1, maxCapacity);
} finally {
buffer.release();
}
}
protected abstract boolean isDirectExpected(boolean preferDirect);
@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());
}
}