Poller

@SuppressWarnings("UnusedDeclaration")
public class Poller {
    public static long seconds(int seconds) {
        return seconds * 1000;
    }

    public static long milliseconds(int millis) {
        return millis;
    }

    public static Poller poller(long timeoutMillis, long pollDelayMillis) {
        return new Poller(timeoutMillis, pollDelayMillis);
    }

    private final long initialDelayMillis;
    private final long timeoutMillis;
    private final long pollDelayMillis;

    public Poller(long timeoutMillis, long pollDelayMillis) {
        this.timeoutMillis = timeoutMillis;
        this.pollDelayMillis = pollDelayMillis;
        this.initialDelayMillis = 0;
    }

    public Poller(long timeoutMillis, long pollDelayMillis, long initialDelayMillis) {
        this.initialDelayMillis = initialDelayMillis;
        this.timeoutMillis = timeoutMillis;
        this.pollDelayMillis = pollDelayMillis;
    }

    public void waitFor(Probe probe) {
        Timeout timeout = new Timeout(timeoutMillis);
        sleep(initialDelayMillis);
        while (!probe.isSatisfied()) {
            if (timeout.hasTimedOut())
                throw new AssertionError(probe.describeFailure());

            sleep(pollDelayMillis);
        }
    }

    public void alwaysSatisfy(Probe probe) {
        Timeout timeout = new Timeout(timeoutMillis);
        sleep(initialDelayMillis);
        while (!timeout.hasTimedOut()) {
            if (!probe.isSatisfied())
                throw new AssertionError(probe.describeFailure());

            sleep(pollDelayMillis);
        }
    }

    private static void sleep(long millis) {
        if (millis > 0)
            try {
                Thread.sleep(millis);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
    }

    public void assertEventually(Probe probe) {
        waitFor(probe);
    }

    public void assertEventually(PollingMatcherAssert.Matchers matchers){
        assertEventually(new PollingMatcherAssert(matchers));
    }

    public void assertAlways(Probe probe) {
        alwaysSatisfy(probe);
    }
    public void assertAlways(PollingMatcherAssert.Matchers matchers){
        assertAlways(new PollingMatcherAssert(matchers));
    }

    public void assertThat(Probe probe) {
        waitFor(probe);
    }

    public static class Timeout {
        private final long timeoutTimeInMillis;

        public Timeout(long timeoutInMillis) {
            this.timeoutTimeInMillis = System.currentTimeMillis() + timeoutInMillis;
        }

        public boolean hasTimedOut() {
            return System.currentTimeMillis() > timeoutTimeInMillis;
        }
    }
}