testReentranceNotCausesNPE() — netty Function Reference

Architecture documentation for the testReentranceNotCausesNPE() function in FlowControlHandlerTest.java from the netty codebase.

Function java Buffer Allocators

Entity Profile

Buffer→ Allocators→ testReentranceNotCausesNPE() — netty Function Reference

Dependency Diagram

graph TD
  451899c7_937e_56fa_b144_0fec1941aaae["testReentranceNotCausesNPE()"]
  403e241f_d76e_484e_d952_7f7a46681916["FlowControlHandlerTest"]
  451899c7_937e_56fa_b144_0fec1941aaae -->|defined in| 403e241f_d76e_484e_d952_7f7a46681916
  style 451899c7_937e_56fa_b144_0fec1941aaae fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

handler/src/test/java/io/netty/handler/flow/FlowControlHandlerTest.java lines 484–538

    @Test
    public void testReentranceNotCausesNPE() throws Throwable {
        final Exchanger<Channel> peerRef = new Exchanger<Channel>();
        final CountDownLatch latch = new CountDownLatch(3);
        final AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
        ChannelInboundHandlerAdapter handler = new ChannelDuplexHandler() {
            @Override
            public void channelActive(ChannelHandlerContext ctx) throws Exception {
                ctx.fireChannelActive();
                peerRef.exchange(ctx.channel(), 1L, SECONDS);
            }

            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) {
                latch.countDown();
                ctx.read();
            }

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

        final FlowControlHandler flow = new FlowControlHandler();
        Channel server = newServer(false, flow, handler);
        Channel client = newClient(server.localAddress());
        try {
            // The client connection on the server side
            Channel peer = peerRef.exchange(null, 1L, SECONDS);

            // Write the message
            client.writeAndFlush(newOneMessage())
                    .syncUninterruptibly();

            // channelRead(1)
            peer.read();
            assertTrue(latch.await(1L, SECONDS));

            assertTrue(peer.eventLoop().submit(new Callable<Boolean>() {
                @Override
                public Boolean call() {
                    return flow.isQueueEmpty();
                }
            }).get());

            Throwable cause = causeRef.get();
            if (cause != null) {
                throw cause;
            }
        } finally {
            client.close();
            server.close();
        }
    }