DefaultMockTickerTest Class — netty Architecture

Source Code

common/src/test/java/io/netty/util/concurrent/DefaultMockTickerTest.java lines 32–148

class DefaultMockTickerTest {

    @Test
    void newMockTickerShouldReturnDefaultMockTicker() {
        assertTrue(Ticker.newMockTicker() instanceof DefaultMockTicker);
    }

    @Test
    void defaultValues() {
        final MockTicker ticker = Ticker.newMockTicker();
        assertEquals(0, ticker.initialNanoTime());
        assertEquals(0, ticker.nanoTime());
    }

    @Test
    void advanceWithoutWaiters() {
        final MockTicker ticker = Ticker.newMockTicker();
        ticker.advance(42, TimeUnit.NANOSECONDS);
        assertEquals(0, ticker.initialNanoTime());
        assertEquals(42, ticker.nanoTime());

        ticker.advanceMillis(42);
        assertEquals(42_000_042, ticker.nanoTime());
    }

    @Test
    void advanceWithNegativeAmount() {
        final MockTicker ticker = Ticker.newMockTicker();
        assertThrows(IllegalArgumentException.class, () -> {
            ticker.advance(-1, TimeUnit.SECONDS);
        });

        assertThrows(IllegalArgumentException.class, () -> {
            ticker.advanceMillis(-1);
        });
    }

    @Timeout(60)
    @Test
    void advanceWithWaiters() throws Exception {
        final List<Thread> threads = new ArrayList<>();
        final DefaultMockTicker ticker = (DefaultMockTicker) Ticker.newMockTicker();
        final int numWaiters = 4;
        final List<FutureTask<Void>> futures = new ArrayList<>();
        for (int i = 0; i < numWaiters; i++) {
            FutureTask<Void> task = new FutureTask<>(() -> {
                try {
                    ticker.sleep(1, TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    throw new CompletionException(e);
                }
                return null;
            });
            Thread thread = new Thread(task);
            threads.add(thread);
            futures.add(task);
            thread.start();
        }

        try {
            // Wait for all threads to be sleeping.
            for (Thread thread : threads) {
                ticker.awaitSleepingThread(thread);
            }

            // Time did not advance at all, and thus future will not complete.
            for (int i = 0; i < numWaiters; i++) {
                final int finalCnt = i;
                assertThrows(TimeoutException.class, () -> {
                    futures.get(finalCnt).get(1, TimeUnit.MILLISECONDS);
                });
            }

            // Advance just one nanosecond before completion.
            ticker.advance(999_999, TimeUnit.NANOSECONDS);

            // All threads should still be sleeping.
            for (Thread thread : threads) {
                ticker.awaitSleepingThread(thread);
            }