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);
}
 

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

    int[] testWindow = new int[1];
    int[] lastValue = new int[1];

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

    try {
        Timeouts.getWithTimeout(2, TimeUnit.SECONDS, ()-> {
            //noinspection InfiniteLoopStatement
            while (true) {
                lastValue[0] = rateLimiter.getWhenReady(() -> {
                    return ++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);

    assertEquals("The rate limiter returns a result", testWindow[0], lastValue[0]);
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
/**
 * Create a sidekick container and attach it to another container. The VNC output of that container will be recorded.
 */
public VncRecordingContainer(@NonNull Network network, @NonNull String targetNetworkAlias) throws IllegalStateException {
    super(TestcontainersConfiguration.getInstance().getVncRecordedContainerImage());

    this.targetNetworkAlias = targetNetworkAlias;
    withNetwork(network);

    waitingFor(new AbstractWaitStrategy() {

        @Override
        protected void waitUntilReady() {
            try {
                Unreliables.retryUntilTrue((int) startupTimeout.toMillis(), TimeUnit.MILLISECONDS, () -> {
                    CountDownLatch latch = new CountDownLatch(1);

                    FrameConsumerResultCallback callback = new FrameConsumerResultCallback() {
                        @Override
                        public void onNext(Frame frame) {
                            if (frame != null && new String(frame.getPayload()).contains("Connected")) {
                                latch.countDown();
                            }
                        }
                    };

                    try (
                            Closeable __ = dockerClient.logContainerCmd(containerId)
                                    .withFollowStream(true)
                                    .withSince(0)
                                    .withStdErr(true)
                                    .exec(callback)
                    ) {
                        return latch.await(1, TimeUnit.SECONDS);
                    }
                });
            } catch (TimeoutException e) {
                throw new ContainerLaunchException("Timed out waiting for log output", e);
            }
        }
    });
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
@Override
protected void waitUntilReady() {
    final Set<Integer> externalLivenessCheckPorts = getLivenessCheckPorts();
    if (externalLivenessCheckPorts.isEmpty()) {
        log.debug("Liveness check ports of {} is empty. Not waiting.", container.getContainerName());
        return;
    }

    @SuppressWarnings("unchecked")
    List<Integer> exposedPorts = container.getExposedPorts();

    final Set<Integer> internalPorts = getInternalPorts(externalLivenessCheckPorts, exposedPorts);

    Callable<Boolean> internalCheck = new InternalCommandPortListeningCheck(container, internalPorts);

    Callable<Boolean> externalCheck = new ExternalPortListeningCheck(container, externalLivenessCheckPorts);

    try {
        Unreliables.retryUntilTrue((int) startupTimeout.getSeconds(), TimeUnit.SECONDS, () -> {
            return getRateLimiter().getWhenReady(() -> internalCheck.call() && externalCheck.call());
        });

    } catch (TimeoutException e) {
        throw new ContainerLaunchException("Timed out waiting for container port to open (" +
                container.getContainerIpAddress() +
                " ports: " +
                externalLivenessCheckPorts +
                " should be listening)");
    }
}
 

import org.rnorth.ducttape.TimeoutException; //导入依赖的package包/类
protected void ping(DockerClient client, int timeoutInSeconds) {
    try {
        Unreliables.retryUntilSuccess(timeoutInSeconds, TimeUnit.SECONDS, () -> {
            return PING_RATE_LIMITER.getWhenReady(() -> {
                LOGGER.debug("Pinging docker daemon...");
                client.pingCmd().exec();
                return true;
            });
        });
    } catch (TimeoutException e) {
        IOUtils.closeQuietly(client);
        throw e;
    }
}