Asserts (Apache Brooklyn)

java.lang.Object
- org.apache.brooklyn.test.Asserts

```
public class Asserts
extends java.lang.Object
```
TODO should move this to new package brooklyn.util.assertions and TODO should add a repeating() method which returns an AssertingRepeater extending Repeater and:
- adds support for requireAllIterationsTrue
- convenience run methods equivalent to succeedsEventually and succeedsContinually
NOTE Selected routines in this class are originally copied from TestNG, to allow us to make assertions without having to introduce a runtime dependency on TestNG.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Asserts.BooleanWithMessage`
`static class`	`Asserts.ShouldHaveFailedPreviouslyAssertionError` Subclass of `AssertionError` which indicates that code which should have thrown did not, so that callers can disambiguate expected errors from this one.

Field Summary

Fields
Modifier and Type	Field and Description
`static Duration`	`DEFAULT_LONG_TIMEOUT` Timeout for use when something should happen within several seconds, but there might be network calls or computation so `DEFAULT_SHORT_TIMEOUT` is not applicable.
`static Duration`	`DEFAULT_SHORT_TIMEOUT` Timeout for use when waiting for other threads to finish.
`static Duration`	`DEFAULT_TIMEOUT` Deprecated. since 0.9.0 use `DEFAULT_LONG_TIMEOUT`

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`assertEquals(boolean actual, boolean expected)` Asserts that two booleans are equal.
`static void`	`assertEquals(boolean actual, boolean expected, java.lang.String message)` Asserts that two booleans are equal.
`static void`	`assertEquals(byte actual, byte expected)` Asserts that two bytes are equal.
`static void`	`assertEquals(byte actual, byte expected, java.lang.String message)` Asserts that two bytes are equal.
`static void`	`assertEquals(char actual, char expected)` Asserts that two chars are equal.
`static void`	`assertEquals(char actual, char expected, java.lang.String message)` Asserts that two chars are equal.
`static void`	`assertEquals(java.util.Collection<?> actual, java.util.Collection<?> expected)` Asserts that two collections contain the same elements in the same order.
`static void`	`assertEquals(java.util.Collection<?> actual, java.util.Collection<?> expected, java.lang.String message)` Asserts that two collections contain the same elements in the same order.
`static void`	`assertEquals(double actual, double expected, double delta)` Asserts that two doubles are equal within a delta.
`static void`	`assertEquals(double actual, double expected, double delta, java.lang.String message)` Asserts that two doubles are equal within a delta.
`static void`	`assertEquals(float actual, float expected, float delta)` Asserts that two floats are equal within a delta.
`static void`	`assertEquals(float actual, float expected, float delta, java.lang.String message)` Asserts that two floats are equal within a delta.
`static void`	`assertEquals(int actual, int expected)` Asserts that two ints are equal.
`static void`	`assertEquals(int actual, int expected, java.lang.String message)` Asserts that two ints are equal.
`static void`	`assertEquals(java.lang.Iterable<?> actual, java.lang.Iterable<?> expected)` Asserts that two iterables return iterators with the same elements in the same order.
`static void`	`assertEquals(java.lang.Iterable<?> actual, java.lang.Iterable<?> expected, java.lang.String message)` Asserts that two iterables return iterators with the same elements in the same order.
`static void`	`assertEquals(java.util.Iterator<?> actual, java.util.Iterator<?> expected)` Asserts that two iterators return the same elements in the same order.
`static void`	`assertEquals(java.util.Iterator<?> actual, java.util.Iterator<?> expected, java.lang.String message)` Asserts that two iterators return the same elements in the same order.
`static void`	`assertEquals(long actual, long expected)` Asserts that two longs are equal.
`static void`	`assertEquals(long actual, long expected, java.lang.String message)` Asserts that two longs are equal.
`static void`	`assertEquals(java.util.Map<?,?> actual, java.util.Map<?,?> expected)` Asserts that two maps are equal.
`static void`	`assertEquals(java.lang.Object[] actual, java.lang.Object[] expected)` Asserts that two arrays contain the same elements in the same order.
`static void`	`assertEquals(java.lang.Object[] actual, java.lang.Object[] expected, java.lang.String message)` Asserts that two arrays contain the same elements in the same order.
`static void`	`assertEquals(java.lang.Object actual, java.lang.Object expected)` Asserts that two objects are equal.
`static void`	`assertEquals(java.lang.Object actual, java.lang.Object expected, java.lang.String message)` Asserts that two objects are equal.
`static void`	`assertEquals(java.util.Set<?> actual, java.util.Set<?> expected)` Asserts that two sets are equal.
`static void`	`assertEquals(java.util.Set<?> actual, java.util.Set<?> expected, java.lang.String message)` Assert set equals
`static void`	`assertEquals(short actual, short expected)` Asserts that two shorts are equal.
`static void`	`assertEquals(short actual, short expected, java.lang.String message)` Asserts that two shorts are equal.
`static void`	`assertEquals(java.lang.String actual, java.lang.String expected)` Asserts that two Strings are equal.
`static void`	`assertEquals(java.lang.String actual, java.lang.String expected, java.lang.String message)` Asserts that two Strings are equal.
`static void`	`assertEqualsIgnoringOrder(java.lang.Iterable<?> actual, java.lang.Iterable<?> expected)`
`static void`	`assertEqualsIgnoringOrder(java.lang.Iterable<?> actual, java.lang.Iterable<?> expected, boolean logDuplicates, java.lang.String errmsg)`
`static void`	`assertFails(java.util.concurrent.Callable<?> c)`
`static void`	`assertFails(java.lang.Runnable r)`
`static void`	`assertFailsWith(java.util.concurrent.Callable<?> c, exceptionChecker)`
`static void`	`assertFailsWith(java.util.concurrent.Callable<?> c, groovy.lang.Closure<java.lang.Boolean> exceptionChecker)`
`static void`	`assertFailsWith(java.lang.Runnable r, exceptionChecker)`
`static void`	`assertFailsWith(java.lang.Runnable c, java.lang.Class<? extends java.lang.Throwable> validException, java.lang.Class<? extends java.lang.Throwable>... otherValidExceptions)`
`static void`	`assertFalse(boolean condition, java.lang.String message)` Asserts that a condition is false.
`static void`	`assertNotNull(java.lang.Object object)` Assert that an object reference is not null.
`static void`	`assertNotNull(java.lang.Object object, java.lang.String message)` Assert that an object reference is not null.
`static void`	`assertNull(java.lang.Object object)` Assert that an object reference is null.
`static void`	`assertNull(java.lang.Object object, java.lang.String message)` Assert that an object reference is null.
`static void`	`assertReturnsEventually(java.lang.Runnable r, Duration timeout)`
`static void`	`assertStringContains(java.lang.String input, java.lang.String phrase1ToContain, java.lang.String... optionalOtherPhrasesToContain)`
`static void`	`assertStringContainsAtLeastOne(java.lang.String input, java.lang.String possiblePhrase1ToContain, java.lang.String... optionalOtherPossiblePhrasesToContain)`
`static void`	`assertStringContainsIgnoreCase(java.lang.String input, java.lang.String phrase1ToContain, java.lang.String... optionalOtherPhrasesToContain)`
`static void`	`assertStringMatchesRegex(java.lang.String input, java.lang.String regex1ToMatch, java.lang.String... optionalOtherRegexesToMatch)`
`static <T> void`	`assertThat(T object, condition)`
`static void`	`assertTrue(boolean condition)` Asserts that a condition is true.
`static void`	`assertTrue(boolean condition, java.lang.String message)` Asserts that a condition is true.
`static <T> void`	`continually( supplier, predicate)` As `#continually(Supplier, Predicate, Duration, Duration, String)` with defaults.
`static <T> void`	`continually( supplier, predicate, Duration duration, Duration period, java.lang.String errMsg)` Asserts that continually the supplier gives a value accepted by the predicate.
`static <T> void`	`continually(java.util.Map<java.lang.String,?> flags, supplier, predicate)` Deprecated. since 0.9.0 use `#continually(Supplier, Predicate, Duration, Duration, String)`
`static <T> void`	`continually(java.util.Map<java.lang.String,?> flags, supplier, predicate, java.lang.String errMsg)` Deprecated. since 0.9.0 use `#continually(Supplier, Predicate, Duration, Duration, String)`
`static <T> void`	`eventually( supplier, predicate)` As `#eventually(Supplier, Predicate, Duration, Duration, String)` with defaults.
`static <T> void`	`eventually( supplier, predicate, Duration timeout)` As `#eventually(Supplier, Predicate, Duration, Duration, String)` with default.
`static <T> void`	`eventually( supplier, predicate, Duration timeout, Duration period, java.lang.String errMsg)` Asserts that eventually the supplier gives a value accepted by the predicate.
`static <T> void`	`eventually(java.util.Map<java.lang.String,?> flags, supplier, predicate)` Deprecated. since 0.9.0 use `#eventually(Supplier, Predicate, Duration, Duration, String)`
`static <T> void`	`eventually(java.util.Map<java.lang.String,?> flags, supplier, predicate, java.lang.String errMsg)` Deprecated. since 0.9.0 use `#eventually(Supplier, Predicate, Duration, Duration, String)`
`static <T> void`	`eventuallyOnNotify(java.lang.Object notifyTarget, supplier, predicate)` As `#eventuallyOnNotify(Object, Supplier, Predicate, Duration, boolean)` with default timeout.
`static <T> void`	`eventuallyOnNotify(java.lang.Object notifyTarget, supplier, predicate, Duration timeout)` as `#eventually(Supplier, Predicate)` for cases where an object is notified; more efficient as it waits on the notify target object.
`static <T> void`	`eventuallyOnNotify(T object, predicate)` As `#eventuallyOnNotify(Object, Predicate, Duration)` with the default duration of `#eventuallyOnNotify(Object, Supplier, Predicate)`.
`static <T> void`	`eventuallyOnNotify(T object, predicate, Duration timeout)` Convenience for `#eventuallyOnNotify(Object, Supplier, Predicate, Duration, boolean)` when the notify target and the value under test are the same.
`static void`	`expectedFailure(java.lang.Throwable e)` Tests that an exception is not `Asserts.ShouldHaveFailedPreviouslyAssertionError`.
`static void`	`expectedFailureContains(java.lang.Throwable e, java.lang.String phrase1ToContain, java.lang.String... optionalOtherPhrasesToContain)` Tests `expectedFailure(Throwable)` and that the `toString` satisfies `assertStringContains(String, String, String...)`.
`static void`	`expectedFailureContainsIgnoreCase(java.lang.Throwable e, java.lang.String phrase1ToContain, java.lang.String... optionalOtherPhrasesToContain)` As `expectedFailureContains(Throwable, String, String...)` but case insensitive
`static void`	`expectedFailureOfType(java.lang.Throwable e, java.lang.Class<?>... permittedSupertypes)` Tests that an exception is not `Asserts.ShouldHaveFailedPreviouslyAssertionError` and is either one of the given types, or has a caused-by of one of the given types.
`static java.lang.AssertionError`	`fail(java.lang.String message)` Fails a test with the given message.
`static void`	`shouldHaveFailedPreviously()` Throws a `Asserts.ShouldHaveFailedPreviouslyAssertionError` exception, to more easily distinguish this failure from other fails.
`static void`	`shouldHaveFailedPreviously(java.lang.String message)` As `shouldHaveFailedPreviously()` but allowing detail, for example a value which was received when it shouldn't have been.
`static <T> T`	`succeedsContinually(java.util.concurrent.Callable<T> c)`
`static <T> T`	`succeedsContinually(java.util.Map<?,?> flags, java.util.concurrent.Callable<T> job)`
`static <T> void`	`succeedsContinually(java.util.Map<?,?> flags, java.lang.Runnable r)`
`static <T> void`	`succeedsContinually(java.lang.Runnable r)`
`static <T> T`	`succeedsEventually(java.util.concurrent.Callable<T> c)`
`static <T> T`	`succeedsEventually(java.util.Map<java.lang.String,?> flags, java.util.concurrent.Callable<T> c)` Convenience method for cases where we need to test until something is true.
`static void`	`succeedsEventually(java.util.Map<java.lang.String,?> flags, java.lang.Runnable r)`
`static void`	`succeedsEventually(java.lang.Runnable r)`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_LONG_TIMEOUT
```
public static final Duration DEFAULT_LONG_TIMEOUT
```
    Timeout for use when something should happen within several seconds, but there might be network calls or computation so DEFAULT_SHORT_TIMEOUT is not applicable.
  - DEFAULT_SHORT_TIMEOUT
```
public static final Duration DEFAULT_SHORT_TIMEOUT
```
    Timeout for use when waiting for other threads to finish.
    Long enough for parallel execution to catch up, even on overloaded mediocre test boxes most of the time, but short enough not to irritate you when your test is failing.
  - DEFAULT_TIMEOUT
```
@Deprecated
public static final Duration DEFAULT_TIMEOUT
```
    Deprecated. since 0.9.0 use DEFAULT_LONG_TIMEOUT
- Method Detail
  - assertNull
```
public static void assertNull(java.lang.Object object)
```
    Assert that an object reference is null.
    
    Parameters:
    object - The object reference.
    
    Throws:
    
    java.lang.AssertionError - if the assertion fails.
  - assertNotNull
```
public static void assertNotNull(java.lang.Object object)
```
    Assert that an object reference is not null.
    
    Parameters:
    object - The object reference.
    
    Throws:
    
    java.lang.AssertionError - if the assertion fails.
  - assertNull
```
public static void assertNull(java.lang.Object object,
              java.lang.String message)
```
    Assert that an object reference is null.
    
    Parameters:
    object - The object reference.
    message - The assertion error message.
    
    Throws:
    
    java.lang.AssertionError - if the assertion fails.
  - assertNotNull
```
public static void assertNotNull(java.lang.Object object,
                 java.lang.String message)
```
    Assert that an object reference is not null.
    
    Parameters:
    object - The object reference.
    message - The assertion error message.
    
    Throws:
    
    java.lang.AssertionError - if the assertion fails.
  - assertEquals
```
public static void assertEquals(java.util.Collection<?> actual,
                java.util.Collection<?> expected)
```
    Asserts that two collections contain the same elements in the same order. If they do not, an AssertionError is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertEquals
```
public static void assertEquals(java.util.Collection<?> actual,
                java.util.Collection<?> expected,
                java.lang.String message)
```
    Asserts that two collections contain the same elements in the same order. If they do not, an AssertionError, with the given message, is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(java.util.Iterator<?> actual,
                java.util.Iterator<?> expected)
```
    Asserts that two iterators return the same elements in the same order. If they do not, an AssertionError is thrown. Please note that this assert iterates over the elements and modifies the state of the iterators.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertEquals
```
public static void assertEquals(java.util.Iterator<?> actual,
                java.util.Iterator<?> expected,
                java.lang.String message)
```
    Asserts that two iterators return the same elements in the same order. If they do not, an AssertionError, with the given message, is thrown. Please note that this assert iterates over the elements and modifies the state of the iterators.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(java.lang.Iterable<?> actual,
                java.lang.Iterable<?> expected)
```
    Asserts that two iterables return iterators with the same elements in the same order. If they do not, an AssertionError is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertEquals
```
public static void assertEquals(java.lang.Iterable<?> actual,
                java.lang.Iterable<?> expected,
                java.lang.String message)
```
    Asserts that two iterables return iterators with the same elements in the same order. If they do not, an AssertionError, with the given message, is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(java.util.Set<?> actual,
                java.util.Set<?> expected)
```
    Asserts that two sets are equal.
  - assertEquals
```
public static void assertEquals(java.util.Set<?> actual,
                java.util.Set<?> expected,
                java.lang.String message)
```
    Assert set equals
  - assertEquals
```
public static void assertEquals(java.util.Map<?,?> actual,
                java.util.Map<?,?> expected)
```
    Asserts that two maps are equal.
  - assertEquals
```
public static void assertEquals(java.lang.Object[] actual,
                java.lang.Object[] expected,
                java.lang.String message)
```
    Asserts that two arrays contain the same elements in the same order. If they do not, an AssertionError, with the given message, is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(java.lang.Object[] actual,
                java.lang.Object[] expected)
```
    Asserts that two arrays contain the same elements in the same order. If they do not, an AssertionError is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertEquals
```
public static void assertEquals(java.lang.Object actual,
                java.lang.Object expected)
```
    Asserts that two objects are equal.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    
    Throws:
    
    java.lang.AssertionError - if the values are not equal.
  - assertEquals
```
public static void assertEquals(java.lang.Object actual,
                java.lang.Object expected,
                java.lang.String message)
```
    Asserts that two objects are equal.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
    
    Throws:
    
    java.lang.AssertionError - if the values are not equal.
  - assertEquals
```
public static void assertEquals(java.lang.String actual,
                java.lang.String expected,
                java.lang.String message)
```
    Asserts that two Strings are equal. If they are not, an AssertionError, with the given message, is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(java.lang.String actual,
                java.lang.String expected)
```
    Asserts that two Strings are equal. If they are not, an AssertionError is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertEquals
```
public static void assertEquals(double actual,
                double expected,
                double delta,
                java.lang.String message)
```
    Asserts that two doubles are equal within a delta. If they are not, an AssertionError, with the given message, is thrown. If the expected value is infinity then the delta value is ignored.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    delta - the absolute tolerable difference between the actual and expected values
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(double actual,
                double expected,
                double delta)
```
    Asserts that two doubles are equal within a delta. If they are not, an AssertionError is thrown. If the expected value is infinity then the delta value is ignored.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    delta - the absolute tolerable difference between the actual and expected values
  - assertEquals
```
public static void assertEquals(float actual,
                float expected,
                float delta,
                java.lang.String message)
```
    Asserts that two floats are equal within a delta. If they are not, an AssertionError, with the given message, is thrown. If the expected value is infinity then the delta value is ignored.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    delta - the absolute tolerable difference between the actual and expected values
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(float actual,
                float expected,
                float delta)
```
    Asserts that two floats are equal within a delta. If they are not, an AssertionError is thrown. If the expected value is infinity then the delta value is ignored.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    delta - the absolute tolerable difference between the actual and expected values
  - assertEquals
```
public static void assertEquals(long actual,
                long expected,
                java.lang.String message)
```
    Asserts that two longs are equal. If they are not, an AssertionError, with the given message, is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(long actual,
                long expected)
```
    Asserts that two longs are equal. If they are not, an AssertionError is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertEquals
```
public static void assertEquals(boolean actual,
                boolean expected,
                java.lang.String message)
```
    Asserts that two booleans are equal. If they are not, an AssertionError, with the given message, is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(boolean actual,
                boolean expected)
```
    Asserts that two booleans are equal. If they are not, an AssertionError is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertEquals
```
public static void assertEquals(byte actual,
                byte expected,
                java.lang.String message)
```
    Asserts that two bytes are equal. If they are not, an AssertionError, with the given message, is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(byte actual,
                byte expected)
```
    Asserts that two bytes are equal. If they are not, an AssertionError is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertEquals
```
public static void assertEquals(char actual,
                char expected,
                java.lang.String message)
```
    Asserts that two chars are equal. If they are not, an AssertionFailedError, with the given message, is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(char actual,
                char expected)
```
    Asserts that two chars are equal. If they are not, an AssertionError is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertEquals
```
public static void assertEquals(short actual,
                short expected,
                java.lang.String message)
```
    Asserts that two shorts are equal. If they are not, an AssertionFailedError, with the given message, is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(short actual,
                short expected)
```
    Asserts that two shorts are equal. If they are not, an AssertionError is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertEquals
```
public static void assertEquals(int actual,
                int expected,
                java.lang.String message)
```
    Asserts that two ints are equal. If they are not, an AssertionFailedError, with the given message, is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
    message - the assertion error message
  - assertEquals
```
public static void assertEquals(int actual,
                int expected)
```
    Asserts that two ints are equal. If they are not, an AssertionError is thrown.
    
    Parameters:
    actual - the actual value
    expected - the expected value
  - assertTrue
```
public static void assertTrue(boolean condition)
```
    Asserts that a condition is true. If it isn't, an AssertionError is thrown.
    
    Parameters:
    condition - the condition to evaluate
  - assertTrue
```
public static void assertTrue(boolean condition,
              java.lang.String message)
```
    Asserts that a condition is true. If it isn't, an AssertionError, with the given message, is thrown.
    
    Parameters:
    condition - the condition to evaluate
    message - the assertion error message
  - assertFalse
```
public static void assertFalse(boolean condition,
               java.lang.String message)
```
    Asserts that a condition is false. If it isn't, an AssertionError, with the given message, is thrown.
    
    Parameters:
    condition - the condition to evaluate
    message - the assertion error message
  - fail
```
public static java.lang.AssertionError fail(java.lang.String message)
```
    Fails a test with the given message.
    
    Parameters:
    message - the assertion error message
  - assertEqualsIgnoringOrder
```
public static void assertEqualsIgnoringOrder(java.lang.Iterable<?> actual,
                             java.lang.Iterable<?> expected)
```
  - assertEqualsIgnoringOrder
```
public static void assertEqualsIgnoringOrder(java.lang.Iterable<?> actual,
                             java.lang.Iterable<?> expected,
                             boolean logDuplicates,
                             java.lang.String errmsg)
```
  - eventually
```
public static <T> void eventually( supplier,
                   predicate)
```
    As #eventually(Supplier, Predicate, Duration, Duration, String) with defaults.
  - eventually
```
@Deprecated
public static <T> void eventually(java.util.Map<java.lang.String,?> flags,
                              supplier,
                              predicate)
```
    Deprecated. since 0.9.0 use #eventually(Supplier, Predicate, Duration, Duration, String)
  - eventually
```
@Deprecated
public static <T> void eventually(java.util.Map<java.lang.String,?> flags,
                              supplier,
                              predicate,
                             java.lang.String errMsg)
```
    Deprecated. since 0.9.0 use #eventually(Supplier, Predicate, Duration, Duration, String)
  - eventually
```
public static <T> void eventually( supplier,
                   predicate,
                  Duration timeout)
```
    As #eventually(Supplier, Predicate, Duration, Duration, String) with default.
  - eventually
```
public static <T> void eventually( supplier,
                   predicate,
                  Duration timeout,
                  Duration period,
                  java.lang.String errMsg)
```
    Asserts that eventually the supplier gives a value accepted by the predicate. Tests periodically and succeeds as soon as the supplier gives an allowed value. Other arguments can be null.
    
    Parameters:
    supplier - supplies the value to test, such as Suppliers#ofInstance(Object) for a constant
    predicate - the Predicate to apply to each value given by the supplier
    timeout - how long to wait, default DEFAULT_SHORT_TIMEOUT
    period - how often to check, default quite often so you won't notice but letting the CPU do work
    errMsg - an error message to display if not satisfied, in addition to the last-tested supplied value and the predicate
  - continually
```
public static <T> void continually( supplier,
                    predicate)
```
    As #continually(Supplier, Predicate, Duration, Duration, String) with defaults.
  - continually
```
@Deprecated
public static <T> void continually(java.util.Map<java.lang.String,?> flags,
                               supplier,
                               predicate)
```
    Deprecated. since 0.9.0 use #continually(Supplier, Predicate, Duration, Duration, String)
  - continually
```
@Deprecated
public static <T> void continually(java.util.Map<java.lang.String,?> flags,
                               supplier,
                               predicate,
                              java.lang.String errMsg)
```
    Deprecated. since 0.9.0 use #continually(Supplier, Predicate, Duration, Duration, String)
  - continually
```
public static <T> void continually( supplier,
                    predicate,
                   Duration duration,
                   Duration period,
                   java.lang.String errMsg)
```
    Asserts that continually the supplier gives a value accepted by the predicate. Tests periodically and fails if the supplier gives a disallowed value. Other arguments can be null.
    
    Parameters:
    supplier - supplies the value to test, such as Suppliers#ofInstance(Object) for a constant
    predicate - the Predicate to apply to each value given by the supplier
    duration - how long to test for, default DEFAULT_SHORT_TIMEOUT
    period - how often to check, default quite often to minimise chance of missing a flashing violation but letting the CPU do work
    errMsg - an error message to display if not satisfied, in addition to the last-tested supplied value and the predicate
  - succeedsEventually
```
public static void succeedsEventually(java.lang.Runnable r)
```
    See Also:
    succeedsContinually(Map, Callable)
  - succeedsEventually
```
public static void succeedsEventually(java.util.Map<java.lang.String,?> flags,
                      java.lang.Runnable r)
```
    See Also:
    succeedsContinually(Map, Callable)
  - succeedsEventually
```
public static <T> T succeedsEventually(java.util.concurrent.Callable<T> c)
```
    See Also:
    succeedsContinually(Map, Callable)
  - succeedsEventually
```
public static <T> T succeedsEventually(java.util.Map<java.lang.String,?> flags,
                       java.util.concurrent.Callable<T> c)
```
    Convenience method for cases where we need to test until something is true. The Callable will be invoked periodically until it succesfully concludes.
    The following flags are supported:
    - abortOnError (boolean, default true)
    - abortOnException - (boolean, default false)
    - timeout - (a Duration or an integer in millis, defaults to DEFAULT_LONG_TIMEOUT)
    - period - (a Duration or an integer in millis, for fixed retry time; if not set, defaults to exponentially increasing from 1 to 500ms)
    - minPeriod - (a Duration or an integer in millis; only used if period not explicitly set; the minimum period when exponentially increasing; defaults to 1ms)
    - maxPeriod - (a Duration or an integer in millis; only used if period not explicitly set; the maximum period when exponentially increasing; defaults to 500ms)
    - maxAttempts - (integer, Integer.MAX_VALUE)
    The following flags are deprecated:
    - useGroovyTruth - (defaults to false; any result code apart from 'false' will be treated as success including null; ignored for Runnables which aren't Callables)
    Parameters:
    flags, - accepts the flags listed above
    c - The callable to invoke
  - succeedsContinually
```
public static <T> void succeedsContinually(java.lang.Runnable r)
```
  - succeedsContinually
```
public static <T> void succeedsContinually(java.util.Map<?,?> flags,
                           java.lang.Runnable r)
```
  - succeedsContinually
```
public static <T> T succeedsContinually(java.util.concurrent.Callable<T> c)
```
  - succeedsContinually
```
public static <T> T succeedsContinually(java.util.Map<?,?> flags,
                        java.util.concurrent.Callable<T> job)
```
  - assertFails
```
public static void assertFails(java.lang.Runnable r)
```
  - assertFails
```
public static void assertFails(java.util.concurrent.Callable<?> c)
```
  - assertFailsWith
```
public static void assertFailsWith(java.util.concurrent.Callable<?> c,
                   groovy.lang.Closure<java.lang.Boolean> exceptionChecker)
```
  - assertFailsWith
```
@SafeVarargs
public static void assertFailsWith(java.lang.Runnable c,
                               java.lang.Class<? extends java.lang.Throwable> validException,
                               java.lang.Class<? extends java.lang.Throwable>... otherValidExceptions)
```
  - assertFailsWith
```
public static void assertFailsWith(java.lang.Runnable r,
                    exceptionChecker)
```
  - assertFailsWith
```
public static void assertFailsWith(java.util.concurrent.Callable<?> c,
                    exceptionChecker)
```
  - assertReturnsEventually
```
public static void assertReturnsEventually(java.lang.Runnable r,
                           Duration timeout)
                                    throws java.lang.InterruptedException,
                                           java.util.concurrent.ExecutionException,
                                           java.util.concurrent.TimeoutException
```
    Throws:
    
    java.lang.InterruptedException
    
    java.util.concurrent.ExecutionException
    
    java.util.concurrent.TimeoutException
  - assertThat
```
public static <T> void assertThat(T object,
                   condition)
```
  - assertStringContains
```
public static void assertStringContains(java.lang.String input,
                        java.lang.String phrase1ToContain,
                        java.lang.String... optionalOtherPhrasesToContain)
```
  - assertStringContainsAtLeastOne
```
public static void assertStringContainsAtLeastOne(java.lang.String input,
                                  java.lang.String possiblePhrase1ToContain,
                                  java.lang.String... optionalOtherPossiblePhrasesToContain)
```
  - assertStringContainsIgnoreCase
```
public static void assertStringContainsIgnoreCase(java.lang.String input,
                                  java.lang.String phrase1ToContain,
                                  java.lang.String... optionalOtherPhrasesToContain)
```
  - assertStringMatchesRegex
```
public static void assertStringMatchesRegex(java.lang.String input,
                            java.lang.String regex1ToMatch,
                            java.lang.String... optionalOtherRegexesToMatch)
```
  - shouldHaveFailedPreviously
```
public static void shouldHaveFailedPreviously()
```
    Throws a Asserts.ShouldHaveFailedPreviouslyAssertionError exception, to more easily distinguish this failure from other fails. In particular, use one of the expectedFailure methods in the surrounding catch block and this error will pass through it.
  - shouldHaveFailedPreviously
```
public static void shouldHaveFailedPreviously(java.lang.String message)
```
    As shouldHaveFailedPreviously() but allowing detail, for example a value which was received when it shouldn't have been.
  - expectedFailure
```
public static void expectedFailure(java.lang.Throwable e)
```
    Tests that an exception is not Asserts.ShouldHaveFailedPreviouslyAssertionError. See shouldHaveFailedPreviously()
  - expectedFailureOfType
```
public static void expectedFailureOfType(java.lang.Throwable e,
                         java.lang.Class<?>... permittedSupertypes)
```
    Tests that an exception is not Asserts.ShouldHaveFailedPreviouslyAssertionError and is either one of the given types, or has a caused-by of one of the given types. If you want *just* the instanceof (without checking the caused-by), then just catch those exception types, treat that as success, and let any other exception be propagated.
  - expectedFailureContains
```
public static void expectedFailureContains(java.lang.Throwable e,
                           java.lang.String phrase1ToContain,
                           java.lang.String... optionalOtherPhrasesToContain)
```
    Tests expectedFailure(Throwable) and that the toString satisfies assertStringContains(String, String, String...).
  - expectedFailureContainsIgnoreCase
```
public static void expectedFailureContainsIgnoreCase(java.lang.Throwable e,
                                     java.lang.String phrase1ToContain,
                                     java.lang.String... optionalOtherPhrasesToContain)
```
    As expectedFailureContains(Throwable, String, String...) but case insensitive
  - eventuallyOnNotify
```
public static <T> void eventuallyOnNotify(java.lang.Object notifyTarget,
                           supplier,
                           predicate)
```
    As #eventuallyOnNotify(Object, Supplier, Predicate, Duration, boolean) with default timeout.
  - eventuallyOnNotify
```
public static <T> void eventuallyOnNotify(java.lang.Object notifyTarget,
                           supplier,
                           predicate,
                          Duration timeout)
```
    as #eventually(Supplier, Predicate) for cases where an object is notified; more efficient as it waits on the notify target object. See also the simpler #eventuallyOnNotify(Object, Predicate) when looking at a collection which is getting notified. Timeout defaults to DEFAULT_SHORT_TIMEOUT.
    This synchronizes on the notify target for the duration of the wait, including while getting and checking the value, so as not to miss any notification.
  - eventuallyOnNotify
```
public static <T> void eventuallyOnNotify(T object,
                           predicate,
                          Duration timeout)
```
    Convenience for #eventuallyOnNotify(Object, Supplier, Predicate, Duration, boolean) when the notify target and the value under test are the same.
  - eventuallyOnNotify
```
public static <T> void eventuallyOnNotify(T object,
                           predicate)
```
    As #eventuallyOnNotify(Object, Predicate, Duration) with the default duration of #eventuallyOnNotify(Object, Supplier, Predicate).

Class Asserts

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_LONG_TIMEOUT

DEFAULT_SHORT_TIMEOUT

DEFAULT_TIMEOUT

Method Detail

assertNull

assertNotNull

assertNull

assertNotNull

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertEquals

assertTrue

assertTrue

assertFalse

fail

assertEqualsIgnoringOrder

assertEqualsIgnoringOrder

eventually

eventually

eventually

eventually

eventually

continually

continually

continually

continually

succeedsEventually

succeedsEventually

succeedsEventually

succeedsEventually

succeedsContinually

succeedsContinually

succeedsContinually

succeedsContinually

assertFails

assertFails

assertFailsWith

assertFailsWith

assertFailsWith

assertFailsWith

assertReturnsEventually

assertThat

assertStringContains

assertStringContainsAtLeastOne

assertStringContainsIgnoreCase

assertStringMatchesRegex