ManualIoEventLoopTest Class — netty Architecture

Source Code

transport/src/test/java/io/netty/channel/ManualIoEventLoopTest.java lines 47–443

public class ManualIoEventLoopTest {

    @Test
    public void testRunNow() throws Exception {
        Thread currentThread = Thread.currentThread();
        Semaphore semaphore = new Semaphore(0);
        ManualIoEventLoop eventLoop = new ManualIoEventLoop(currentThread, executor ->
                new TestIoHandler(semaphore));
        assertEquals(0, eventLoop.runNow());

        TestRunnable runnable = new TestRunnable();
        eventLoop.execute(runnable);
        assertFalse(runnable.isDone());

        assertEquals(1, eventLoop.runNow());
        assertTrue(runnable.isDone());
        eventLoop.shutdown();
        while (!eventLoop.isTerminated()) {
            eventLoop.runNow();
        }

        eventLoop.terminationFuture().sync();
    }

    @Test
    public void testRun() throws Exception {
        Thread currentThread = Thread.currentThread();
        Semaphore semaphore = new Semaphore(0);
        ManualIoEventLoop eventLoop = new ManualIoEventLoop(currentThread, executor ->
                new TestIoHandler(semaphore));

        long waitTime = TimeUnit.MILLISECONDS.toNanos(200);
        long current = System.nanoTime();
        assertEquals(0, eventLoop.run(waitTime));
        long actualNanos = System.nanoTime() - current;
        assertThat(actualNanos).isGreaterThanOrEqualTo(waitTime);

        TestRunnable runnable = new TestRunnable();
        eventLoop.execute(runnable);
        assertFalse(runnable.isDone());

        waitTime = TimeUnit.SECONDS.toNanos(1);
        current = System.nanoTime();
        assertEquals(1, eventLoop.run(waitTime));
        assertThat(waitTime).isGreaterThan(System.nanoTime() - current);

        assertTrue(runnable.isDone());
        eventLoop.shutdown();

        while (!eventLoop.isTerminated()) {
            eventLoop.runNow();
        }
        eventLoop.terminationFuture().sync();
    }

    @Test
    public void testShutdownOutSideOfOwningThread() throws Exception {
        Semaphore semaphore = new Semaphore(0);
        Thread ownerThread = new Thread();
        ManualIoEventLoop eventLoop = new ManualIoEventLoop(ownerThread, executor ->
                new TestIoHandler(semaphore));
        eventLoop.shutdown();
        assertTrue(eventLoop.isShuttingDown());
        // we expect wakeup to be called!
        assertEquals(1, semaphore.availablePermits());
    }

    @Test
    public void testCallFromWrongThread() throws Exception {
        Thread thread = new Thread();
        Semaphore semaphore = new Semaphore(0);
        ManualIoEventLoop eventLoop = new ManualIoEventLoop(thread, executor ->
                new TestIoHandler(semaphore));

        assertThrows(IllegalStateException.class, eventLoop::runNow);
        assertThrows(IllegalStateException.class, () -> eventLoop.run(10));
    }

    @Test
    public void testThreadEventExecutorMap() throws Exception {
        final BlockingQueue<EventExecutor> queue = new LinkedBlockingQueue<>();