Package org.assertj.core.api

Class AbstractZonedDateTimeAssert<SELF extends AbstractZonedDateTimeAssert<SELF>>

    • Constructor Detail

      • AbstractZonedDateTimeAssert

        protected AbstractZonedDateTimeAssert​(ZonedDateTime actual,
                                      Class<?> selfType)

    • Method Detail

      • isBefore

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

        Comparison is done on ZonedDateTime's instant (i.e. ChronoZonedDateTime.toEpochSecond())

        Example : 

         assertThat(parse("2000-01-01T23:59:59Z")).isBefore(parse("2000-01-02T00:00:00Z"));
        Parameters:
        other - the given ZonedDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        IllegalArgumentException - if other ZonedDateTime is null.
        AssertionError - if the actual ZonedDateTime is not strictly before the given one.

      • isBeforeOrEqualTo

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

        Comparison is done on ZonedDateTime's instant (i.e. ChronoZonedDateTime.toEpochSecond())

        Example : 

         assertThat(parse("2000-01-01T23:59:59Z")).isBeforeOrEqualTo(parse("2000-01-01T23:59:59Z"))
                                          .isBeforeOrEqualTo(parse("2000-01-02T00:00:00Z"));
        Parameters:
        other - the given ZonedDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        IllegalArgumentException - if other ZonedDateTime is null.
        AssertionError - if the actual ZoneDateTime is not before or equals to the given one.

      • isAfterOrEqualTo

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

        Comparison is done on ZonedDateTime's instant (i.e. ChronoZonedDateTime.toEpochSecond())

        Example : 

         assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo(parse("2000-01-01T00:00:00Z"))
                                          .isAfterOrEqualTo(parse("1999-12-31T23:59:59Z"));
        Parameters:
        other - the given ZonedDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        IllegalArgumentException - if other ZonedDateTime is null.
        AssertionError - if the actual ZonedDateTime is not after or equals to the given one.

      • isAfter

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

        Comparison is done on ZonedDateTime's instant (i.e. ChronoZonedDateTime.toEpochSecond())

        Example : 

         assertThat(parse("2000-01-01T00:00:00Z")).isAfter(parse("1999-12-31T23:59:59Z"));
        Parameters:
        other - the given ZonedDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        IllegalArgumentException - if other ZonedDateTime is null.
        AssertionError - if the actual ZonedDateTime is not strictly after the given one.

      • isEqualToIgnoringNanos

        public SELF isEqualToIgnoringNanos​(ZonedDateTime other)
        Verifies that actual and given ZonedDateTime have same year, month, day, hour, minute and second fields, (nanosecond fields are ignored in comparison).

        Note that given ZonedDateTime is converted in the actual's ZoneId before comparison.

        Assertion can fail with dateTimes in same chronological nanosecond time window, e.g :

        2000-01-01T00:00:01.000000000 and 2000-01-01T00:00:00.999999999.

        Assertion fails as second fields differ even if time difference is only 1ns.

        Code example : 

         // successful assertions
 ZonedDateTime dateTime1 = ZonedDateTime.of(2000, 1, 1, 0, 0, 1, 0);
 ZonedDateTime dateTime2 = ZonedDateTime.of(2000, 1, 1, 0, 0, 1, 456);
 assertThat(dateTime1).isEqualToIgnoringNanos(dateTime2);

 // failing assertions (even if time difference is only 1ms)
 ZonedDateTime dateTimeA = ZonedDateTime.of(2000, 1, 1, 0, 0, 1, 0);
 ZonedDateTime dateTimeB = ZonedDateTime.of(2000, 1, 1, 0, 0, 0, 999999999);
 assertThat(dateTimeA).isEqualToIgnoringNanos(dateTimeB);
        Parameters:
        other - the given ZonedDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        IllegalArgumentException - if other ZonedDateTime is null.
        AssertionError - if the actual ZonedDateTime is are not equal with nanoseconds ignored.

      • isEqualToIgnoringSeconds

        public SELF isEqualToIgnoringSeconds​(ZonedDateTime other)
        Verifies that actual and given ZonedDateTime have same year, month, day, hour and minute fields (second and nanosecond fields are ignored in comparison).

        Note that given ZonedDateTime is converted in the actual's ZoneId before comparison.

        Assertion can fail with ZonedDateTimes in same chronological second time window, e.g :

        2000-01-01T00:01:00.000 and 2000-01-01T00:00:59.000.

        Assertion fails as minute fields differ even if time difference is only 1ns.

        Code example : 

         // successful assertions
 ZonedDateTime dateTime1 = ZonedDateTime.of(2000, 1, 1, 23, 50, 0, 0);
 ZonedDateTime dateTime2 = ZonedDateTime.of(2000, 1, 1, 23, 50, 10, 456);
 assertThat(dateTime1).isEqualToIgnoringSeconds(dateTime2);

 // failing assertions (even if time difference is only 1ns)
 ZonedDateTime dateTimeA = ZonedDateTime.of(2000, 1, 1, 23, 50, 00, 0);
 ZonedDateTime dateTimeB = ZonedDateTime.of(2000, 1, 1, 23, 49, 59, 999999999);
 assertThat(dateTimeA).isEqualToIgnoringSeconds(dateTimeB);
        Parameters:
        other - the given ZonedDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        IllegalArgumentException - if other ZonedDateTime is null.
        AssertionError - if the actual ZonedDateTime is are not equal with second and nanosecond fields ignored.

      • isEqualToIgnoringMinutes

        public SELF isEqualToIgnoringMinutes​(ZonedDateTime other)
        Verifies that actual and given ZonedDateTime have same year, month, day and hour fields (minute, second and nanosecond fields are ignored in comparison).

        Note that given ZonedDateTime is converted in the actual's ZoneId before comparison.

        Assertion can fail with dateTimes in same chronological second time window, e.g :

        2000-01-01T01:00:00.000 and 2000-01-01T00:59:59.000.

        Time difference is only 1s but hour fields differ.

        Code example : 

         // successful assertions
 ZonedDateTime dateTime1 = ZonedDateTime.of(2000, 1, 1, 23, 50, 0, 0);
 ZonedDateTime dateTime2 = ZonedDateTime.of(2000, 1, 1, 23, 00, 2, 7);
 assertThat(dateTime1).isEqualToIgnoringMinutes(dateTime2);

 // failing assertions (even if time difference is only 1ms)
 ZonedDateTime dateTimeA = ZonedDateTime.of(2000, 1, 1, 01, 00, 00, 000);
 ZonedDateTime dateTimeB = ZonedDateTime.of(2000, 1, 1, 00, 59, 59, 999);
 assertThat(dateTimeA).isEqualToIgnoringMinutes(dateTimeB);
        Parameters:
        other - the given ZonedDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        IllegalArgumentException - if other ZonedDateTime is null.
        AssertionError - if the actual ZonedDateTime is are not equal ignoring minute, second and nanosecond fields.

      • isEqualToIgnoringHours

        public SELF isEqualToIgnoringHours​(ZonedDateTime other)
        Verifies that actual and given ZonedDateTime have same year, month and day fields (hour, minute, second and nanosecond fields are ignored in comparison).

        Note that given ZonedDateTime is converted in the actual's ZoneId before comparison.

        Assertion can fail with dateTimes in same chronological minute time window, e.g :

        2000-01-01T23:59:00.000 and 2000-01-02T00:00:00.000.

        Time difference is only 1min but day fields differ.

        Code example : 

         // successful assertions
 ZonedDateTime dateTime1 = ZonedDateTime.of(2000, 1, 1, 23, 59, 59, 999, ZoneId.systemDefault());
 ZonedDateTime dateTime2 = ZonedDateTime.of(2000, 1, 1, 00, 00, 00, 000, ZoneId.systemDefault());
 assertThat(dateTime1).isEqualToIgnoringHours(dateTime2);

 // failing assertions (even if time difference is only 1ms)
 ZonedDateTime dateTimeA = ZonedDateTime.of(2000, 1, 2, 00, 00, 00, 000, ZoneId.systemDefault());
 ZonedDateTime dateTimeB = ZonedDateTime.of(2000, 1, 1, 23, 59, 59, 999, ZoneId.systemDefault());
 assertThat(dateTimeA).isEqualToIgnoringHours(dateTimeB);
        Parameters:
        other - the given ZonedDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        IllegalArgumentException - if other ZonedDateTime is null.
        AssertionError - if the actual ZonedDateTime is are not equal with second and nanosecond fields ignored.

      • isEqualTo

        public SELF isEqualTo​(ZonedDateTime expected)
        Verifies that the actual ZonedDateTime is equal to the given one in the actual's ZoneId.

        Example : 

         ZonedDateTime firstOfJanuary2000InUTC = ZonedDateTime.parse("2000-01-01T00:00:00Z");
 assertThat(firstOfJanuary2000InUTC).isEqualTo(parse("2000-01-01T00:00:00Z"));
 
 // the following assertion succeeds as ZonedDateTime are compared in actual's time zone
 // 2000-01-01T01:00:00+01:00 = 2000-01-01T00:00:00 in UTC
 assertThat(firstOfJanuary2000InUTC).isEqualTo(parse("2000-01-01T01:00:00+01:00"));
        Parameters:
        expected - the given value to compare the actual value to.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is not equal to the ZonedDateTime in the actual ZonedDateTime's java.time.ZoneId.

      • isEqualTo

        public SELF isEqualTo​(String dateTimeAsString)
        Same assertion as isEqualTo(ZonedDateTime) but the ZonedDateTime is built from given String, which must follow ISO date-time format to allow calling ZonedDateTime.parse(CharSequence, DateTimeFormatter) method.

        Note that the ZonedDateTime created from the given String is built in the ZoneId of the ZonedDateTime to check.

        Example : 

         // use String in comparison to avoid writing the code to perform the conversion
 ZonedDateTime firstOfJanuary2000InUTC = ZonedDateTime.parse("2000-01-01T00:00:00Z");
 assertThat(firstOfJanuary2000InUTC).isEqualTo("2000-01-01T00:00:00Z");
 
 // the following assertion succeeds as ZonedDateTime are compared in actual's time zone
 // 2000-01-01T01:00:00+01:00 = 2000-01-01T00:00:00 in UTC
 assertThat(firstOfJanuary2000InUTC).isEqualTo("2000-01-01T01:00:00+01:00");
        Parameters:
        dateTimeAsString - String representing a ZonedDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        IllegalArgumentException - if given String is null or can't be converted to a ZonedDateTime.
        AssertionError - if the actual ZonedDateTime is not equal to the ZonedDateTime built from given String.

      • isNotEqualTo

        public SELF isNotEqualTo​(ZonedDateTime expected)
        Verifies that the actual value is not equal to the given one in the actual ZonedDateTime's java.time.ZoneId.

        Example : 

         assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo(parse("2000-01-15T00:00:00Z"));
        Parameters:
        expected - the given value to compare the actual value to.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is equal to the ZonedDateTime in the actual ZonedDateTime's java.time.ZoneId.

      • isIn

        public SELF isIn​(ZonedDateTime... expected)
        Verifies that the actual ZonedDateTime is equal to one of the given ZonedDateTime in the actual ZonedDateTime's ZoneId.

        Example : 

         assertThat(parse("2000-01-01T00:00:00Z")).isIn(parse("1999-12-31T23:59:59Z"),
                                                parse("2000-01-01T00:00:00Z"));
        Parameters:
        expected - the given ZonedDateTimes to compare the actual value to.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        AssertionError - if the actual ZonedDateTime is not in the given ZonedDateTimes.

      • isNotIn

        public SELF isNotIn​(ZonedDateTime... expected)
        Verifies that the actual ZonedDateTime is equal to one of the given ZonedDateTime in the actual ZonedDateTime's ZoneId.

        Example : 

         assertThat(parse("2000-01-01T00:00:00Z")).isNotIn(parse("1999-12-31T23:59:59Z"),
                                                   parse("2000-01-02T00:00:00Z"));
        Parameters:
        expected - the given ZonedDateTimes to compare the actual value to.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual ZonedDateTime is null.
        AssertionError - if the actual ZonedDateTime is not in the given ZonedDateTimes.

      • isBetween

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

        Example: 

         ZonedDateTime zonedDateTime = ZonedDateTime.now();
 
 // assertions succeed:
 assertThat(zonedDateTime).isBetween(zonedDateTime.minusSeconds(1), zonedDateTime.plusSeconds(1))
                           .isBetween(zonedDateTime, zonedDateTime.plusSeconds(1))
                           .isBetween(zonedDateTime.minusSeconds(1), zonedDateTime)
                           .isBetween(zonedDateTime, zonedDateTime);
 
 // assertions fail:
 assertThat(zonedDateTime).isBetween(zonedDateTime.minusSeconds(10), zonedDateTime.minusSeconds(1));
 assertThat(zonedDateTime).isBetween(zonedDateTime.plusSeconds(1), zonedDateTime.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] period.
        Since:
        3.7.1

      • isBetween

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

        Example: 

         ZonedDateTime firstOfJanuary2000 = ZonedDateTime.parse("2000-01-01T00:00:00Z");
 
 // assertions succeed:
 assertThat(firstOfJanuary2000).isBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:01Z")         
                               .isBetween("2000-01-01T00:00:00Z", "2000-01-01T00:00:01Z")         
                               .isBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:00Z")         
                               .isBetween("2000-01-01T00:00:00Z", "2000-01-01T00:00:00Z");
                               
 // assertion fails:
 assertThat(firstOfJanuary2000).isBetween("1999-01-01T00:00:01Z", "1999-12-31T23: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 ZonedDateTime.
        AssertionError - if the actual value is not in [start, end] period.
        Since:
        3.7.1

      • isStrictlyBetween

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

        Example: 

         ZonedDateTime zonedDateTime = ZonedDateTime.now();
 
 // assertion succeeds:
 assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime.minusSeconds(1), zonedDateTime.plusSeconds(1));
 
 // assertions fail:
 assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime.minusSeconds(10), zonedDateTime.minusSeconds(1));
 assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime.plusSeconds(1), zonedDateTime.plusSeconds(10));
 assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime, zonedDateTime.plusSeconds(1));
 assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime.minusSeconds(1), zonedDateTime);
        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[ period.
        Since:
        3.7.1

      • isStrictlyBetween

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

        Example: 

         ZonedDateTime firstOfJanuary2000 = ZonedDateTime.parse("2000-01-01T00:00:00Z");
 
 // assertion succeeds:
 assertThat(firstOfJanuary2000).isStrictlyBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:01Z");
 
 // assertions fail:
 assertThat(firstOfJanuary2000).isStrictlyBetween("1999-01-01T00:00:01Z", "1999-12-31T23:59:59Z");
 assertThat(firstOfJanuary2000).isStrictlyBetween("2000-01-01T00:00:00Z", "2000-01-01T00:00:01Z");
 assertThat(firstOfJanuary2000).isStrictlyBetween("1999-12-31T23:59:59Z", "2000-01-01T00: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 ZonedDateTime.
        AssertionError - if the actual value is not in ]start, end[ period.
        Since:
        3.7.1

      • convertToDateTimeArray

        private ZonedDateTime[] convertToDateTimeArray​(String... dateTimesAsString)

      • checkIsNotNullAndNotEmpty

        private void checkIsNotNullAndNotEmpty​(Object[] values)

      • assertDateTimeAsStringParameterIsNotNull

        private static void assertDateTimeAsStringParameterIsNotNull​(String dateTimeAsString)
        Check that the ZonedDateTime string representation to compare actual ZonedDateTime to is not null, otherwise throws a IllegalArgumentException with an explicit message
        Parameters:
        dateTimeAsString - String representing the ZonedDateTime to compare actual with
        Throws:
        IllegalArgumentException - with an explicit message if the given String is null

      • areEqualIgnoringNanos

        private static boolean areEqualIgnoringNanos​(ZonedDateTime actual,
                                             ZonedDateTime other)
        Returns true if both datetime are in the same year, month and day of month, hour, minute and second, false otherwise.
        Parameters:
        actual - the actual datetime. expected not be null
        other - the other datetime. expected not be null
        Returns:
        true if both datetime are in the same year, month and day of month, hour, minute and second, false otherwise.

      • areEqualIgnoringSeconds

        private static boolean areEqualIgnoringSeconds​(ZonedDateTime actual,
                                               ZonedDateTime other)
        Returns true if both datetime are in the same year, month, day of month, hour and minute, false otherwise.
        Parameters:
        actual - the actual datetime. expected not be null
        other - the other datetime. expected not be null
        Returns:
        true if both datetime are in the same year, month, day of month, hour and minute, false otherwise.

      • areEqualIgnoringMinutes

        private static boolean areEqualIgnoringMinutes​(ZonedDateTime actual,
                                               ZonedDateTime other)
        Returns true if both datetime are in the same year, month, day of month and hour, false otherwise.
        Parameters:
        actual - the actual datetime. expected not be null
        other - the other datetime. expected not be null
        Returns:
        true if both datetime are in the same year, month, day of month and hour, false otherwise.

      • haveSameYearMonthAndDayOfMonth

        private static boolean haveSameYearMonthAndDayOfMonth​(ZonedDateTime actual,
                                                      ZonedDateTime other)
        Returns true if both datetime are in the same year, month and day of month, false otherwise.
        Parameters:
        actual - the actual datetime. expected not be null
        other - the other datetime. expected not be null
        Returns:
        true if both datetime are in the same year, month and day of month, false otherwise

      • haveSameYearAndMonth

        private static boolean haveSameYearAndMonth​(ZonedDateTime actual,
                                            ZonedDateTime other)
        Returns true if both datetime are in the same year and month, false otherwise.
        Parameters:
        actual - the actual datetime. expected not be null
        other - the other datetime. expected not be null
        Returns:
        true if both datetime are in the same year and month, false otherwise

      • haveSameYear

        private static boolean haveSameYear​(ZonedDateTime actual,
                                    ZonedDateTime other)
        Returns true if both datetime are in the same year, false otherwise.
        Parameters:
        actual - the actual datetime. expected not be null
        other - the other datetime. expected not be null
        Returns:
        true if both datetime are in the same year, false otherwise