import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
private boolean awaitExpiration(Region r, Object key) {
  // Return true if entry expires. We only wait
  // TEST_WAIT_MS. If we need to wait that long for
  // a SHORT_WAIT_MS to expire then the expiration
  // is probably still set at LONG_WAIT_MS.
  try {
    with().pollInterval(POLL_INTERVAL_MS, TimeUnit.MILLISECONDS).await()
        .atMost(TEST_WAIT_MS, TimeUnit.MILLISECONDS).until(() -> !r.containsValueForKey(key));
  } catch (ConditionTimeoutException toe) {
    return false;
  }
  return true;
}
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
public void waitUntilReady(Cluster cluster) {
    final AtomicReference<Optional<SuccessOrFailure>> lastSuccessOrFailure = new AtomicReference<>(
            Optional.empty());

    log.info("Waiting for cluster to be healthy");
    try {
        Awaitility.await()
                .pollInterval(50, TimeUnit.MILLISECONDS)
                .atMost(timeout.getMillis(), TimeUnit.MILLISECONDS)
                .until(weHaveSuccess(cluster, lastSuccessOrFailure));
    } catch (ConditionTimeoutException e) {
        throw new IllegalStateException(serviceDidNotStartupExceptionMessage(lastSuccessOrFailure));
    }
}
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public boolean matches(Object item) {
    MockAuthenticationCallback<T> callback = (MockAuthenticationCallback<T>) item;
    try {
        await().until(callback.payload(), payloadMatcher);
        await().until(callback.error(), errorMatcher);
        return true;
    } catch (ConditionTimeoutException e) {
        return false;
    }
}
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public boolean matches(Object item) {
    MockBaseCallback<T, U> callback = (MockBaseCallback<T, U>) item;
    try {
        await().until(callback.payload(), payloadMatcher);
        await().until(callback.error(), errorMatcher);
        return true;
    } catch (ConditionTimeoutException e) {
        return false;
    }
}
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public boolean matches(Object item) {
    MockManagementCallback<T> callback = (MockManagementCallback<T>) item;
    try {
        await().until(callback.payload(), payloadMatcher);
        await().until(callback.error(), errorMatcher);
        return true;
    } catch (ConditionTimeoutException e) {
        return false;
    }
}
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
public RabbitDockerContainer assertUp() {
    RabbitProbe probe = getProbe();
    try {
        Awaitility
                .with()
                .pollDelay(2, TimeUnit.SECONDS)
                .pollInterval(500, TimeUnit.MILLISECONDS)
                .await()
                .atMost(2, TimeUnit.MINUTES)
                .until(probe::isSatisfied);
    } catch(ConditionTimeoutException e) {
        throw new RuntimeException(probe.getLatestError());
    }
    return this;
}
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
@Test
public void test() {
  try {
    await().atMost(1, TimeUnit.SECONDS).catchUncaughtExceptions().until(getTask());
  } catch (ConditionTimeoutException e) {

    String msg = e.toString();
    msg = Common.hasError(msg) ? msg : Common.error("Timeout Error\n" + lastInput());

    System.err.println(msg);
    System.exit(-1);
  } catch (Throwable t) {
    //t.printStackTrace();
    StackTraceElement[] stackTrace = t.getStackTrace();
    StringBuilder buf = new StringBuilder();

    buf.append(t.fillInStackTrace()).append('\n');

    for (StackTraceElement line : stackTrace) {
      if (classes.contains(line.getClassName())) {
        buf.append(line).append('\n');
      }
    }
    buf.append(lastInput());

    System.err.println(Common.error(buf.toString()));
    System.exit(-1);
  }
}
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
private void verifyRightCountOfEvents(final Expect[] expectedEvents) {

        for (final Expect expectedEvent : expectedEvents) {
            try {
                Awaitility.await().atMost(5, TimeUnit.SECONDS)
                        .until(() -> eventCaptor.getCountFor(expectedEvent.type()), equalTo(expectedEvent.count()));

            } catch (final ConditionTimeoutException ex) {
                Assert.fail("Did not receive the expected amount of events form " + expectedEvent.type() + " Expected: "
                        + expectedEvent.count() + " but was: " + eventCaptor.getCountFor(expectedEvent.type()));
            }
        }
    }
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
@Test(expected = ConditionTimeoutException.class)
public void
a_client_cannot_write_after_it_left() throws Exception {
    jack.enter();
    joeShouldReceive(welcome("Jack"));

    jack.leave();
    joeShouldReceive(exit("Jack"));

    jack.announce("All alone now ...");

    joeShouldReceive(signed("Jack", "Are alone now ..."));
}
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public boolean matches(Object item) {
    MockLockCallback callback = (MockLockCallback) item;
    try {
        waitAtMost(Duration.ONE_SECOND).await().until(callback.authentication(), authenticationMatcher);
        waitAtMost(Duration.ONE_SECOND).await().until(callback.canceled(), canceledMatcher);
        waitAtMost(Duration.ONE_SECOND).await().until(callback.error(), errorMatcher);
        return true;
    } catch (ConditionTimeoutException e) {
        return false;
    }
}
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
private void waitForScanners(int maxTime) {
    /* XXX!!!!!!!!!!!!!!!!!! */
    if (maxTime == 0) {
        maxTime = 3600*2;
    }
    if (maxTime < timeStep) {
        maxTime = timeStep * 2;
    }
    try {
        Awaitility.with().timeout(maxTime, TimeUnit.SECONDS)
                .and().with().pollDelay(timeStep, TimeUnit.SECONDS)
                .and().with().pollInterval(timeStep, TimeUnit.SECONDS)
                .await()
                .until(new Callable<Boolean>() {
                    @Override
                    public Boolean call() throws Exception {
                        scanTime += timeStep;
                        synchronized (scanners) {
                            Iterator<IScanQueueItem> i = scanners.iterator();
                            while (i.hasNext()) {
                                IScanQueueItem scan = i.next();
                                if (scan.getStatus().equals("finished")) {
                                    i.remove();
                                    totalScanners += 1;
                                } else {
                                    stdout.println("Scanners: " + scanners.size());

                                    if (issues != null) {
                                        callbacks.generateScanReport("XML", issues.toArray(new IScanIssue[issues.size()]),
                                                new File(extConfig.getReportPath()));
                                    }

                                    return false;
                                }
                            }
                        }
                        return true;
                    }
                });
    } catch (ConditionTimeoutException e) {
        /* exiting anyway */
        stdout.println("timeout!");
        timeout = true;
    }
}
 

import com.jayway.awaitility.core.ConditionTimeoutException; //导入依赖的package包/类
/**
 * Starts the container and waits until is started
 *
 * @param timeout in seconds
 */
@Override
public void start(int timeout) {
    if (containerId != null) {
        return;
    }

    pullImage();

    CreateContainerCmd createCommand = dockerCommand();
    LOGGER.debug("Creating container [" + createCommand.getName() + "]");
    containerId = createCommand.exec().getId();

    DockerClientFactory.build().startContainerCmd(containerId).exec();

    try {

        await("Container did not start within " + timeout + " seconds").atMost(timeout, TimeUnit.SECONDS).pollDelay(1, TimeUnit.SECONDS).until(() -> {
            List<Container> containers = DockerClientFactory.build().listContainersCmd().withShowAll(true).exec();
            for (Container container : containers) {
                if (container.getId().equals(containerId)) {
                    return true;
                }
            }
            return false;
        });

    } catch (ConditionTimeoutException cte) {
        String errorMessage = String.format("Container [%s] did not start within %d seconds.", createCommand.getName(), timeout);
        LOGGER.error(errorMessage);
        try {
            for (String logLine : DockerContainersUtil.getDockerLogs(containerId)) {
                LOGGER.error(logLine);
            }
        } catch (Exception e) {
            LOGGER.error("Could not print container logs", e);
        }
        throw new MinimesosException(errorMessage + " See container logs above");
    }

    LOGGER.debug(String.format("Container %s is up and running", containerId));
}