SELF - the "self" type of this assertion class.public abstract class AbstractOffsetDateTimeAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>> extends AbstractTemporalAssert<SELF,OffsetDateTime>
OffsetDateTime type from new Date & Time API introduced in Java 8.| Modifier and Type | Field and Description |
|---|---|
static String |
NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE |
actual, info, myself, objects, throwUnsupportedExceptionOnEquals| Modifier | Constructor and Description |
|---|---|
protected |
AbstractOffsetDateTimeAssert(OffsetDateTime actual,
Class<?> selfType)
Creates a new
|
| Modifier and Type | Method and Description |
|---|---|
SELF |
isAfter(OffsetDateTime other)
Verifies that the actual
OffsetDateTime is strictly after the given one according to the comparator in use. |
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. |
SELF |
isAfterOrEqualTo(OffsetDateTime other)
Verifies that the actual
OffsetDateTime is after or equals to the given one according to the comparator in use. |
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. |
SELF |
isAtSameInstantAs(OffsetDateTime other)
Verifies that actual and given
OffsetDateTime are at the same Instant. |
SELF |
isBefore(OffsetDateTime other)
Verifies that the actual
OffsetDateTime is strictly before the given one according to the comparator in use. |
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. |
SELF |
isBeforeOrEqualTo(OffsetDateTime other)
Verifies that the actual
OffsetDateTime is before or equals to the given one according to the comparator in use. |
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. |
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. |
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. |
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. |
SELF |
isEqualTo(Object other)
Verifies that the actual
OffsetDateTime is equal to the given one according to the comparator in use. |
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. |
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). |
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). |
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). |
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). |
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). |
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. |
SELF |
isNotEqualTo(Object other)
Verifies that the actual
OffsetDateTime is not equal to the given value according to the comparator in use. |
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. |
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. |
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. |
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. |
protected OffsetDateTime |
parse(String offsetDateTimeAsString)
Obtains an instance of
TEMPORAL from a string representation in ISO date format. |
SELF |
usingDefaultComparator()
Revert to standard comparison for the incoming assertion checks.
|
getActual, isCloseTo, isCloseTo, usingComparator, usingComparatorareEqual, asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, inHexadecimal, is, isElementOfCustomAssert, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOfForProxy, satisfiesForProxy, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingRecursiveComparison, usingRecursiveComparison, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnErrorclone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitas, as, as, describedAspublic static final String NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE
protected AbstractOffsetDateTimeAssert(OffsetDateTime actual, Class<?> selfType)
AbstractOffsetDateTimeAssertselfType - the "self type"actual - the actual value to verifypublic SELF isBefore(OffsetDateTime other)
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")); other - the given OffsetDateTime.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.public SELF isBefore(String offsetDateTimeAsString)
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"); offsetDateTimeAsString - String representing a OffsetDateTime.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.public SELF isBeforeOrEqualTo(OffsetDateTime other)
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")); other - the given OffsetDateTime.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.public SELF isBeforeOrEqualTo(String offsetDateTimeAsString)
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"); offsetDateTimeAsString - String representing a OffsetDateTime.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.public SELF isAfterOrEqualTo(OffsetDateTime other)
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"));other - the given OffsetDateTime.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.public SELF isAfterOrEqualTo(String offsetDateTimeAsString)
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");offsetDateTimeAsString - String representing a OffsetDateTime.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.public SELF isAfter(OffsetDateTime other)
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"));other - the given OffsetDateTime.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.public SELF isAfter(String offsetDateTimeAsString)
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");offsetDateTimeAsString - String representing a OffsetDateTime.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.public SELF isEqualTo(Object other)
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"));isEqualTo in interface Assert<SELF extends AbstractOffsetDateTimeAssert<SELF>,OffsetDateTime>isEqualTo in class AbstractAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,OffsetDateTime>other - the given value to compare the actual value to.AssertionError - if the actual OffsetDateTime is not equal to the given one according to
the comparator in use.public SELF isCloseToUtcNow(TemporalUnitOffset offset)
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));offset - The offset used for comparisonNullPointerException - 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.public SELF isEqualTo(String dateTimeAsString)
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");dateTimeAsString - String representing a OffsetDateTime.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.public SELF isNotEqualTo(Object other)
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"));isNotEqualTo in interface Assert<SELF extends AbstractOffsetDateTimeAssert<SELF>,OffsetDateTime>isNotEqualTo in class AbstractAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,OffsetDateTime>other - the given value to compare the actual value to.AssertionError - if the actual OffsetDateTime is equal to the given one according to
the comparator in use.public SELF isNotEqualTo(String dateTimeAsString)
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");dateTimeAsString - String representing a OffsetDateTime.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.public SELF isIn(String... dateTimesAsString)
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");dateTimesAsString - String array representing OffsetDateTimes.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.public SELF isNotIn(String... dateTimesAsString)
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");dateTimesAsString - Array of String representing a OffsetDateTime.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.public SELF isEqualToIgnoringNanos(OffsetDateTime other)
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);other - the given OffsetDateTime.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.public SELF isEqualToIgnoringTimezone(OffsetDateTime other)
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);other - the given OffsetDateTime.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.public SELF isEqualToIgnoringSeconds(OffsetDateTime other)
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);other - the given OffsetDateTime.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.public SELF isEqualToIgnoringMinutes(OffsetDateTime other)
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);other - the given OffsetDateTime.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.public SELF isEqualToIgnoringHours(OffsetDateTime other)
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);other - the given OffsetDateTime.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.public SELF isBetween(OffsetDateTime startExclusive, OffsetDateTime endExclusive)
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"));startExclusive - the start value (exclusive), expected not to be null.endExclusive - the end value (exclusive), expected not to be null.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.public SELF isBetween(String startExclusive, String endExclusive)
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");startExclusive - the start value (exclusive), expected not to be null.endExclusive - the end value (exclusive), expected not to be null.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.public SELF isStrictlyBetween(OffsetDateTime startExclusive, OffsetDateTime endExclusive)
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"));startExclusive - the start value (exclusive), expected not to be null.endExclusive - the end value (exclusive), expected not to be null.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.public SELF isStrictlyBetween(String startExclusive, String endExclusive)
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");startExclusive - the start value (exclusive), expected not to be null.endExclusive - the end value (exclusive), expected not to be null.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.public SELF usingDefaultComparator()
This method should be used to disable a custom comparison strategy set by calling usingComparator.
usingDefaultComparator in interface Assert<SELF extends AbstractOffsetDateTimeAssert<SELF>,OffsetDateTime>usingDefaultComparator in class AbstractTemporalAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,OffsetDateTime>this assertion object.public SELF isAtSameInstantAs(OffsetDateTime other)
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);other - the given OffsetDateTime.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.protected OffsetDateTime parse(String offsetDateTimeAsString)
TEMPORAL from a string representation in ISO date format.parse in class AbstractTemporalAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,OffsetDateTime>offsetDateTimeAsString - the string to parse, not nullTEMPORAL, not nullCopyright © 2025. All rights reserved.