Java TimeoutException类代码示例

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void appliesOuterTimeout() {

    final WaitStrategy underTest = new WaitAllStrategy()
            .withStrategy(strategy1)
            .withStartupTimeout(Duration.ofMillis(10));

    doAnswer(invocation -> {
        Uninterruptibles.sleepUninterruptibly(20, TimeUnit.MILLISECONDS);
        return null;
    }).when(strategy1).waitUntilReady(eq(container));

    assertThrows("The outer strategy timeout applies", TimeoutException.class, () -> {
        underTest.waitUntilReady(container);
    });
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testNeverConsistent() {
    try {
        Inconsistents.retryUntilConsistent(50, 1000, TimeUnit.MILLISECONDS, () -> {
            Thread.sleep(10L);
            return System.currentTimeMillis();
        });
    } catch (TimeoutException e) {
        Throwable cause = e.getCause();
        assertEquals("An exception is thrown if the result is never consistent", ResultsNeverConsistentException.class, cause.getClass());
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testNotConsistentLongEnough() {
    try {
        Inconsistents.retryUntilConsistent(50, 1000, TimeUnit.MILLISECONDS, () -> {
            Thread.sleep(10L);
            return System.currentTimeMillis() / 49;
        });
    } catch (TimeoutException e) {
        Throwable cause = e.getCause();
        assertEquals("An exception is thrown if the result is never consistent", InconsistentResultsException.class, cause.getClass());
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testRetryUntilTrueImmediateSuccess() throws Exception {
    try {
        Unreliables.retryUntilTrue(500, TimeUnit.MILLISECONDS, () -> true);
    } catch (TimeoutException e) {
        fail("When retrying until true, an immediate return true should be OK but timed out");
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testRetryUntilTrueSuccessWithinTimeoutWindow() throws Exception {
    try {
        Unreliables.retryUntilTrue(500, TimeUnit.MILLISECONDS, () -> {
            Thread.sleep(300L);
            return true;
        });
    } catch (TimeoutException e) {
        fail("When retrying until true, a return true within the timeout window should be OK but timed out");
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testRetryUntilTrueSuccessWithinTimeoutWindowWithManyFailures() throws Exception {
    long start = System.currentTimeMillis();
    try {
        Unreliables.retryUntilTrue(500, TimeUnit.MILLISECONDS, () -> {
            return System.currentTimeMillis() - start > 300;
        });
    } catch (TimeoutException e) {
        fail("When retrying until true, a return true within the timeout window should be OK but timed out");
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testRetryUntilTrueFailsWhenOutsideTimeoutWindow() throws Exception {
    try {
        Unreliables.retryUntilTrue(500, TimeUnit.MILLISECONDS, () -> {
            Thread.sleep(600L);
            return true;
        });
        fail("When retrying until true, a return true outside the timeout window should throw a timeout exception");
    } catch (TimeoutException e) {
        // ok
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testRetryUntilSuccessImmediateSuccess() throws Exception {
    try {
        String result = Unreliables.retryUntilSuccess(500, TimeUnit.MILLISECONDS, () -> "OK");
        assertEquals("A result can be returned using retryUntilSuccess", "OK", result);
    } catch (TimeoutException e) {
        fail("When retrying until true, an immediate return true should be OK but timed out");
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testRetryUntilSuccessWithinTimeoutWindow() throws Exception {
    try {
        String result = Unreliables.retryUntilSuccess(500, TimeUnit.MILLISECONDS, () -> {
            Thread.sleep(300L);
            return "OK";
        });
        assertEquals("A result can be returned using retryUntilSuccess", "OK", result);
    } catch (TimeoutException e) {
        fail("When retrying until true, a return true within the timeout window should be OK but timed out");
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testRetryUntilSuccessWithinTimeoutWindowWithManyFailures() throws Exception {
    long start = System.currentTimeMillis();
    try {
        String result = Unreliables.retryUntilSuccess(500, TimeUnit.MILLISECONDS, () -> {
            if (System.currentTimeMillis() - start < 300) {
                throw new Exception("FAILURE");
            }
            return "OK";
        });
        assertEquals("A result can be returned using retryUntilSuccess", "OK", result);
    } catch (TimeoutException e) {
        fail("When retrying until true, a return true within the timeout window should be OK but timed out");
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testRetryUntilSuccessFailsWhenOutsideTimeoutWindow() throws Exception {
    String result = "NOT OK";
    try {
        result = Unreliables.retryUntilSuccess(500, TimeUnit.MILLISECONDS, () -> {
            Thread.sleep(600L);
            return "OK";
        });
        fail("When retrying until true, a return true outside the timeout window should throw a timeout exception");
    } catch (TimeoutException e) {
        // ok
        assertEquals("A result can be returned using retryUntilSuccess", "NOT OK", result);
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testRetryUntilSuccessFailsWhenOutsideTimeoutWindowAndCapturesException() throws Exception {
    try {
        Unreliables.retryUntilSuccess(500, TimeUnit.MILLISECONDS, () -> {
            throw new IllegalStateException("This is the exception");
        });
        fail("When retrying until true, a return true outside the timeout window should throw a timeout exception");
    } catch (TimeoutException e) {
        // ok
        assertEquals("A result can be returned using retryUntilSuccess", "This is the exception", e.getCause().getMessage());
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void timeoutThrowsException() {
    assertThrows("It throws a TimeoutException if execution time is exceeded", TimeoutException.class, () -> {
        Timeouts.doWithTimeout(1, TimeUnit.SECONDS, () -> {
            try {
                Thread.sleep(2000L);
            } catch (InterruptedException ignored) { }
        });
    });
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void timeoutThrowsExceptionWithoutReturnValue() {
    assertThrows("It throws a TimeoutException if execution time is exceeded", TimeoutException.class, () -> {
        Timeouts.getWithTimeout(1, TimeUnit.SECONDS, () -> {
            try {
                Thread.sleep(2000L);
            } catch (InterruptedException ignored) { }
            return "result";
        });
    });
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Test
public void testLimitExecutions() {

    int[] testWindow = new int[1];

    RateLimiter rateLimiter = RateLimiterBuilder.newBuilder()
                                         .withRate(10, TimeUnit.SECONDS)
                                         .withConstantThroughput()
                                         .build();

    try {
        Timeouts.getWithTimeout(2, TimeUnit.SECONDS, ()-> {
            //noinspection InfiniteLoopStatement
            while (true) {
                rateLimiter.doWhenReady(() -> {
                    testWindow[0]++;
                });
            }
        });
    } catch (TimeoutException ignored) {
        // We're just using a timeout here to limit execution to a given time
    }

    // Approximate estimates
    assertTrue("The rate limiter should have kept executions at or below 21", testWindow[0] <= 21);
    assertTrue("The rate limiter should allowed at least 15 executions", testWindow[0] >= 15);
}