QuicWritableTest Class — netty Architecture

Source Code

codec-native-quic/src/test/java/io/netty/handler/codec/quic/QuicWritableTest.java lines 41–301

public class QuicWritableTest extends AbstractQuicTest {

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

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

    private static void testCorrectlyHandleWritability(Executor executor, boolean readInComplete) throws Throwable  {
        int bufferSize = 64 * 1024;
        Promise<Void> writePromise = ImmediateEventExecutor.INSTANCE.newPromise();
        final AtomicReference<Throwable> serverErrorRef = new AtomicReference<>();
        final AtomicReference<Throwable> clientErrorRef = new AtomicReference<>();
        QuicChannelValidationHandler serverHandler = new QuicChannelValidationHandler();
        Channel server = QuicTestUtils.newServer(
                QuicTestUtils.newQuicServerBuilder(executor).initialMaxStreamsBidirectional(5000),
                InsecureQuicTokenHandler.INSTANCE,
                serverHandler, new ChannelInboundHandlerAdapter() {

                    @Override
                    public void channelRead(ChannelHandlerContext ctx, Object msg) {
                        ByteBuf buffer = (ByteBuf) msg;
                        buffer.release();
                        ctx.writeAndFlush(ctx.alloc().buffer(bufferSize).writeZero(bufferSize))
                                .addListener(new PromiseNotifier<>(writePromise));
                    }

                    @Override
                    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
                        serverErrorRef.set(cause);
                    }

                    @Override
                    public boolean isSharable() {
                        return true;
                    }
                });
        InetSocketAddress address = (InetSocketAddress) server.localAddress();
        Channel channel = QuicTestUtils.newClient(QuicTestUtils.newQuicClientBuilder(executor)
                .initialMaxStreamDataBidirectionalLocal(bufferSize / 4));

        QuicChannelValidationHandler clientHandler = new QuicChannelValidationHandler();
        try {
            QuicChannel quicChannel = QuicTestUtils.newQuicChannelBootstrap(channel)
                    .handler(clientHandler)
                    .streamHandler(new ChannelInboundHandlerAdapter())
                    .remoteAddress(address)
                    .connect()
                    .get();
            QuicStreamChannel stream = quicChannel.createStream(
                    QuicStreamType.BIDIRECTIONAL, new ChannelInboundHandlerAdapter() {
                        int bytes;

                        @Override
                        public void channelRegistered(ChannelHandlerContext ctx) {
                            ctx.channel().config().setAutoRead(false);
                        }

                        @Override
                        public void channelActive(ChannelHandlerContext ctx) {
                            ctx.writeAndFlush(ctx.alloc().buffer(8).writeLong(8));
                        }

                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) {
                            if (bytes == 0) {
                                // First read
                                assertFalse(writePromise.isDone());
                            }
                            ByteBuf buffer = (ByteBuf) msg;
                            bytes += buffer.readableBytes();
                            buffer.release();
                            if (bytes == bufferSize) {
                                ctx.close();
                                assertTrue(writePromise.isDone());