Package org.assertj.core.api

Class AbstractOffsetDateTimeAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>>

    • Field Detail

      • NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE

        public static final String NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE
        See Also:
        Constant Field Values

    • Constructor Detail

      • AbstractOffsetDateTimeAssert

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

    • Method Detail

      • isBefore

        public SELF isBefore​(OffsetDateTime other)
        Verifies that the actual OffsetDateTime is strictly before the given one according to the comparator in use.

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         // assertion succeeds
 assertThat(parse("2000-01-01T01:00:00Z")).isBefore(parse("2020-01-01T01:00:00Z"));

 // assertions fail
 assertThat(parse("2000-01-01T01:00:00Z")).isBefore(parse("1999-01-01T01:00:00Z"));
 assertThat(parse("2000-01-01T01:00:00Z")).isBefore(parse("2000-01-01T01:00:00Z"));
 // fails because both OffsetDateTime refer to the same instant (on different offsets)
 assertThat(parse("2000-01-01T01:00:00Z")).isBefore(parse("2000-01-01T00:00:00-01:00"));

 // succeeds because both OffsetDateTime refer to the same instant and OffsetDateTime natural comparator is used.
 assertThat(parse("2000-01-02T00:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isBefore(parse("2000-01-02T01:00:00+01:00"));
        Parameters:
        other - the given OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if other OffsetDateTime is null.
        AssertionError - if the actual OffsetDateTime is not strictly before the given one according to the comparator in use.

      • isBefore

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

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         // assertion succeeds
 assertThat(parse("2000-01-01T01:00:00Z")).isBefore("2020-01-01T01:00:00Z");

 // assertions fail
 assertThat(parse("2000-01-01T01:00:00Z")).isBefore("1999-01-01T01:00:00Z");
 assertThat(parse("2000-01-01T01:00:00Z")).isBefore("2000-01-01T01:00:00Z");
 // fails because both OffsetDateTime refer to the same instant (on different offsets)
 assertThat(parse("2000-01-01T01:00:00Z")).isBefore("2000-01-01T00:00:00-01:00");

 // succeeds because both OffsetDateTime refer to the same instant and OffsetDateTime natural comparator is used.
 assertThat(parse("2000-01-02T00:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isBefore("2000-01-02T01:00:00+01:00");
        Parameters:
        offsetDateTimeAsString - String representing a OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if given String is null or can't be converted to a OffsetDateTime.
        AssertionError - if the actual OffsetDateTime is not strictly before the OffsetDateTime built from given String.

      • isBeforeOrEqualTo

        public SELF isBeforeOrEqualTo​(OffsetDateTime other)
        Verifies that the actual OffsetDateTime is before or equals to the given one according to the comparator in use.

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         // assertions succeed
 assertThat(parse("2000-01-01T01:00:00Z")).isBeforeOrEqualTo(parse("2020-01-01T01:00:00Z"))
                                          .isBeforeOrEqualTo(parse("2000-01-01T01:00:00Z"))
                                          // same instant (on different offsets)
                                          .isBeforeOrEqualTo(parse("2000-01-01T00:00:00-01:00"));

 // assertions fail
 assertThat(parse("2000-01-01T01:00:00Z")).isBeforeOrEqualTo(parse("1999-01-01T01:00:00Z"));
 // even though the same instant, fails because of OffsetDateTime natural comparator is used and OffsetDateTime are on different offsets
 assertThat(parse("2000-01-01T01:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isBeforeOrEqualTo(parse("2000-01-01T00:00:00-01:00"));
        Parameters:
        other - the given OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if other OffsetDateTime is null.
        AssertionError - if the actual OffsetDateTime is not before or equals to the given one according to the comparator in use.

      • isBeforeOrEqualTo

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

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         // assertions succeed
 assertThat(parse("2000-01-01T01:00:00Z")).isBeforeOrEqualTo("2020-01-01T01:00:00Z")
                                          .isBeforeOrEqualTo("2000-01-01T01:00:00Z")
                                          // same instant (on different offsets)
                                          .isBeforeOrEqualTo("2000-01-01T00:00:00-01:00");

 // assertions fail
 assertThat(parse("2000-01-01T01:00:00Z")).isBeforeOrEqualTo("1999-01-01T01:00:00Z");
 // even though the same instant, fails because of OffsetDateTime natural comparator is used and OffsetDateTime are on different offsets
 assertThat(parse("2000-01-01T01:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isBeforeOrEqualTo("2000-01-01T00:00:00-01:00");
        Parameters:
        offsetDateTimeAsString - String representing a OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if given String is null or can't be converted to a OffsetDateTime.
        AssertionError - if the actual OffsetDateTime is not before or equals to the OffsetDateTime built from given String.

      • isAfterOrEqualTo

        public SELF isAfterOrEqualTo​(OffsetDateTime other)
        Verifies that the actual OffsetDateTime is after or equals to the given one according to the comparator in use.

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         // assertions succeed
 assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo(parse("2000-01-01T00:00:00Z"))
                                          .isAfterOrEqualTo(parse("1999-12-31T23:59:59Z"))
                                          // same instant in different offset
                                          .isAfterOrEqualTo(parse("2000-01-01T00:00:00-01:00"));

 // assertions fail
 assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo(parse("2001-01-01T00:00:00Z"));
 // fails even though they refer to the same instant due to OffsetDateTime natural comparator
 assertThat(parse("2000-01-01T00:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isAfterOrEqualTo(parse("2000-01-01T01:00:00+01:00"));
        Parameters:
        other - the given OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if other OffsetDateTime is null.
        AssertionError - if the actual OffsetDateTime is not after or equals to the given one according to the comparator in use.

      • isAfterOrEqualTo

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

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         // assertions succeed
 assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo("2000-01-01T00:00:00Z")
                                          .isAfterOrEqualTo("1999-12-31T23:59:59Z")
                                          // same instant in different offset
                                          .isAfterOrEqualTo("2000-01-01T00:00:00-01:00");

 // assertions fail
 assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo("2001-01-01T00:00:00Z");
 // fails even though they refer to the same instant due to OffsetDateTime natural comparator
 assertThat(parse("2000-01-01T00:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isAfterOrEqualTo("2000-01-01T01:00:00+01:00");
        Parameters:
        offsetDateTimeAsString - String representing a OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if given String is null or can't be converted to a OffsetDateTime.
        AssertionError - if the actual OffsetDateTime is not after or equals to the OffsetDateTime built from given String.

      • isAfter

        public SELF isAfter​(OffsetDateTime other)
        Verifies that the actual OffsetDateTime is strictly after the given one according to the comparator in use.

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         // assertions succeed:
  assertThat(parse("2000-01-01T00:00:00Z")).isAfter(parse("1999-12-31T23:59:59Z"));

 // assertions fail
 assertThat(parse("2000-01-01T01:00:00Z")).isAfter(parse("2001-01-01T01:00:00Z"));
 assertThat(parse("2000-01-01T01:00:00Z")).isAfter(parse("2000-01-01T01:00:00Z"));
 // fails because both OffsetDateTime refer to the same instant (on different offsets)
 assertThat(parse("2000-01-01T01:00:00Z")).isAfter(parse("2000-01-01T00:00:00-01:00"));

 // even though they refer to the same instant assertion succeeds because of different offset
 assertThat(parse("2000-01-01T01:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isAfter(parse("2000-01-01T00:00:00-01:00"));
        Parameters:
        other - the given OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if other OffsetDateTime is null.
        AssertionError - if the actual OffsetDateTime is not strictly after the given one according to the comparator in use.

      • isAfter

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

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         // assertion succeeds
 assertThat(parse("2000-01-01T01:00:00Z")).isAfter("1999-01-01T00:00:00Z");

 // assertions fail
 assertThat(parse("2000-01-01T01:00:00Z")).isAfter("2001-01-01T01:00:00Z");
 assertThat(parse("2000-01-01T01:00:00Z")).isAfter("2000-01-01T01:00:00Z");
 // fails because both OffsetDateTime refer to the same instant (on different offsets)
 assertThat(parse("2000-01-01T01:00:00Z")).isAfter("2000-01-01T00:00:00-01:00");

 // even though they refer to the same instant assertion succeeds because of different offset
 assertThat(parse("2000-01-01T01:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isAfter("2000-01-01T00:00:00-01:00");
        Parameters:
        offsetDateTimeAsString - String representing a OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if given String is null or can't be converted to a OffsetDateTime.
        AssertionError - if the actual OffsetDateTime is not strictly after the OffsetDateTime built from given String.

      • isEqualTo

        public SELF isEqualTo​(Object other)
        Verifies that the actual OffsetDateTime is equal to the given one according to the comparator in use.

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         OffsetDateTime firstOfJanuary2000InUTC = OffsetDateTime.parse("2000-01-01T00:00:00Z");

 // both assertions succeed, the second one because the comparison based on the instant they are referring to
 // 2000-01-01T01:00:00+01:00 = 2000-01-01T00:00:00 in UTC
 assertThat(firstOfJanuary2000InUTC).isEqualTo(parse("2000-01-01T00:00:00Z"))
                                    .isEqualTo(parse("2000-01-01T01:00:00+01:00"));

 // assertions fail
 assertThat(firstOfJanuary2000InUTC).isEqualTo(parse("1999-01-01T01:00:00Z"));
 // fails as the comparator compares the offsets
 assertThat(firstOfJanuary2000InUTC).usingComparator(OffsetDateTime::compareTo)
                                    .isEqualTo(parse("2000-01-01T01:00:00+01:00"));
        Specified by:
        isEqualTo in interface Assert<SELF extends AbstractOffsetDateTimeAssert<SELF>,​OffsetDateTime>
        Overrides:
        isEqualTo in class AbstractAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,​OffsetDateTime>
        Parameters:
        other - the given value to compare the actual value to.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is not equal to the given one according to the comparator in use.

      • isCloseToUtcNow

        public SELF isCloseToUtcNow​(TemporalUnitOffset offset)
        Verifies that the actual OffsetDateTime is close to the current date and time on the UTC timezone, according to the given TemporalUnitOffset. You can build the offset parameter using Assertions.within(long, TemporalUnit) or Assertions.byLessThan(long, TemporalUnit).

        If the difference is equal to the offset, the assertion succeeds.

        Example: 

         OffsetDateTime actual = OffsetDateTime.now(Clock.systemUTC());

 // assertion will pass as if executed less than one second after actual was built
 assertThat(actual).isCloseToUtcNow(within(1, ChronoUnit.SECONDS));

 // assertion will fail
 assertThat(actual.plusSeconds(2)).isCloseToUtcNow(within(1, ChronoUnit.SECONDS));
        Parameters:
        offset - The offset used for comparison
        Returns:
        this assertion object
        Throws:
        NullPointerException - if offset parameter is null.
        AssertionError - if the actual OffsetDateTime is null.
        AssertionError - if the actual OffsetDateTime is not close to the current time by less than the given offset.

      • isEqualTo

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

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         OffsetDateTime firstOfJanuary2000InUTC = OffsetDateTime.parse("2000-01-01T00:00:00Z");

 // both assertions succeed, the second one because the comparison based on the instant they are referring to
 // 2000-01-01T01:00:00+01:00 = 2000-01-01T00:00:00 in UTC
 assertThat(firstOfJanuary2000InUTC).isEqualTo("2000-01-01T00:00:00Z")
                                    .isEqualTo("2000-01-01T01:00:00+01:00");

 // assertions fail
 assertThat(firstOfJanuary2000InUTC).isEqualTo("1999-01-01T01:00:00Z");
 // fails as the comparator compares the offsets
 assertThat(firstOfJanuary2000InUTC).usingComparator(OffsetDateTime::compareTo)
                                    .isEqualTo("2000-01-01T01:00:00+01:00");
        Parameters:
        dateTimeAsString - String representing a OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if given String is null or can't be converted to a OffsetDateTime.
        AssertionError - if the actual OffsetDateTime is not equal to the OffsetDateTime built from given String.

      • isNotEqualTo

        public SELF isNotEqualTo​(Object other)
        Verifies that the actual OffsetDateTime is not equal to the given value according to the comparator in use.

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         // assertions succeed
 assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo(parse("2020-01-01T00:00:00Z"));
 // even though they refer to the same instant, succeeds as the OffsetDateTime comparator checks the offsets
 assertThat(parse("2000-01-01T00:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isNotEqualTo(parse("2000-01-01T02:00:00+02:00"));

 // assertions fail
 assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo(parse("2000-01-01T00:00:00Z"));
 // fails because the default comparator only checks the instant and they refer to the same
 assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo(parse("2000-01-01T02:00:00+02:00"));
        Specified by:
        isNotEqualTo in interface Assert<SELF extends AbstractOffsetDateTimeAssert<SELF>,​OffsetDateTime>
        Overrides:
        isNotEqualTo in class AbstractAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,​OffsetDateTime>
        Parameters:
        other - the given value to compare the actual value to.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is equal to the given one according to the comparator in use.

      • isNotEqualTo

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

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example : 

         // assertions succeed
 assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo("2020-01-01T00:00:00Z");
 // even though they refer to the same instant, succeeds as the OffsetDateTime comparator checks the offsets
 assertThat(parse("2000-01-01T00:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isNotEqualTo("2000-01-01T02:00:00+02:00");

 // assertions fail
 assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo("2000-01-01T00:00:00Z");
 // fails because the default comparator only checks the instant and they refer to the same
 assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo("2000-01-01T02:00:00+02:00");
        Parameters:
        dateTimeAsString - String representing a OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if given String is null or can't be converted to a OffsetDateTime.
        AssertionError - if the actual OffsetDateTime is equal to the OffsetDateTime built from given String.

      • isEqualToIgnoringNanos

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

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

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

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

        Code example : 

         // successful assertions
 OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC);
 OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 456, ZoneOffset.UTC);
 assertThat(OffsetDateTime1).isEqualToIgnoringNanos(OffsetDateTime2);
         // failing assertions (even if time difference is only 1ns)
 OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC);
 OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 0, 0, 0, 999999999, ZoneOffset.UTC);
 assertThat(OffsetDateTimeA).isEqualToIgnoringNanos(OffsetDateTimeB);
        Parameters:
        other - the given OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if other OffsetDateTime is null.
        AssertionError - if the actual OffsetDateTime is are not equal with nanoseconds ignored.

      • isEqualToIgnoringTimezone

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

        Code example : 

         // successful assertions
 OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC);
 OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.MAX);
 assertThat(OffsetDateTime1).isEqualToIgnoringTimezone(OffsetDateTime2);

 // failing assertions
 OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC);
 OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 0, 0, 0, 999999999, ZoneOffset.UTC);
 assertThat(OffsetDateTimeA).isEqualToIgnoringTimezone(OffsetDateTimeB);
        Parameters:
        other - the given OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if other OffsetDateTime is null.
        AssertionError - if the actual OffsetDateTime is are not equal with timezone ignored.

      • isEqualToIgnoringSeconds

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

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

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

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

        Code example : 

         // successful assertions
 OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 23, 50, 0, 0, ZoneOffset.UTC);
 OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 23, 50, 10, 456, ZoneOffset.UTC);
 assertThat(OffsetDateTime1).isEqualToIgnoringSeconds(OffsetDateTime2);

 // failing assertions (even if time difference is only 1ms)
 OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 23, 50, 00, 000, ZoneOffset.UTC);
 OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 23, 49, 59, 999, ZoneOffset.UTC);
 assertThat(OffsetDateTimeA).isEqualToIgnoringSeconds(OffsetDateTimeB);
        Parameters:
        other - the given OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if other OffsetDateTime is null.
        AssertionError - if the actual OffsetDateTime is are not equal with second and nanosecond fields ignored.

      • isEqualToIgnoringMinutes

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

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

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

        Time difference is only 1s but hour fields differ.

        Code example : 

         // successful assertions
 OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 23, 50, 0, 0, ZoneOffset.UTC);
 OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 23, 00, 2, 7, ZoneOffset.UTC);
 assertThat(OffsetDateTime1).isEqualToIgnoringMinutes(OffsetDateTime2);

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

      • isEqualToIgnoringHours

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

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

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

        Time difference is only 1min but day fields differ.

        Code example : 

         // successful assertions
 OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 23, 59, 59, 999, ZoneOffset.UTC);
 OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 00, 00, 00, 000, ZoneOffset.UTC);
 assertThat(OffsetDateTime1).isEqualToIgnoringHours(OffsetDateTime2);

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

      • isBetween

        public SELF isBetween​(OffsetDateTime startExclusive,
                      OffsetDateTime endExclusive)
        Verifies that the actual OffsetDateTime is in the [start, end] period (start and end included) according to the comparator in use.

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example: 

         OffsetDateTime offsetDateTime = OffsetDateTime.now();

 // assertions succeed:
 assertThat(offsetDateTime).isBetween(offsetDateTime.minusSeconds(1), offsetDateTime.plusSeconds(1))
                           .isBetween(offsetDateTime, offsetDateTime.plusSeconds(1))
                           .isBetween(offsetDateTime.minusSeconds(1), offsetDateTime)
                           .isBetween(offsetDateTime, offsetDateTime);
 // succeeds with default comparator which compares the point in time
 assertThat(parse("2010-01-01T00:00:00Z")).isBetween(parse("2010-01-01T01:00:00+01:00"),
                                                     parse("2010-01-01T01:00:00+01:00"));

 // assertions fail:
 assertThat(offsetDateTime).isBetween(offsetDateTime.minusSeconds(10), offsetDateTime.minusSeconds(1));
 assertThat(offsetDateTime).isBetween(offsetDateTime.plusSeconds(1), offsetDateTime.plusSeconds(10));

 // succeeds with default comparator
 assertThat(parse("2010-01-01T00:00:00Z")).isBetween(parse("2010-01-01T01:00:00+01:00"),
                                                     parse("2010-01-01T01:00:00+01:00"));
 // fails with a comparator which checks the offset, too
 assertThat(parse("2010-01-01T00:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isBetween(parse("2010-01-01T01:00:00+01:00"),
                                                     parse("2010-01-01T01:00:00+01:00"));
        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 according to the comparator in use.
        Since:
        3.7.1

      • isBetween

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

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example: 

         OffsetDateTime firstOfJanuary2000 = OffsetDateTime.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")
                               // same instant as firstOfJanuary2000 but on a different offset
                               .isBetween("2000-01-01T01:00:00+01:00", "2000-01-01T01:00:00+01:00");

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

      • isStrictlyBetween

        public SELF isStrictlyBetween​(OffsetDateTime startExclusive,
                              OffsetDateTime endExclusive)
        Verifies that the actual OffsetDateTime is in the ]start, end[ period (start and end excluded) according to the comparator in use.

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example: 

         OffsetDateTime offsetDateTime = OffsetDateTime.now();

 // assertions succeed:
 assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime.minusSeconds(1), offsetDateTime.plusSeconds(1));
 // succeeds with a different comparator even though the end value refers to the same instant as the actual
 assertThat(parse("2010-01-01T12:00:00Z")).usingComparator(OffsetDateTime::compareTo)
                                          .isStrictlyBetween(parse("2010-01-01T12:59:59+01:00"),
                                                             parse("2010-01-01T13:00:00+01:00"));

 // assertions fail:
 assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime.minusSeconds(10), offsetDateTime.minusSeconds(1));
 assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime.plusSeconds(1), offsetDateTime.plusSeconds(10));
 assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime, offsetDateTime.plusSeconds(1));
 assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime.minusSeconds(1), offsetDateTime);

 // fails with default comparator since the end value refers to the same instant as the actual
 assertThat(parse("2010-01-01T12:00:00Z")).isStrictlyBetween(parse("2010-01-01T12:59:59+01:00"),
                                                             parse("2010-01-01T13:00:00+01:00"));
        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 according to the comparator in use.
        Since:
        3.7.1

      • isStrictlyBetween

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

        Breaking change since 3.15.0 The default comparator uses OffsetDateTime.timeLineOrder() which only compares the underlying instant and ignores different timezones / offsets / chronologies.
        This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

        Example: 

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

 // assertion succeeds:
 assertThat(firstOfJanuary2000).isStrictlyBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:01Z")
                               // succeeds with a different comparator even though the end value refers to the same instant as the actual
                               .usingComparator(OffsetDateTime::compareTo)
                               .isStrictlyBetween("1999-12-31T23:59:59Z", "2000-01-01T01:00:00+01:00");

 // 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");
 // fails with default comparator since the end value refers to the same instant as the actual
 assertThat(parse("2010-01-01T12:00:00Z")).isStrictlyBetween("2010-01-01T12:59:59+01:00", "2010-01-01T13:00:00+01:00");
        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 OffsetDateTime.
        AssertionError - if the actual value is not in ]start, end[ period.
        Since:
        3.7.1

      • buildDefaultComparables

        private Comparables buildDefaultComparables()

      • isAtSameInstantAs

        public SELF isAtSameInstantAs​(OffsetDateTime other)
        Verifies that actual and given OffsetDateTime are at the same Instant.

        Example: 

         OffsetDateTime offsetDateTime1 = OffsetDateTime.of(2000, 12, 12, 3, 0, 0, 0, ZoneOffset.ofHours(3));
 OffsetDateTime offsetDateTime2 = OffsetDateTime.of(2000, 12, 12, 0, 0, 0, 0, ZoneOffset.ofHours(0));
 // assertion succeeds
 assertThat(offsetDateTime1).isAtSameInstantAs(offsetDateTime2);

 offsetDateTime2 = OffsetDateTime.of(2000, 12, 12, 2, 0, 0, 0, ZoneOffset.ofHours(0));
 // assertion fails
 assertThat(offsetDateTime1).isAtSameInstantAs(offsetDateTime2);
        Parameters:
        other - the given OffsetDateTime.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual OffsetDateTime is null.
        IllegalArgumentException - if other OffsetDateTime is null.
        AssertionError - if the actual OffsetDateTime is not at the same Instant as the other.

      • areEqualIgnoringNanos

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

      • areEqualIgnoringSeconds

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

      • areEqualIgnoringMinutes

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

      • haveSameYearMonthAndDayOfMonth

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

      • haveSameYearAndMonth

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

      • haveSameYear

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

      • areEqualIgnoringTimezone

        private static boolean areEqualIgnoringTimezone​(OffsetDateTime actual,
                                                OffsetDateTime other)
        Returns true if both OffsetDateTime are in the same hour, minute, second and nanosecond false otherwise.
        Parameters:
        actual - the actual OffsetDateTime. expected not be null
        other - the other OffsetDateTime. expected not be null
        Returns:
        true if both OffsetDateTime are in the same hour, minute, second and nanosecond false otherwise.

      • haveSameNano

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

      • convertToOffsetDateTimeArray

        private static Object[] convertToOffsetDateTimeArray​(String... dateTimesAsString)

      • checkIsNotNullAndNotEmpty

        private void checkIsNotNullAndNotEmpty​(Object[] values)