Package org.assertj.core.api

Class AbstractDurationAssert<SELF extends AbstractDurationAssert<SELF>>

    • 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