AbstractEncoderTest Class — netty Architecture

Source Code

codec-compression/src/test/java/io/netty/handler/codec/compression/AbstractEncoderTest.java lines 30–129

public abstract class AbstractEncoderTest extends AbstractCompressionTest {

    protected EmbeddedChannel channel;

    /**
     * Decompresses data with some external library.
     */
    protected abstract ByteBuf decompress(ByteBuf compressed, int originalLength) throws Exception;

    @BeforeEach
    public final void initChannel() {
        channel = createChannel();
    }

    protected abstract EmbeddedChannel createChannel();

    @AfterEach
    public void destroyChannel() {
        if (channel != null) {
            channel.finishAndReleaseAll();
            channel = null;
        }
    }

    public static ByteBuf[] smallData() {
        ByteBuf heap = Unpooled.wrappedBuffer(BYTES_SMALL);
        ByteBuf direct = Unpooled.directBuffer(BYTES_SMALL.length);
        direct.writeBytes(BYTES_SMALL);
        return new ByteBuf[] {heap, direct};
    }

    public static ByteBuf[] largeData() {
        ByteBuf heap = Unpooled.wrappedBuffer(BYTES_LARGE);
        ByteBuf direct = Unpooled.directBuffer(BYTES_LARGE.length);
        direct.writeBytes(BYTES_LARGE);
        return new ByteBuf[] {heap, direct};
    }

    @ParameterizedTest
    @MethodSource("smallData")
    public void testCompressionOfSmallChunkOfData(ByteBuf data) throws Exception {
        testCompression(data);
    }

    @ParameterizedTest
    @MethodSource("largeData")
    public void testCompressionOfLargeChunkOfData(ByteBuf data) throws Exception {
        testCompression(data);
    }

    @ParameterizedTest
    @MethodSource("largeData")
    public void testCompressionOfBatchedFlowOfData(ByteBuf data) throws Exception {
        testCompressionOfBatchedFlow(data);
    }

    protected void testCompression(final ByteBuf data) throws Exception {
        final int dataLength = data.readableBytes();
        assertTrue(channel.writeOutbound(data.retain()));
        assertTrue(channel.finish());
        assertEquals(0, data.readableBytes());

        ByteBuf decompressed = readDecompressed(dataLength);
        assertEquals(data.resetReaderIndex(), decompressed);

        decompressed.release();
        data.release();
    }

    protected void testCompressionOfBatchedFlow(final ByteBuf data) throws Exception {
        final int dataLength = data.readableBytes();
        int written = 0, length = rand.nextInt(100);
        while (written + length < dataLength) {
            ByteBuf in = data.retainedSlice(written, length);
            assertTrue(channel.writeOutbound(in));
            assertEquals(0, in.readableBytes());
            written += length;
            length = rand.nextInt(100);
        }
        ByteBuf in = data.retainedSlice(written, dataLength - written);
        assertTrue(channel.writeOutbound(in));