org.echocat.jomon.testing

Class Assert

java.lang.Object

org.echocat.jomon.testing.Assert

public class Assert
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Assert.AssertWithRetry
static class	Assert.AssertWithRetryRespectingException
static class	Assert.AssertWithRetrySupport<S extends RetryingStrategy<java.lang.Void>>

Field Summary

Fields

Modifier and Type	Field and Description
static java.lang.String	ASSERT_CLASSNAME

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Assert()

Method Summary

Modifier and Type	Method and Description
static void	assertThat(boolean actual)
static void	assertThat(java.lang.String reason, boolean actual)
static <T> void	assertThat(java.lang.String reason, T actual, org.hamcrest.Matcher<T> matcher) Asserts that actual satisfies the condition specified by matcher.
static <T> void	assertThat(T actual, org.hamcrest.Matcher<T> matcher) Asserts that actual satisfies the condition specified by matcher.
static Assert.AssertWithRetryRespectingException	assertWithRetries(int maxNumbersOfRetries) Creates an Assert.AssertWithRetry that allows to test the assertion at most maxNumbersOfRetries times until it must succeed.
static Assert.AssertWithRetry	assertWithRetry(RetryingStrategy<java.lang.Void> retryingStrategy) Creates an Assert.AssertWithRetry that uses a custom RetryingStrategy to satisfy a given assertion.
static Assert.AssertWithRetryRespectingException	assertWithTimeout(Duration duration) Creates an Assert.AssertWithRetry that allows a timeout in which the assertion must be satisfied.
static Assert.AssertWithRetryRespectingException	assertWithTimeout(java.lang.String duration) Creates an Assert.AssertWithRetry that allows a timeout in which the assertion must be satisfied.
static void	fail()
static void	fail(java.lang.String message)
protected static java.lang.StackTraceElement[]	getCleanStackTrace()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

ASSERT_CLASSNAME

public static final java.lang.String ASSERT_CLASSNAME

Constructor Detail

Assert

protected Assert()

Method Detail

assertThat

public static void assertThat(boolean actual)

assertThat

public static void assertThat(@Nullable
                              java.lang.String reason,
                              boolean actual)

assertThat

public static <T> void assertThat(@Nullable
                                  T actual,
                                  @Nonnull
                                  org.hamcrest.Matcher<T> matcher)

Asserts that actual satisfies the condition specified by matcher. If not, an AssertionError is thrown with information about the matcher and failing value. Example:

   assertThat(0, is(1)); // fails:
     // failure message:
     // expected: is <1>
     // got value: <0>
   assertThat(0, is(not(1))) // passes
 

Type Parameters:

T - the static type accepted by the matcher (this can flag obvious compile-time problems such as assertThat(1, is("a"))

Parameters:

actual - the computed value being compared

matcher - an expression, built of Matchers, specifying allowed values

See Also:

CoreMatchers, JUnitMatchers

assertThat

public static <T> void assertThat(@Nullable
                                  java.lang.String reason,
                                  @Nullable
                                  T actual,
                                  @Nonnull
                                  org.hamcrest.Matcher<T> matcher)

Asserts that actual satisfies the condition specified by matcher. If not, an AssertionError is thrown with the reason and information about the matcher and failing value. Example:

 :
   assertThat("Help! Integers don't work", 0, is(1)); // fails:
     // failure message:
     // Help! Integers don't work
     // expected: is <1>
     // got value: <0>
   assertThat("Zero is one", 0, is(not(1))) // passes
 

Type Parameters:

T - the static type accepted by the matcher (this can flag obvious compile-time problems such as assertThat(1, is("a"))

Parameters:

reason - additional information about the error

actual - the computed value being compared

matcher - an expression, built of Matchers, specifying allowed values

See Also:

CoreMatchers, JUnitMatchers

fail

public static void fail()

fail

public static void fail(@Nullable
                        java.lang.String message)

getCleanStackTrace

@Nonnull
protected static java.lang.StackTraceElement[] getCleanStackTrace()

assertWithRetries

@Nonnull
public static Assert.AssertWithRetryRespectingException assertWithRetries(@Nonnegative
                                                                                    int maxNumbersOfRetries)

Creates an Assert.AssertWithRetry that allows to test the assertion at most maxNumbersOfRetries times until it must succeed. Otherwise an AssertionError is thrown. This method allows a chained notation, e.g.:

     assertWithRetry(3).that("some reasons", new Callable() {
          @Override
         public Boolean call() throws Exception {
             return readValue();
         }
     }, equalTo(5));
 

With Java 1.8 or later, we can use the more straightforward lamba notation:

     assertWithRetry(3).that(() -> readValue(), equalTo(5));
 

assertWithTimeout

@Nonnull
public static Assert.AssertWithRetryRespectingException assertWithTimeout(@Nonnull
                                                                                    java.lang.String duration)

Creates an Assert.AssertWithRetry that allows a timeout in which the assertion must be satisfied. If the assertion still fails after this timeout an {link AssertionError} is thrown. This method allows a chained notation, e.g.:

     assertWithRetry("3s").that("some reasons", new Callable() {
          @Override
         public Boolean call() throws Exception {
             return readValue();
         }
     }, equalTo(5));
 

With Java 1.8 or later, we can use the more straightforward lamba notation:

     assertWithRetry("3s").that(() -> readValue(), equalTo(5));
 

Parameters:

duration - the maximum time in Duration nation in which an assertion must succeed

assertWithTimeout

@Nonnull
public static Assert.AssertWithRetryRespectingException assertWithTimeout(@Nonnull
                                                                                    Duration duration)

Creates an Assert.AssertWithRetry that allows a timeout in which the assertion must be satisfied. If the assertion still fails after this timeout an {link AssertionError} is thrown. This method allows a chained notation, e.g.:

     assertWithRetry(new Duration("3s")).that("some reasons", new Callable() {
          @Override
         public Boolean call() throws Exception {
             return readValue();
         }
     }, equalTo(5));
 

With Java 1.8 or later, we can use the more straightforward lamba notation:

     assertWithRetry(new Duration("3s")).that(() -> readValue(), equalTo(5));
 

Parameters:

duration - the maximum time as a Duration in which an assertion must succeed

assertWithRetry

@Nonnull
public static Assert.AssertWithRetry assertWithRetry(@Nonnull
                                                               RetryingStrategy<java.lang.Void> retryingStrategy)

Creates an Assert.AssertWithRetry that uses a custom RetryingStrategy to satisfy a given assertion. This method allows a chained notation, e.g.:

     assertWithRetry(new RetryForSpecifiedTimeStrategy("5s")).that("some reasons", new Callable() {
          @Override
         public Boolean call() throws Exception {
             return readValue();
         }
     }, equalTo(5));
 

With Java 1.8 or later, we can use the more straightforward lamba notation:

     assertWithRetry(new RetryForSpecifiedTimeStrategy("5s")).that(() -> readValue(), equalTo(5));
 

Parameters:

retryingStrategy - the strategy to retry the assertion until is either succeeds or the strategy declines a retry