org.assertj.core.api

Class AbstractDurationAssert<SELF extends AbstractDurationAssert<SELF>>

java.lang.Object

org.assertj.core.api.AbstractAssert<SELF,ACTUAL>

org.assertj.core.api.AbstractObjectAssert<SELF,ACTUAL>

org.assertj.core.api.AbstractComparableAssert<SELF,Duration>

org.assertj.core.api.AbstractDurationAssert<SELF>

All Implemented Interfaces:

Assert<SELF,Duration>, ComparableAssert<SELF,Duration>, Descriptable<SELF>, ExtensionPoints<SELF,Duration>

Direct Known Subclasses:

DurationAssert

public abstract class AbstractDurationAssert<SELF extends AbstractDurationAssert<SELF>>
extends AbstractComparableAssert<SELF,Duration>

Assertions for Duration type.

Since:

3.15.0

Author:

Filip Hrisafov

Field Summary

Fields inherited from class org.assertj.core.api.AbstractAssert

actual, info, myself, objects, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractDurationAssert(Duration duration, Class<?> selfType) Creates a new AbstractDurationAssert

Method Summary

Modifier and Type	Method and Description
SELF	hasDays(long otherDays) Verifies that the actual Duration has the given days.
SELF	hasHours(long otherHours) Verifies that the actual Duration has the given hours.
SELF	hasMillis(long otherMillis) Verifies that the actual Duration has the given millis.
SELF	hasMinutes(long otherMinutes) Verifies that the actual Duration has the given minutes.
SELF	hasNanos(long otherNanos) Verifies that the actual Duration has the given nanos.
SELF	hasSeconds(long otherSeconds) Verifies that the actual Duration has the given seconds.
SELF	isCloseTo(Duration expected, Duration allowedDifference) Verifies that the actual Duration is close to the given one within the given allowed difference (assertion succeeds if difference = allowed difference).
SELF	isNegative() Verifies that the actual Duration is negative (i.e.
SELF	isPositive() Verifies that the actual Duration is positive (i.e.
SELF	isZero() Verifies that the actual Duration is equal to Duration.ZERO.

Methods inherited from class org.assertj.core.api.AbstractComparableAssert

inBinary, inHexadecimal, isBetween, isEqualByComparingTo, isGreaterThan, isGreaterThanOrEqualTo, isLessThan, isLessThanOrEqualTo, isNotEqualByComparingTo, isStrictlyBetween, usingComparator, usingComparator, usingDefaultComparator

Methods inherited from class org.assertj.core.api.AbstractObjectAssert

as, as, doesNotReturn, extracting, extracting, extracting, extracting, extracting, extracting, extractingForProxy, getComparatorsByType, hasAllNullFieldsOrProperties, hasAllNullFieldsOrPropertiesExcept, hasFieldOrProperty, hasFieldOrPropertyWithValue, hasNoNullFieldsOrProperties, hasNoNullFieldsOrPropertiesExcept, hasOnlyFields, isEqualToComparingFieldByField, isEqualToComparingFieldByFieldRecursively, isEqualToComparingOnlyGivenFields, isEqualToIgnoringGivenFields, isEqualToIgnoringNullFields, newObjectAssert, returns, usingComparatorForFields, usingComparatorForType, usingRecursiveComparison, usingRecursiveComparison

Methods inherited from class org.assertj.core.api.AbstractAssert

areEqual, asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, is, isElementOfCustomAssert, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOfForProxy, satisfiesForProxy, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.assertj.core.api.Descriptable

as, describedAs

Constructor Detail

AbstractDurationAssert

protected AbstractDurationAssert(Duration duration,
                                 Class<?> selfType)

Creates a new AbstractDurationAssert

Parameters:

duration - the actual value to verify

selfType - the "self type"

Method Detail

isZero

public SELF isZero()

Verifies that the actual Duration is equal to Duration.ZERO.

Example :

 // assertion will pass
 assertThat(Duration.ZERO).isZero();

 // assertion will fail
 assertThat(Duration.ofMinutes(3)).isZero();

Returns:

this assertion object

Throws:

AssertionError - if the actual Duration is null

AssertionError - if the actual Duration is not Duration.ZERO

Since:

3.15.0

isNegative

public SELF isNegative()

Verifies that the actual Duration is negative (i.e. is less than Duration.ZERO).

Example :

 // assertion will pass
 assertThat(Duration.ofMinutes(-15)).isNegative();

 // assertion will fail
 assertThat(Duration.ofMinutes(10)).isNegative();

Returns:

this assertion object

Throws:

AssertionError - if the actual Duration is null

AssertionError - if the actual Duration is not less than Duration.ZERO

Since:

3.15.0

isPositive

public SELF isPositive()

Verifies that the actual Duration is positive (i.e. is greater than Duration.ZERO).

Example :

 // assertion will pass
 assertThat(Duration.ofHours(5)).isPositive();

 // assertion will fail
 assertThat(Duration.ofHours(-2)).isPositive();

Returns:

this assertion object

Throws:

AssertionError - if the actual Duration is null

AssertionError - if the actual Duration is not greater than Duration.ZERO

Since:

3.15.0

hasNanos

public SELF hasNanos(long otherNanos)

Verifies that the actual Duration has the given nanos.

Example :

 // assertion will pass
 assertThat(Duration.ofNanos(145)).hasNanos(145);

 // assertion will fail
 assertThat(Duration.ofNanos(145)).hasNanos(50);

Parameters:

otherNanos - the expected nanoseconds value

Returns:

this assertion object

Throws:

AssertionError - if the actual Duration is null

AssertionError - if the actual Duration does not have the given nanos

Since:

3.15.0

hasMillis

public SELF hasMillis(long otherMillis)

Verifies that the actual Duration has the given millis.

Example :

 // assertion will pass
 assertThat(Duration.ofMillis(250)).hasMillis(250);

 // assertion will fail
 assertThat(Duration.ofMillis(250)).hasMillis(700);

Parameters:

otherMillis - the expected milliseconds value

Returns:

this assertion object

Throws:

AssertionError - if the actual Duration is null

AssertionError - if the actual Duration does not have the given millis

Since:

3.15.0

hasSeconds

public SELF hasSeconds(long otherSeconds)

Verifies that the actual Duration has the given seconds.

Example :

 // assertion will pass
 assertThat(Duration.ofSeconds(250)).hasSeconds(250);

 // assertion will fail
 assertThat(Duration.ofSeconds(250)).hasSeconds(700);

Parameters:

otherSeconds - the expected seconds value

Returns:

this assertion object

Throws:

AssertionError - if the actual Duration is null

AssertionError - if the actual Duration does not have the given seconds

Since:

3.15.0

hasMinutes

public SELF hasMinutes(long otherMinutes)

Verifies that the actual Duration has the given minutes.

Example :

 // assertion will pass
 assertThat(Duration.ofMinutes(65)).hasMinutes(65);

 // assertion will fail
 assertThat(Duration.ofMinutes(65)).hasMinutes(25);

Parameters:

otherMinutes - the expected minutes value

Returns:

this assertion object

Throws:

AssertionError - if the actual Duration is null

AssertionError - if the actual Duration does not have the given minutes

Since:

3.15.0

hasHours

public SELF hasHours(long otherHours)

Verifies that the actual Duration has the given hours.

Example :

 // assertion will pass
 assertThat(Duration.ofHours(15)).hasHours(15);

 // assertion will fail
 assertThat(Duration.ofHours(15)).hasHours(5);

Parameters:

otherHours - the expected hours value

Returns:

this assertion object

Throws:

AssertionError - if the actual Duration is null

AssertionError - if the actual Duration does not have the given hours

Since:

3.15.0

hasDays

public SELF hasDays(long otherDays)

Verifies that the actual Duration has the given days.

Example :

 // assertion will pass
 assertThat(Duration.ofDays(5)).hasDays(5);

 // assertion will fail
 assertThat(Duration.ofDays(5)).hasDays(1);

Parameters:

otherDays - the expected days value

Returns:

this assertion object

Throws:

AssertionError - if the actual Duration is null

AssertionError - if the actual Duration does not have the given days

Since:

3.15.0

isCloseTo

public SELF isCloseTo(Duration expected,
                      Duration allowedDifference)

Verifies that the actual Duration is close to the given one within the given allowed difference (assertion succeeds if difference = allowed difference).

This is equivalent of: abs(actual - expected) <= allowed difference.

For readability you can use Assertions.withMarginOf(Duration) to express the allowed difference.

Examples:

 Duration twoMinutes = Duration.ofMinutes(2);
 // assertions succeed:
 assertThat(twoMinutes).isCloseTo(Duration.ofMinutes(3), Duration.ofMinutes(5));
 assertThat(twoMinutes).isCloseTo(Duration.ofMinutes(-3), Duration.ofMinutes(10));

 // assertion succeeds when difference is exactly equals to the allowed difference
 assertThat(twoMinutes).isCloseTo(Duration.ofMinutes(3), Duration.ofMinutes(1));
 assertThat(twoMinutes).isCloseTo(Duration.ofMinutes(-3), Duration.ofMinutes(5));

 // assertions using within syntactic sugar
 assertThat(twoMinutes).isCloseTo(Duration.ofMinutes(3), withMarginOf(Duration.ofMinutes(5)));
 assertThat(twoMinutes).isCloseTo(Duration.ofMinutes(3), withMarginOf(Duration.ofMinutes(1)));

 // assertions fail
 assertThat(twoMinutes).isCloseTo(Duration.ofMinutes(5), withMarginOf(Duration.ofMinutes(1)));
 assertThat(twoMinutes).isCloseTo(Duration.ofMinutes(-3), withMarginOf(Duration.ofMinutes(4)));

Parameters:

expected - the given Duration to compare to actual.

allowedDifference - a positive Duration to express the maximum allowed difference.

Returns:

this assertion object.

Throws:

IllegalArgumentException - if the expected Duration is null.

IllegalArgumentException - if the allowed difference Duration is null or negative.

AssertionError - if the actual value is not close enough to the given one.

Since:

3.18.0