Package org.assertj.core.api

Class AbstractInstantAssert<SELF extends AbstractInstantAssert<SELF>>

java.lang.Object
org.assertj.core.api.AbstractAssert<SELF,Instant>
org.assertj.core.api.AbstractTemporalAssert<SELF,Instant>
org.assertj.core.api.AbstractInstantAssert<SELF>
Type Parameters:
SELF - the "self" type of this assertion class.
All Implemented Interfaces:
Assert<SELF,Instant>, Descriptable<SELF>, ExtensionPoints<SELF,Instant>
Direct Known Subclasses:
InstantAssert
public class AbstractInstantAssert<SELF extends AbstractInstantAssert<SELF>> extends AbstractTemporalAssert<SELF,Instant>
Assertions for Instant type from new Date & Time API introduced in Java 8.
Since:
3.7.0

  • Constructor Details

    • AbstractInstantAssert

      protected AbstractInstantAssert(Instant actual, Class<?> selfType)
      Creates a new AbstractInstantAssert.
      Parameters:
      actual - the actual value to verify
      selfType - the "self type"

  • Method Details

    • isBefore

      public SELF isBefore(Instant other)
      Verifies that the actual Instant is strictly before the given one.

      Example : 

       assertThat(parse("2007-12-03T10:15:30.00Z")).isBefore(parse("2007-12-03T10:15:31.00Z"));
      Parameters:
      other - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if other Instant is null.
      AssertionError - if the actual Instant is not strictly before the given one.
      Since:
      3.7.0

    • isBefore

      public SELF isBefore(String instantAsString)
      Same assertion as isBefore(Instant) but the Instant is built from given String, which must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.

      Example : 

       // use String in comparison to avoid writing the code to perform the conversion
 assertThat(parse("2007-12-03T10:15:30.00Z").isBefore("2007-12-03T10:15:31.00Z");
      Parameters:
      instantAsString - String representing a Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if given String is null.
      DateTimeParseException - if given String can't be converted to a Instant.
      AssertionError - if the actual Instant is not strictly before the Instant built from given String.
      Since:
      3.7.0

    • isBeforeOrEqualTo

      public SELF isBeforeOrEqualTo(Instant other)
      Verifies that the actual Instant is before or equals to the given one.

      Example : 

       assertThat(parse("2007-12-03T10:15:30.00Z")).isBeforeOrEqualTo(parse("2007-12-03T10:15:30.00Z"))
                                .isBeforeOrEqualTo(parse("2007-12-03T10:15:31.00Z"));
      Parameters:
      other - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if other Instant is null.
      AssertionError - if the actual Instant is not before or equals to the given one.
      Since:
      3.7.0

    • isBeforeOrEqualTo

      public SELF isBeforeOrEqualTo(String instantAsString)
      Same assertion as isBeforeOrEqualTo(Instant) but the Instant is built from given String, which must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.

      Example : 

       // use String in comparison to avoid conversion
 assertThat(parse("2007-12-03T10:15:30.00Z")).isBeforeOrEqualTo("2007-12-03T10:15:30.00Z")
                                .isBeforeOrEqualTo("2007-12-03T10:15:31.00Z");
      Parameters:
      instantAsString - String representing a Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if given String is null.
      DateTimeParseException - if given String can't be converted to a Instant.
      AssertionError - if the actual Instant is not before or equals to the Instant built from given String.
      Since:
      3.7.0

    • isAfterOrEqualTo

      public SELF isAfterOrEqualTo(Instant other)
      Verifies that the actual Instant is after or equals to the given one.

      Example : 

       assertThat(parse("2007-12-03T10:15:30.00Z")).isAfterOrEqualTo(parse("2007-12-03T10:15:30.00Z"))
                                .isAfterOrEqualTo(parse("2007-12-03T10:15:27.00Z"));
      Parameters:
      other - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if other Instant is null.
      AssertionError - if the actual Instant is not after or equals to the given one.
      Since:
      3.7.0

    • isAfterOrEqualTo

      public SELF isAfterOrEqualTo(String instantAsString)
      Same assertion as isAfterOrEqualTo(Instant) but the Instant is built from given String, which must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.

      Example : 

       // use String in comparison to avoid conversion
 assertThat(parse("2007-12-03T10:15:30.00Z")).isAfterOrEqualTo("2007-12-03T10:15:30.00Z")
                                .isAfterOrEqualTo("2007-12-03T10:15:27.00Z");
      Parameters:
      instantAsString - String representing a Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if given String is null.
      DateTimeParseException - if given String can't be converted to a Instant.
      AssertionError - if the actual Instant is not after or equals to the Instant built from given String.
      Since:
      3.7.0

    • isAfter

      public SELF isAfter(Instant other)
      Verifies that the actual Instant is strictly after the given one.

      Example : 

       assertThat(parse("2007-12-03T10:15:30.00Z").isAfter(parse("2007-12-03T10:15:27.00Z"));
      Parameters:
      other - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if other Instant is null.
      AssertionError - if the actual Instant is not strictly after the given one.
      Since:
      3.7.0

    • isAfter

      public SELF isAfter(String instantAsString)
      Same assertion as isAfter(Instant) but the Instant is built from given a String that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.

      Example : 

       // use String in comparison to avoid conversion
 assertThat(parse("2007-12-03T10:15:30.00Z")).isAfter("2007-12-03T10:15:27.00Z");
      Parameters:
      instantAsString - String representing a Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if given String is null.
      DateTimeParseException - if given String can't be converted to a Instant.
      AssertionError - if the actual Instant is not strictly after the Instant built from given String.
      Since:
      3.7.0

    • isEqualTo

      public SELF isEqualTo(String instantAsString)
      Same assertion as AbstractAssert.isEqualTo(Object) (where Object is expected to be Instant) but here you pass Instant String representation that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.

      Example : 

       // use directly String in comparison to avoid writing the code to perform the conversion
 assertThat(parse("2007-12-03T10:15:30.00Z")).isEqualTo("2007-12-03T10:15:30.00Z");
      Parameters:
      instantAsString - String representing a Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if given String is null.
      DateTimeParseException - if given String can't be converted to a Instant.
      AssertionError - if the actual Instant is not equal to the Instant built from given String.
      Since:
      3.7.0

    • isNotEqualTo

      public SELF isNotEqualTo(String instantAsString)
      Same assertion as AbstractAssert.isNotEqualTo(Object) (where Object is expected to be Instant) but here you pass Instant String representation that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.

      Example : 

       // use directly String in comparison to avoid writing the code to perform the conversion
 assertThat(parse("2007-12-03T10:15:30.00Z")).isNotEqualTo("2007-12-03T10:15:00.00Z");
      Parameters:
      instantAsString - String representing a Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if given String is null.
      DateTimeParseException - if given String can't be converted to a Instant.
      AssertionError - if the actual Instant is equal to the Instant built from given String.
      Since:
      3.7.0

    • isIn

      public SELF isIn(String... instantsAsString)
      Same assertion as AbstractAssert.isIn(Object...) (where Objects are expected to be Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.

      Example : 

       // use String based representation of Instant
 assertThat(parse("2007-12-03T10:15:30.00Z")).isIn("2007-12-03T10:15:30.00Z", "2007-12-03T10:15:35.00Z");
      Parameters:
      instantsAsString - String array representing Instants.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if given Strings are null or empty.
      DateTimeParseException - if one of the given String can't be converted to a Instant.
      AssertionError - if the actual Instant is not in the Instants built from given Strings.
      Since:
      3.7.0

    • isNotIn

      public SELF isNotIn(String... instantsAsString)
      Same assertion as AbstractAssert.isNotIn(Object...) (where Objects are expected to be Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.

      Example : 

       // use String based representation of Instant
 assertThat(parse("2007-12-03T10:15:30.00Z")).isNotIn("2007-12-03T10:15:35.00Z", "2007-12-03T10:15:25.00Z");
      Parameters:
      instantsAsString - Array of String representing a Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      IllegalArgumentException - if given Strings are null or empty.
      DateTimeParseException - if one of the given String can't be converted to a Instant.
      AssertionError - if the actual Instant is in the Instants built from given Strings.
      Since:
      3.7.0

    • isInThePast

      public SELF isInThePast()
      Verifies that the actual Instant is strictly in the past.

      Example: 

       // assertion succeeds:
 assertThat(Instant.now().minusSeconds(60)).isInThePast();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      AssertionError - if the actual Instant is not in the past.
      Since:
      3.25.0

    • isInTheFuture

      public SELF isInTheFuture()
      Verifies that the actual Instant is strictly in the future.

      Example: 

       // assertion succeeds:
 assertThat(Instant.now().plusSeconds(60)).isInTheFuture();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Instant is null.
      AssertionError - if the actual Instant is not in the future.
      Since:
      3.25.0

    • isBetween

      public SELF isBetween(Instant startInclusive, Instant endInclusive)
      Verifies that the actual Instant is in the [start, end] period (start and end included).

      Example: 

       Instant instant = Instant.now();

 // assertions succeed:
 assertThat(instant).isBetween(instant.minusSeconds(1), instant.plusSeconds(1))
                    .isBetween(instant, instant.plusSeconds(1))
                    .isBetween(instant.minusSeconds(1), instant)
                    .isBetween(instant, instant);

 // assertions fail:
 assertThat(instant).isBetween(instant.minusSeconds(10), instant.minusSeconds(1));
 assertThat(instant).isBetween(instant.plusSeconds(1), instant.plusSeconds(10));
      Parameters:
      startInclusive - the start value (inclusive), expected not to be null.
      endInclusive - the end value (inclusive), expected not to be null.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      NullPointerException - if start value is null.
      NullPointerException - if end value is null.
      AssertionError - if the actual value is not in [start, end] range.
      Since:
      3.7.1

    • isBetween

      public SELF isBetween(String startInclusive, String endInclusive)
      Same assertion as isBetween(Instant, Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.

      Example: 

       Instant firstOfJanuary2000 = Instant.parse("2000-01-01T00:00:00.00Z");

 // assertions succeed:
 assertThat(firstOfJanuary2000).isBetween("1999-01-01T00:00:00.00Z", "2001-01-01T00:00:00.00Z")
                               .isBetween("2000-01-01T00:00:00.00Z", "2001-01-01T00:00:00.00Z")
                               .isBetween("1999-01-01T00:00:00.00Z", "2000-01-01T00:00:00.00Z")
                               .isBetween("2000-01-01T00:00:00.00Z", "2000-01-01T00:00:00.00Z");

 // assertion fails:
 assertThat(firstOfJanuary2000).isBetween("1999-01-01T00:00:00.00Z", "1999-12-31T23:59:59.59Z");
      Parameters:
      startInclusive - the start value (inclusive), expected not to be null.
      endInclusive - the end value (inclusive), expected not to be null.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      NullPointerException - if start value is null.
      NullPointerException - if end value is null.
      DateTimeParseException - if any of the given String can't be converted to a Instant.
      AssertionError - if the actual value is not in [start, end] range.
      Since:
      3.7.1

    • isStrictlyBetween

      public SELF isStrictlyBetween(Instant startExclusive, Instant endExclusive)
      Verifies that the actual Instant is in the ]start, end[ period (start and end excluded).

      Example: 

       Instant instant = Instant.now();

 // assertion succeeds:
 assertThat(instant).isStrictlyBetween(instant.minusSeconds(1), instant.plusSeconds(1));

 // assertions fail:
 assertThat(instant).isStrictlyBetween(instant.minusSeconds(10), instant.minusSeconds(1));
 assertThat(instant).isStrictlyBetween(instant.plusSeconds(1), instant.plusSeconds(10));
 assertThat(instant).isStrictlyBetween(instant, instant.plusSeconds(1));
 assertThat(instant).isStrictlyBetween(instant.minusSeconds(1), instant);
      Parameters:
      startExclusive - the start value (exclusive), expected not to be null.
      endExclusive - the end value (exclusive), expected not to be null.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      NullPointerException - if start value is null.
      NullPointerException - if end value is null.
      AssertionError - if the actual value is not in ]start, end[ range.
      Since:
      3.7.1

    • isStrictlyBetween

      public SELF isStrictlyBetween(String startExclusive, String endExclusive)
      Same assertion as isStrictlyBetween(Instant, Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.

      Example: 

       Instant firstOfJanuary2000 = Instant.parse("2000-01-01T00:00:00.00Z");

 // assertion succeeds:
 assertThat(firstOfJanuary2000).isStrictlyBetween("1999-01-01T00:00:00.00Z", "2001-01-01T00:00:00.00Z");

 // assertions fail:
 assertThat(firstOfJanuary2000).isStrictlyBetween("1999-01-01T00:00:00.00Z", "1999-12-31T23:59:59.59Z");
 assertThat(firstOfJanuary2000).isStrictlyBetween("2000-01-01T00:00:00.00Z", "2001-01-01T00:00:00.00Z");
 assertThat(firstOfJanuary2000).isStrictlyBetween("1999-01-01T00:00:00.00Z", "2000-01-01T00:00:00.00Z");
      Parameters:
      startExclusive - the start value (exclusive), expected not to be null.
      endExclusive - the end value (exclusive), expected not to be null.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      NullPointerException - if start value is null.
      NullPointerException - if end value is null.
      DateTimeParseException - if any of the given String can't be converted to a Instant.
      AssertionError - if the actual value is not in ]start, end[ range.
      Since:
      3.7.1

    • parse

      protected Instant parse(String instantAsString)
      Description copied from class: AbstractTemporalAssert
      Obtains an instance of TEMPORAL from a string representation in ISO date format.
      Specified by:
      parse in class AbstractTemporalAssert<SELF extends AbstractInstantAssert<SELF>,Instant>
      Parameters:
      instantAsString - the string to parse, not null
      Returns:
      the parsed TEMPORAL, not null