testTimedOut() — netty Function Reference

Source Code

codec-native-quic/src/test/java/io/netty/handler/codec/quic/QuicChannelConnectTest.java lines 413–503

    @ParameterizedTest
    @MethodSource("newSslTaskExecutors")
    @Timeout(5)
    public void testTimedOut(Executor executor) throws Throwable {
        final AtomicBoolean dropPackets = new AtomicBoolean();
        final BlockingQueue<QuicStreamChannel> acceptedStreams = new LinkedBlockingQueue<>();
        Channel server = QuicTestUtils.newServer(
                QuicTestUtils.newQuicServerBuilder(executor).maxIdleTimeout(1, TimeUnit.MILLISECONDS),
                NoQuicTokenHandler.INSTANCE,
                new ChannelInboundHandlerAdapter() {
                    @Override
                    public boolean isSharable() {
                        return true;
                    }
                },
                new ChannelInboundHandlerAdapter() {
                    @Override
                    public boolean isSharable() {
                        return true;
                    }

                    @Override
                    public void channelActive(ChannelHandlerContext ctx) {
                        acceptedStreams.add((QuicStreamChannel) ctx.channel());
                        dropPackets.set(true);
                        ctx.fireChannelActive();
                    }

                    @Override
                    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
                        // Server closes the stream whenever the client sends a FIN.
                        if (evt instanceof ChannelInputShutdownEvent) {
                            ctx.close();
                        }
                        ctx.fireUserEventTriggered(evt);
                    }
                });

        // Have the server drop packets once we tell it to do so.
        server.pipeline().addFirst(
                new ChannelDuplexHandler() {
                    @Override
                    public void channelRead(ChannelHandlerContext ctx, Object msg) {
                        if (dropPackets.get()) {
                            ReferenceCountUtil.release(msg);
                        } else {
                            ctx.fireChannelRead(msg);
                        }
                    }

                    @Override
                    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
                        if (dropPackets.get()) {
                            ReferenceCountUtil.release(msg);
                            promise.setSuccess();
                        } else {
                            ctx.write(msg, promise);
                        }
                    }
                });

        InetSocketAddress address = (InetSocketAddress) server.localAddress();
        Channel channel = QuicTestUtils.newClient(QuicTestUtils.newQuicClientBuilder(executor));
        ChannelActiveVerifyHandler clientQuicChannelHandler = new ChannelActiveVerifyHandler();
        try {
            QuicChannel quicChannel = QuicTestUtils.newQuicChannelBootstrap(channel)
                    .handler(clientQuicChannelHandler)
                    .remoteAddress(address)
                    .connect()
                    .get();

            QuicStreamChannel quicStream = quicChannel.createStream(QuicStreamType.BIDIRECTIONAL,
                    new ChannelInboundHandlerAdapter()).get();

            ByteBuf payload = Unpooled.wrappedBuffer("HELLO!".getBytes(StandardCharsets.US_ASCII));
            quicStream.writeAndFlush(payload).sync();
            assertTrue(quicStream.closeFuture().await().isSuccess());

            QuicStreamChannel accepted = acceptedStreams.take();
            accepted.closeFuture().sync();
            assertTrue(accepted.parent().isTimedOut());