QuicChannelDatagramTest Class — netty Architecture

Source Code

codec-native-quic/src/test/java/io/netty/handler/codec/quic/QuicChannelDatagramTest.java lines 43–306

public class QuicChannelDatagramTest extends AbstractQuicTest {

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

    static {
        random.nextBytes(data);
    }

    @ParameterizedTest
    @MethodSource("newSslTaskExecutors")
    public void testDatagramFlushInChannelRead(Executor executor) throws Throwable {
        testDatagram(executor, false);
    }

    @ParameterizedTest
    @MethodSource("newSslTaskExecutors")
    public void testDatagramFlushInChannelReadComplete(Executor executor) throws Throwable {
        testDatagram(executor, true);
    }

    private void testDatagram(Executor executor, boolean flushInReadComplete) throws Throwable {
        AtomicReference<QuicDatagramExtensionEvent> serverEventRef = new AtomicReference<>();

        QuicChannelValidationHandler serverHandler = new QuicChannelValidationHandler() {

            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) {
                if (msg instanceof ByteBuf) {
                    final ChannelFuture future;
                    if (!flushInReadComplete) {
                        future = ctx.writeAndFlush(msg);
                    } else {
                        future = ctx.write(msg);
                    }
                    future.addListener(ChannelFutureListener.CLOSE);
                } else {
                    ctx.fireChannelRead(msg);
                }
            }

            @Override
            public void channelReadComplete(ChannelHandlerContext ctx) {
                if (flushInReadComplete) {
                    ctx.flush();
                }
            }

            @Override
            public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
                if (evt instanceof QuicDatagramExtensionEvent) {
                    serverEventRef.set((QuicDatagramExtensionEvent) evt);
                }
                super.userEventTriggered(ctx, evt);
            }
        };
        Channel server = QuicTestUtils.newServer(QuicTestUtils.newQuicServerBuilder(executor)
                        .datagram(10, 10),
                InsecureQuicTokenHandler.INSTANCE, serverHandler , new ChannelInboundHandlerAdapter());
        InetSocketAddress address = (InetSocketAddress) server.localAddress();

        Promise<ByteBuf> receivedBuffer = ImmediateEventExecutor.INSTANCE.newPromise();
        AtomicReference<QuicDatagramExtensionEvent> clientEventRef = new AtomicReference<>();
        Channel channel = QuicTestUtils.newClient(QuicTestUtils.newQuicClientBuilder(executor)
                .datagram(10, 10));

        QuicChannelValidationHandler clientHandler = new QuicChannelValidationHandler() {
            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) {
                if (!receivedBuffer.trySuccess((ByteBuf) msg)) {
                    ReferenceCountUtil.release(msg);
                }
            }

            @Override
            public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
                if (evt instanceof QuicDatagramExtensionEvent) {
                    clientEventRef.set((QuicDatagramExtensionEvent) evt);
                }
                super.userEventTriggered(ctx, evt);
            }