Package org.assertj.core.api

Class AbstractOffsetDateTimeAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>>

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

  • Field Details

    • NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE

      public static final String NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE
      See Also:

  • Constructor Details

  • Method Details

    • isBefore

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

      Example : 

       assertThat(parse("2000-01-01T23:59:59Z")).isBefore(parse("2000-01-02T00:00:00Z"));
      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.

    • 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.

      Example : 

       // use String in comparison to avoid writing the code to perform the conversion
 assertThat(parse("2000-01-01T23:59:59Z")).isBefore("2000-01-02T00:00:00Z");
      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.

      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 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.

    • 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.

      Example : 

       // use String in comparison to avoid conversion
 assertThat(parse("2000-01-01T23:59:59Z")).isBeforeOrEqualTo("2000-01-01T23:59:59Z")
                                          .isBeforeOrEqualTo("2000-01-02T00:00:00Z");
      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.

      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 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.

    • 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.

      Example : 

       // use String in comparison to avoid conversion
 assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo("2000-01-01T00:00:00Z")
                                          .isAfterOrEqualTo("1999-12-31T23:59:59Z");
      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.

      Example : 

       assertThat(parse("2000-01-01T00:00:00Z")).isAfter(parse("1999-12-31T23:59:59Z"));
      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.

    • 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.

      Example : 

       // use String in comparison to avoid conversion
 assertThat(parse("2000-01-01T00:00:00Z")).isAfter("1999-12-31T23:59:59Z");
      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(String dateTimeAsString)
      Same assertion as AbstractAssert.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.

      Example : 

       // use String in comparison to avoid writing the code to perform the conversion
 assertThat(parse("2000-01-01T00:00:00Z")).isEqualTo("2000-01-01T00:00:00Z");
      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(String dateTimeAsString)
      Same assertion as AbstractAssert.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.

      Example : 

       // use String in comparison to avoid writing the code to perform the conversion
 assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo("2000-01-15T00:00:00Z");
      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.

    • isIn

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

      Example : 

       // use String based representation of OffsetDateTime
 assertThat(parse("2000-01-01T00:00:00Z")).isIn("1999-12-31T00:00:00Z", "2000-01-01T00:00:00Z");
      Parameters:
      dateTimesAsString - String array representing OffsetDateTimes.
      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 in the OffsetDateTimes built from given Strings.

    • isNotIn

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

      Example : 

       // use String based representation of OffsetDateTime
 assertThat(parse("2000-01-01T00:00:00Z")).isNotIn("1999-12-31T00:00:00Z", "2000-01-02T00:00:00Z");
      Parameters:
      dateTimesAsString - Array of 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 in the OffsetDateTimes built from given Strings.

    • 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 startInclusive, OffsetDateTime endInclusive)
      Verifies that the actual OffsetDateTime is in the [start, end] period (start and end included).

      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);
 
 // assertions fail:
 assertThat(offsetDateTime).isBetween(offsetDateTime.minusSeconds(10), offsetDateTime.minusSeconds(1));
 assertThat(offsetDateTime).isBetween(offsetDateTime.plusSeconds(1), offsetDateTime.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(OffsetDateTime, OffsetDateTime) but here you pass OffsetDateTime String representations which must follow ISO OffsetDateTime format to allow calling OffsetDateTime.parse(CharSequence) method.

      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");
                               
 // 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 OffsetDateTime.
      AssertionError - if the actual value is not in [start, end] period.
      Since:
      3.7.1

    • isStrictlyBetween

      public SELF isStrictlyBetween(OffsetDateTime startInclusive, OffsetDateTime endInclusive)
      Verifies that the actual OffsetDateTime is in the ]start, end[ period (start and end excluded).

      Example: 

       OffsetDateTime offsetDateTime = OffsetDateTime.now();
 
 // assertion succeeds:
 assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime.minusSeconds(1), offsetDateTime.plusSeconds(1));
 
 // 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);
      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

    • isStrictlyBetween

      public SELF isStrictlyBetween(String startInclusive, String endInclusive)
      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.

      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");
 
 // 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:
      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 OffsetDateTime.
      AssertionError - if the actual value is not in ]start, end[ period.
      Since:
      3.7.1

    • parse

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

    • 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)

    • assertOffsetDateTimeAsStringParameterIsNotNull

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

    • assertOffsetDateTimeParameterIsNotNull

      private static void assertOffsetDateTimeParameterIsNotNull(OffsetDateTime other)
      Check that the OffsetDateTime to compare actual OffsetDateTime to is not null, in that case throws a IllegalArgumentException with an explicit message
      Parameters:
      other - the OffsetDateTime to check
      Throws:
      IllegalArgumentException - with an explicit message if the given OffsetDateTime is null