testStreamLimitEnforcedWhenCreatingViaServer() — netty Function Reference

Source Code

codec-native-quic/src/test/java/io/netty/handler/codec/quic/QuicStreamLimitTest.java lines 134–193

    private static void testStreamLimitEnforcedWhenCreatingViaServer(Executor executor, QuicStreamType type)
            throws Throwable {
        Promise<Void> streamPromise = ImmediateEventExecutor.INSTANCE.newPromise();
        Promise<Throwable> stream2Promise = ImmediateEventExecutor.INSTANCE.newPromise();
        QuicChannelValidationHandler serverHandler = new QuicChannelValidationHandler() {
            @Override
            public void channelActive(ChannelHandlerContext ctx) {
                super.channelActive(ctx);
                QuicChannel channel = (QuicChannel) ctx.channel();
                channel.createStream(type, new ChannelInboundHandlerAdapter())
                        .addListener((Future<QuicStreamChannel> future) -> {
                            if (future.isSuccess()) {
                                QuicStreamChannel stream = future.getNow();
                                streamPromise.setSuccess(null);
                                channel.createStream(type, new ChannelInboundHandlerAdapter())
                                        .addListener((Future<QuicStreamChannel> f) -> {
                                            stream.close();
                                            stream2Promise.setSuccess(f.cause());
                                        });
                            } else {
                                streamPromise.setFailure(future.cause());
                            }
                        });
            }
        };
        Channel server = QuicTestUtils.newServer(
                QuicTestUtils.newQuicServerBuilder(executor),
                InsecureQuicTokenHandler.INSTANCE,
                serverHandler, new ChannelInboundHandlerAdapter() {
                    @Override
                    public boolean isSharable() {
                        return true;
                    }
                });
        InetSocketAddress address = (InetSocketAddress) server.localAddress();
        Channel channel = QuicTestUtils.newClient(QuicTestUtils.newQuicClientBuilder(executor)
                .initialMaxStreamsBidirectional(1).initialMaxStreamsUnidirectional(1));

        QuicChannelValidationHandler clientHandler = new QuicChannelValidationHandler();
        try {
            QuicChannel quicChannel = QuicTestUtils.newQuicChannelBootstrap(channel)
                    .handler(clientHandler)
                    .streamHandler(new ChannelInboundHandlerAdapter())
                    .remoteAddress(address)
                    .connect().get();
            streamPromise.sync();
            // Second stream creation should fail.
            assertInstanceOf(QuicException.class, stream2Promise.get());
            quicChannel.close().sync();

            serverHandler.assertState();
            clientHandler.assertState();
        } finally {
            server.close().sync();
            // Close the parent Datagram channel as well.
            channel.close().sync();

            shutdown(executor);
        }
    }