Package 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

  • Constructor Details

    • AbstractDurationAssert

      protected AbstractDurationAssert(Duration duration, Class<?> selfType)
      Creates a new AbstractDurationAssert
      Parameters:
      duration - the actual value to verify
      selfType - the "self type"

  • Method Details

    • 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