QuicStreamHalfClosureTest Class — netty Architecture

Source Code

codec-native-quic/src/test/java/io/netty/handler/codec/quic/QuicStreamHalfClosureTest.java lines 36–156

public class QuicStreamHalfClosureTest extends AbstractQuicTest {

    @ParameterizedTest
    @MethodSource("newSslTaskExecutors")
    public void testCloseHalfClosureUnidirectional(Executor executor) throws Throwable {
        testCloseHalfClosure(executor, QuicStreamType.UNIDIRECTIONAL);
    }

    @ParameterizedTest
    @MethodSource("newSslTaskExecutors")
    public void testCloseHalfClosureBidirectional(Executor executor) throws Throwable {
        testCloseHalfClosure(executor, QuicStreamType.BIDIRECTIONAL);
    }

    private static void testCloseHalfClosure(Executor executor, QuicStreamType type) throws Throwable {
        Channel server = null;
        Channel channel = null;
        QuicChannelValidationHandler serverHandler = new QuicChannelValidationHandler();
        QuicChannelValidationHandler clientHandler = new StreamCreationHandler(type);
        try {
            StreamHandler handler = new StreamHandler();
            server = QuicTestUtils.newServer(executor, serverHandler, handler);
            channel = QuicTestUtils.newClient(executor);
            QuicChannel quicChannel = QuicTestUtils.newQuicChannelBootstrap(channel)
                    .handler(clientHandler)
                    .streamHandler(new ChannelInboundHandlerAdapter())
                    .remoteAddress(server.localAddress())
                    .connect()
                    .get();

            handler.assertSequence();
            quicChannel.closeFuture().sync();

            serverHandler.assertState();
            clientHandler.assertState();
        } finally {
            QuicTestUtils.closeIfNotNull(channel);
            QuicTestUtils.closeIfNotNull(server);

            shutdown(executor);
        }
    }

    private static final class StreamCreationHandler extends QuicChannelValidationHandler {
        private final QuicStreamType type;

        StreamCreationHandler(QuicStreamType type) {
            this.type = type;
        }

        @Override
        public void channelActive(ChannelHandlerContext ctx) {
            super.channelActive(ctx);
            QuicChannel channel = (QuicChannel) ctx.channel();
            channel.createStream(type, new ChannelInboundHandlerAdapter() {
                @Override
                public void channelActive(ChannelHandlerContext ctx)  {
                    // Do the write and close the channel
                    ctx.writeAndFlush(Unpooled.buffer().writeZero(8))
                            .addListener(ChannelFutureListener.CLOSE);
                }
            });
        }
    }

    private static final class StreamHandler extends ChannelInboundHandlerAdapter {
        private final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

        @Override
        public void channelRegistered(ChannelHandlerContext ctx) {
            queue.add(0);
        }

        @Override
        public void channelInactive(ChannelHandlerContext ctx) {
            queue.add(5);
            // Close the QUIC channel as well.
            ctx.channel().parent().close();
        }

        @Override