Class AbstractInstantAssert<SELF extends AbstractInstantAssert<SELF>>

  • Type Parameters:
    SELF - the "self" type of this assertion class.
    All Implemented Interfaces:
    Assert<SELF,​java.time.Instant>, Descriptable<SELF>, ExtensionPoints<SELF,​java.time.Instant>
    Direct Known Subclasses:
    InstantAssert

    public class AbstractInstantAssert<SELF extends AbstractInstantAssert<SELF>>
    extends AbstractTemporalAssert<SELF,​java.time.Instant>
    Assertions for Instant type from new Date & Time API introduced in Java 8.
    Since:
    3.7.0
    • Constructor Detail

      • AbstractInstantAssert

        protected AbstractInstantAssert​(java.time.Instant actual,
                                        java.lang.Class<?> selfType)
        Creates a new AbstractInstantAssert.
        Parameters:
        selfType - the "self type"
        actual - the actual value to verify
    • Method Detail

      • isBefore

        public SELF isBefore​(java.time.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if other Instant is null.
        java.lang.AssertionError - if the actual Instant is not strictly before the given one.
        Since:
        3.7.0
      • isBefore

        public SELF isBefore​(java.lang.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if given String is null.
        java.time.format.DateTimeParseException - if given String can't be converted to a Instant.
        java.lang.AssertionError - if the actual Instant is not strictly before the Instant built from given String.
        Since:
        3.7.0
      • isBeforeOrEqualTo

        public SELF isBeforeOrEqualTo​(java.time.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if other Instant is null.
        java.lang.AssertionError - if the actual Instant is not before or equals to the given one.
        Since:
        3.7.0
      • isBeforeOrEqualTo

        public SELF isBeforeOrEqualTo​(java.lang.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if given String is null.
        java.time.format.DateTimeParseException - if given String can't be converted to a Instant.
        java.lang.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​(java.time.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if other Instant is null.
        java.lang.AssertionError - if the actual Instant is not after or equals to the given one.
        Since:
        3.7.0
      • isAfterOrEqualTo

        public SELF isAfterOrEqualTo​(java.lang.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if given String is null.
        java.time.format.DateTimeParseException - if given String can't be converted to a Instant.
        java.lang.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​(java.time.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if other Instant is null.
        java.lang.AssertionError - if the actual Instant is not strictly after the given one.
        Since:
        3.7.0
      • isAfter

        public SELF isAfter​(java.lang.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if given String is null.
        java.time.format.DateTimeParseException - if given String can't be converted to a Instant.
        java.lang.AssertionError - if the actual Instant is not strictly after the Instant built from given String.
        Since:
        3.7.0
      • isEqualTo

        public SELF isEqualTo​(java.lang.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if given String is null.
        java.time.format.DateTimeParseException - if given String can't be converted to a Instant.
        java.lang.AssertionError - if the actual Instant is not equal to the Instant built from given String.
        Since:
        3.7.0
      • isNotEqualTo

        public SELF isNotEqualTo​(java.lang.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if given String is null.
        java.time.format.DateTimeParseException - if given String can't be converted to a Instant.
        java.lang.AssertionError - if the actual Instant is equal to the Instant built from given String.
        Since:
        3.7.0
      • isIn

        public SELF isIn​(java.lang.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if given Strings are null or empty.
        java.time.format.DateTimeParseException - if one of the given String can't be converted to a Instant.
        java.lang.AssertionError - if the actual Instant is not in the Instants built from given Strings.
        Since:
        3.7.0
      • isNotIn

        public SELF isNotIn​(java.lang.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:
        java.lang.AssertionError - if the actual Instant is null.
        java.lang.IllegalArgumentException - if given Strings are null or empty.
        java.time.format.DateTimeParseException - if one of the given String can't be converted to a Instant.
        java.lang.AssertionError - if the actual Instant is in the Instants built from given Strings.
        Since:
        3.7.0
      • isBetween

        public SELF isBetween​(java.time.Instant startInclusive,
                              java.time.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:
        java.lang.AssertionError - if the actual value is null.
        java.lang.NullPointerException - if start value is null.
        java.lang.NullPointerException - if end value is null.
        java.lang.AssertionError - if the actual value is not in [start, end] range.
        Since:
        3.7.1
      • isBetween

        public SELF isBetween​(java.lang.String startInclusive,
                              java.lang.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:
        java.lang.AssertionError - if the actual value is null.
        java.lang.NullPointerException - if start value is null.
        java.lang.NullPointerException - if end value is null.
        java.time.format.DateTimeParseException - if any of the given String can't be converted to a Instant.
        java.lang.AssertionError - if the actual value is not in [start, end] range.
        Since:
        3.7.1
      • isStrictlyBetween

        public SELF isStrictlyBetween​(java.time.Instant startExclusive,
                                      java.time.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:
        java.lang.AssertionError - if the actual value is null.
        java.lang.NullPointerException - if start value is null.
        java.lang.NullPointerException - if end value is null.
        java.lang.AssertionError - if the actual value is not in ]start, end[ range.
        Since:
        3.7.1
      • isStrictlyBetween

        public SELF isStrictlyBetween​(java.lang.String startExclusive,
                                      java.lang.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:
        java.lang.AssertionError - if the actual value is null.
        java.lang.NullPointerException - if start value is null.
        java.lang.NullPointerException - if end value is null.
        java.time.format.DateTimeParseException - if any of the given String can't be converted to a Instant.
        java.lang.AssertionError - if the actual value is not in ]start, end[ range.
        Since:
        3.7.1
      • parse

        protected java.time.Instant parse​(java.lang.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>,​java.time.Instant>
        Parameters:
        instantAsString - the string to parse, not null
        Returns:
        the parsed TEMPORAL, not null
      • convertToInstantArray

        private static java.lang.Object[] convertToInstantArray​(java.lang.String[] instantsAsString)
      • assertNotNull

        private static void assertNotNull​(AssertionInfo info,
                                          java.time.Instant actual)
      • checkIsNotNullAndNotEmpty

        private void checkIsNotNullAndNotEmpty​(java.lang.Object[] values)
      • assertInstantAsStringParameterIsNotNull

        private static void assertInstantAsStringParameterIsNotNull​(java.lang.String instantAsString)
        Check that the Instant string representation to compare actual Instant to is not null, otherwise throws a IllegalArgumentException with an explicit message
        Parameters:
        instantAsString - String representing the Instant to compare actual with
        Throws:
        java.lang.IllegalArgumentException - with an explicit message if the given String is null
      • assertInstantParameterIsNotNull

        private static void assertInstantParameterIsNotNull​(java.time.Instant instant)