QuicChannelEchoTest Class — netty Architecture

Source Code

codec-native-quic/src/test/java/io/netty/handler/codec/quic/QuicChannelEchoTest.java lines 49–440

public class QuicChannelEchoTest extends AbstractQuicTest {

    private static final Random random = new Random();
    static final byte[] data = new byte[1048576];

    static {
        random.nextBytes(data);
    }

    public static Collection<Object[]> data() {
        List<Object[]> config = new ArrayList<>();
        for (int a = 0; a < 2; a++) {
            for (int b = 0; b < 2; b++) {
                for (int c = 0; c < 2; c++) {
                    config.add(new Object[] { a == 0, b == 0, c == 0 });
                }
            }
        }
        return config;
    }

    private void setAllocator(Channel channel, ByteBufAllocator allocator) {
        channel.config().setAllocator(allocator);
    }

    private ByteBufAllocator getAllocator(boolean directBuffer) {
        if (directBuffer) {
            return new UnpooledByteBufAllocator(true);
        } else {
            // Force usage of heap buffers and also ensure memoryAddress() is not not supported.
            return new AbstractByteBufAllocator(false) {

                @Override
                public ByteBuf ioBuffer() {
                    return heapBuffer();
                }

                @Override
                public ByteBuf ioBuffer(int initialCapacity) {
                    return heapBuffer(initialCapacity);
                }

                @Override
                public ByteBuf ioBuffer(int initialCapacity, int maxCapacity) {
                    return heapBuffer(initialCapacity, maxCapacity);
                }

                @Override
                protected ByteBuf newHeapBuffer(int initialCapacity, int maxCapacity) {
                    return new UnpooledHeapByteBuf(this, initialCapacity, maxCapacity);
                }

                @Override
                protected ByteBuf newDirectBuffer(int initialCapacity, int maxCapacity) {
                    return new UnpooledDirectByteBuf(this, initialCapacity, maxCapacity);
                }

                @Override
                public boolean isDirectBufferPooled() {
                    return false;
                }
            };
        }
    }

    @ParameterizedTest(name =
            "{index}: autoRead = {0}, directBuffer = {1}, composite = {2}")
    @MethodSource("data")
    public void testEchoStartedFromServer(boolean autoRead, boolean directBuffer, boolean composite) throws Throwable {
        ByteBufAllocator allocator = getAllocator(directBuffer);
        final EchoHandler sh = new EchoHandler(true, autoRead, allocator);
        final EchoHandler ch = new EchoHandler(false, autoRead, allocator);
        AtomicReference<List<ChannelFuture>> writeFutures = new AtomicReference<>();
        Channel server = QuicTestUtils.newServer(ImmediateExecutor.INSTANCE, new ChannelInboundHandlerAdapter() {
            @Override
            public void channelActive(ChannelHandlerContext ctx) {
                setAllocator(ctx.channel(), allocator);
                ((QuicChannel) ctx.channel()).createStream(QuicStreamType.BIDIRECTIONAL, sh)
                        .addListener((Future<QuicStreamChannel> future) -> {
                            QuicStreamChannel stream = future.getNow();
                            setAllocator(stream, allocator);