ByteBufUtilTest Class — netty Architecture

Source Code

buffer/src/test/java/io/netty/buffer/ByteBufUtilTest.java lines 46–1111

public class ByteBufUtilTest {
    private static final String PARAMETERIZED_NAME = "bufferType = {0}";
    private final AdaptiveByteBufAllocator adaptiveByteBufAllocator = new AdaptiveByteBufAllocator();

    private enum BufferType {
        DIRECT_UNPOOLED, DIRECT_POOLED, DIRECT_ADAPTIVE, HEAP_POOLED, HEAP_UNPOOLED, HEAP_ADAPTIVE
    }

    private ByteBuf buffer(BufferType bufferType, int capacity) {
        switch (bufferType) {

        case DIRECT_UNPOOLED:
            return Unpooled.directBuffer(capacity);
        case HEAP_UNPOOLED:
            return Unpooled.buffer(capacity);
        case DIRECT_POOLED:
            return PooledByteBufAllocator.DEFAULT.directBuffer(capacity);
        case HEAP_POOLED:
            return PooledByteBufAllocator.DEFAULT.buffer(capacity);
        case DIRECT_ADAPTIVE:
            return adaptiveByteBufAllocator.directBuffer(capacity);
        case HEAP_ADAPTIVE:
            return adaptiveByteBufAllocator.heapBuffer(capacity);
        default:
            throw new AssertionError("unexpected buffer type: " + bufferType);
        }
    }

    private CompositeByteBuf compositeByteBuf(BufferType bufferType) {
        switch (bufferType) {

            case DIRECT_UNPOOLED:
                return  UnpooledByteBufAllocator.DEFAULT.compositeDirectBuffer();
            case HEAP_UNPOOLED:
                return  UnpooledByteBufAllocator.DEFAULT.compositeHeapBuffer();
            case DIRECT_POOLED:
                return PooledByteBufAllocator.DEFAULT.compositeDirectBuffer();
            case HEAP_POOLED:
                return PooledByteBufAllocator.DEFAULT.compositeHeapBuffer();
            case DIRECT_ADAPTIVE:
                return adaptiveByteBufAllocator.compositeDirectBuffer();
            case HEAP_ADAPTIVE:
                return adaptiveByteBufAllocator.compositeHeapBuffer();
            default:
                throw new AssertionError("unexpected buffer type: " + bufferType);
        }
    }

    public static Collection<Object[]> noUnsafe() {
        return Arrays.asList(new Object[][] {
                { BufferType.DIRECT_POOLED },
                { BufferType.DIRECT_UNPOOLED },
                { BufferType.HEAP_POOLED },
                { BufferType.HEAP_UNPOOLED },
                { BufferType.DIRECT_ADAPTIVE },
                { BufferType.HEAP_ADAPTIVE }
        });
    }

    @Test
    public void decodeRandomHexBytesWithEvenLength() {
        decodeRandomHexBytes(256);
    }

    @Test
    public void decodeRandomHexBytesWithOddLength() {
        decodeRandomHexBytes(257);
    }

    private static void decodeRandomHexBytes(int len) {
        byte[] b = new byte[len];
        Random rand = new Random();
        rand.nextBytes(b);
        String hexDump = ByteBufUtil.hexDump(b);
        for (int i = 0; i <= len; i++) {  // going over sub-strings of various lengths including empty byte[].
            byte[] b2 = Arrays.copyOfRange(b, i, b.length);
            byte[] decodedBytes = ByteBufUtil.decodeHexDump(hexDump, i * 2, (len - i) * 2);
            assertArrayEquals(b2, decodedBytes);
        }
    }