testInvokeInEventLoop() — netty Function Reference

Source Code

transport/src/test/java/io/netty/channel/ManualIoEventLoopTest.java lines 167–221

    private static void testInvokeInEventLoop(final boolean any, final boolean timeout) {
        Semaphore semaphore = new Semaphore(0);
        ManualIoEventLoop eventLoop = new ManualIoEventLoop(Thread.currentThread(), executor ->
                new TestIoHandler(semaphore));
        try {
            assertThrows(RejectedExecutionException.class, new Executable() {
                @Override
                public void execute() throws Throwable {
                    final Promise<Void> promise = eventLoop.newPromise();
                    eventLoop.execute(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                Set<Callable<Boolean>> set = Collections.<Callable<Boolean>>singleton(
                                        new Callable<Boolean>() {
                                            @Override
                                            public Boolean call() {
                                                promise.setFailure(
                                                        new AssertionError("Should never execute the Callable"));
                                                return Boolean.TRUE;
                                            }
                                        });
                                if (any) {
                                    if (timeout) {
                                        eventLoop.invokeAny(set, 10, TimeUnit.SECONDS);
                                    } else {
                                        eventLoop.invokeAny(set);
                                    }
                                } else {
                                    if (timeout) {
                                        eventLoop.invokeAll(set, 10, TimeUnit.SECONDS);
                                    } else {
                                        eventLoop.invokeAll(set);
                                    }
                                }
                                promise.setFailure(new AssertionError("Should never reach here"));
                            } catch (Throwable cause) {
                                promise.setFailure(cause);
                            }
                        }
                    });
                    while (!promise.isDone()) {
                        eventLoop.runNow();
                    }
                    promise.syncUninterruptibly();
                }
            });
        } finally {
            eventLoop.shutdownGracefully(0, 0, TimeUnit.MILLISECONDS);
            while (!eventLoop.isTerminated()) {
                eventLoop.runNow();
            }
            assertTrue(eventLoop.terminationFuture().isSuccess());
        }
    }