SingleThreadIoEventLoopTest Class — netty Architecture

Source Code

transport/src/test/java/io/netty/channel/SingleThreadIoEventLoopTest.java lines 30–186

public class SingleThreadIoEventLoopTest {

    @Test
    void testIsIoType() {
        class TestIoHandler2 extends TestIoHandler {
            TestIoHandler2(ThreadAwareExecutor executor) {
                super(executor);
            }
        }

        IoEventLoopGroup group = new SingleThreadIoEventLoop(null,
                Executors.defaultThreadFactory(), TestIoHandler::new);
        assertTrue(group.isIoType(TestIoHandler.class));
        assertFalse(group.isIoType(TestIoHandler2.class));
        group.shutdownGracefully();
    }

    static final class CompatibleTestIoHandler extends TestIoHandler {
        CompatibleTestIoHandler(ThreadAwareExecutor executor) {
            super(executor);
        }

        @Override
        public boolean isCompatible(Class<? extends IoHandle> handleType) {
            return handleType.equals(TestIoHandle.class);
        }
    }

    @Test
    void testIsCompatible() {

        IoHandle handle = new TestIoHandle() { };
        IoEventLoopGroup group = new SingleThreadIoEventLoop(null,
                Executors.defaultThreadFactory(), CompatibleTestIoHandler::new);
        assertTrue(group.isCompatible(TestIoHandle.class));
        assertFalse(group.isCompatible(handle.getClass()));
        group.shutdownGracefully();
    }

    private static final class TestThreadFactory implements ThreadFactory {
        final LinkedBlockingQueue<Thread> threads = new LinkedBlockingQueue<>();
        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            threads.add(thread);
            return thread;
        }
    }

    @Disabled("This test is flaky and will often stall the build")
    @Test
    void testSuspendingWhileRegistrationActive() throws Exception {
        TestThreadFactory threadFactory = new TestThreadFactory();
        IoEventLoop loop = new SingleThreadIoEventLoop(null, threadFactory,
                eventLoop -> new TestIoHandler(eventLoop) {
            @Override
            public boolean isCompatible(Class<? extends IoHandle> handleType) {
                return true;
            }
        });
        assertFalse(loop.isSuspended());
        IoRegistration registration = loop.register(new TestIoHandle()).sync().getNow();
        Thread currentThread = threadFactory.threads.take();
        assertTrue(currentThread.isAlive());
        assertTrue(loop.trySuspend());

        // Still should be alive as until the registration is cancelled we can not suspend the loop.
        assertTrue(currentThread.isAlive());

        registration.cancel();
        assertFalse(registration.isValid());

        // The current thread should be able to die now.
        currentThread.join();

        assertTrue(threadFactory.threads.isEmpty());
        loop.shutdownGracefully();
    }

    private static class TestIoHandler implements IoHandler {
        private final Semaphore semaphore = new Semaphore(0);