Class AbstractOffsetDateTimeAssert<SELF extends 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
OffsetDateTime
type from new Date & Time API introduced in Java 8.- Author:
- Paweł Stawicki, Joel Costigliola, Marcin Zajączkowski, Nikolaos Georgiou
-
Field Summary
Fields inherited from class org.assertj.core.api.AbstractAssert
actual, info, myself, objects, throwUnsupportedExceptionOnEquals
-
Constructor Summary
ModifierConstructorDescriptionprotected
AbstractOffsetDateTimeAssert
(OffsetDateTime actual, Class<?> selfType) Creates a new
.AbstractOffsetDateTimeAssert
-
Method Summary
Modifier and TypeMethodDescriptionSame assertion asisAfter(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given a String that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.isAfter
(OffsetDateTime other) Verifies that the actualOffsetDateTime
is strictly after the given one according to the comparator in use.isAfterOrEqualTo
(String offsetDateTimeAsString) Same assertion asisAfterOrEqualTo(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.isAfterOrEqualTo
(OffsetDateTime other) Verifies that the actualOffsetDateTime
is after or equals to the given one according to the comparator in use.isAtSameInstantAs
(OffsetDateTime other) Verifies that actual and givenOffsetDateTime
are at the sameInstant
.Same assertion asisBefore(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.isBefore
(OffsetDateTime other) Verifies that the actualOffsetDateTime
is strictly before the given one according to the comparator in use.isBeforeOrEqualTo
(String offsetDateTimeAsString) Same assertion asisBeforeOrEqualTo(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.isBeforeOrEqualTo
(OffsetDateTime other) Verifies that the actualOffsetDateTime
is before or equals to the given one according to the comparator in use.Same assertion asisBetween(OffsetDateTime, OffsetDateTime)
but here you passOffsetDateTime
String representations which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.isBetween
(OffsetDateTime startExclusive, OffsetDateTime endExclusive) Verifies that the actualOffsetDateTime
is in the [start, end] period (start and end included) according to the comparator in use.isCloseToUtcNow
(TemporalUnitOffset offset) Verifies that the actualOffsetDateTime
is close to the current date and time on the UTC timezone, according to the givenTemporalUnitOffset
.Verifies that the actualOffsetDateTime
is equal to the given one according to the comparator in use.Same assertion asisEqualTo(Object)
(where Object is expected to beOffsetDateTime
) but here you passOffsetDateTime
String representation that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.Verifies that actual and givenOffsetDateTime
have same year, month and day fields (hour, minute, second and nanosecond fields are ignored in comparison).Verifies that actual and givenOffsetDateTime
have same year, month, day and hour fields (minute, second and nanosecond fields are ignored in comparison).Verifies that actual and givenOffsetDateTime
have same year, month, day, hour, minute and second fields, (nanosecond fields are ignored in comparison).Verifies that actual and givenOffsetDateTime
have same year, month, day, hour and minute fields (second and nanosecond fields are ignored in comparison).Verifies that actual and givenOffsetDateTime
have same year, month, day, hour, minute, second and nanosecond fields, (timezone fields are ignored in comparison).Same assertion asAbstractAssert.isIn(Object...)
(where Objects are expected to beOffsetDateTime
) but here you passOffsetDateTime
String representations that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.isNotEqualTo
(Object other) Verifies that the actualOffsetDateTime
is not equal to the given value according to the comparator in use.isNotEqualTo
(String dateTimeAsString) Same assertion asisNotEqualTo(Object)
(where Object is expected to beOffsetDateTime
) but here you passOffsetDateTime
String representation that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.Same assertion asAbstractAssert.isNotIn(Object...)
(where Objects are expected to beOffsetDateTime
) but here you passOffsetDateTime
String representations that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.isStrictlyBetween
(String startExclusive, String endExclusive) Same assertion asisStrictlyBetween(OffsetDateTime, OffsetDateTime)
but here you passOffsetDateTime
String representations which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.isStrictlyBetween
(OffsetDateTime startExclusive, OffsetDateTime endExclusive) Verifies that the actualOffsetDateTime
is in the ]start, end[ period (start and end excluded) according to the comparator in use.protected OffsetDateTime
Obtains an instance ofTEMPORAL
from a string representation in ISO date format.Revert to standard comparison for the incoming assertion checks.Methods inherited from class org.assertj.core.api.AbstractTemporalAssert
getActual, isCloseTo, isCloseTo, usingComparator, usingComparator
Methods inherited from class org.assertj.core.api.AbstractAssert
areEqual, 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, usingRecursiveAssertion, usingRecursiveAssertion, usingRecursiveComparison, usingRecursiveComparison, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
Methods inherited from interface org.assertj.core.api.Descriptable
as, as, as, describedAs
-
Field Details
-
NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE
- See Also:
-
-
Constructor Details
-
AbstractOffsetDateTimeAssert
Creates a new
.AbstractOffsetDateTimeAssert
- Parameters:
selfType
- the "self type"actual
- the actual value to verify
-
-
Method Details
-
isBefore
Verifies that the actualOffsetDateTime
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 byAbstractTemporalAssert.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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not strictly before the given one according to the comparator in use.
-
isBefore
Same assertion asisBefore(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.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 byAbstractTemporalAssert.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 aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not strictly before theOffsetDateTime
built from given String.
-
isBeforeOrEqualTo
Verifies that the actualOffsetDateTime
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 byAbstractTemporalAssert.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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not before or equals to the given one according to the comparator in use.
-
isBeforeOrEqualTo
Same assertion asisBeforeOrEqualTo(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.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 byAbstractTemporalAssert.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 aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not before or equals to theOffsetDateTime
built from given String.
-
isAfterOrEqualTo
Verifies that the actualOffsetDateTime
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 byAbstractTemporalAssert.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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not after or equals to the given one according to the comparator in use.
-
isAfterOrEqualTo
Same assertion asisAfterOrEqualTo(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.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 byAbstractTemporalAssert.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 aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not after or equals to theOffsetDateTime
built from given String.
-
isAfter
Verifies that the actualOffsetDateTime
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 byAbstractTemporalAssert.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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not strictly after the given one according to the comparator in use.
-
isAfter
Same assertion asisAfter(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given a String that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.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 byAbstractTemporalAssert.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 aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not strictly after theOffsetDateTime
built from given String.
-
isEqualTo
Verifies that the actualOffsetDateTime
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 byAbstractTemporalAssert.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 interfaceAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,
OffsetDateTime> - Overrides:
isEqualTo
in classAbstractAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,
OffsetDateTime> - Parameters:
other
- the given value to compare the actual value to.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
is not equal to the given one according to the comparator in use.
-
isCloseToUtcNow
Verifies that the actualOffsetDateTime
is close to the current date and time on the UTC timezone, according to the givenTemporalUnitOffset
. You can build the offset parameter usingAssertions.within(long, TemporalUnit)
orAssertions.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
- ifoffset
parameter isnull
.AssertionError
- if the actualOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not close to the current time by less than the given offset.
-
isEqualTo
Same assertion asisEqualTo(Object)
(where Object is expected to beOffsetDateTime
) but here you passOffsetDateTime
String representation that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.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 byAbstractTemporalAssert.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 aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not equal to theOffsetDateTime
built from given String.
-
isNotEqualTo
Verifies that the actualOffsetDateTime
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 byAbstractTemporalAssert.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 interfaceAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,
OffsetDateTime> - Overrides:
isNotEqualTo
in classAbstractAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,
OffsetDateTime> - Parameters:
other
- the given value to compare the actual value to.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
is equal to the given one according to the comparator in use.
-
isNotEqualTo
Same assertion asisNotEqualTo(Object)
(where Object is expected to beOffsetDateTime
) but here you passOffsetDateTime
String representation that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.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 byAbstractTemporalAssert.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 aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is equal to theOffsetDateTime
built from given String.
-
isIn
Same assertion asAbstractAssert.isIn(Object...)
(where Objects are expected to beOffsetDateTime
) but here you passOffsetDateTime
String representations that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.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 representingOffsetDateTime
s.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not in theOffsetDateTime
s built from given Strings.
-
isNotIn
Same assertion asAbstractAssert.isNotIn(Object...)
(where Objects are expected to beOffsetDateTime
) but here you passOffsetDateTime
String representations that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.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 aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is in theOffsetDateTime
s built from given Strings.
-
isEqualToIgnoringNanos
Verifies that actual and givenOffsetDateTime
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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is are not equal with nanoseconds ignored.
-
isEqualToIgnoringTimezone
Verifies that actual and givenOffsetDateTime
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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is are not equal with timezone ignored.
-
isEqualToIgnoringSeconds
Verifies that actual and givenOffsetDateTime
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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is are not equal with second and nanosecond fields ignored.
-
isEqualToIgnoringMinutes
Verifies that actual and givenOffsetDateTime
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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is are not equal ignoring minute, second and nanosecond fields.
-
isEqualToIgnoringHours
Verifies that actual and givenOffsetDateTime
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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is are not equal with second and nanosecond fields ignored.
-
isBetween
Verifies that the actualOffsetDateTime
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 byAbstractTemporalAssert.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 isnull
.NullPointerException
- if start value isnull
.NullPointerException
- if end value isnull
.AssertionError
- if the actual value is not in [start, end] period according to the comparator in use.- Since:
- 3.7.1
-
isBetween
Same assertion asisBetween(OffsetDateTime, OffsetDateTime)
but here you passOffsetDateTime
String representations which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.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 byAbstractTemporalAssert.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 isnull
.NullPointerException
- if start value isnull
.NullPointerException
- if end value isnull
.DateTimeParseException
- if any of the given String can't be converted to aOffsetDateTime
.AssertionError
- if the actual value is not in [start, end] period.- Since:
- 3.7.1
-
isStrictlyBetween
Verifies that the actualOffsetDateTime
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 byAbstractTemporalAssert.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 isnull
.NullPointerException
- if start value isnull
.NullPointerException
- if end value isnull
.AssertionError
- if the actual value is not in ]start, end[ period according to the comparator in use.- Since:
- 3.7.1
-
isStrictlyBetween
Same assertion asisStrictlyBetween(OffsetDateTime, OffsetDateTime)
but here you passOffsetDateTime
String representations which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.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 byAbstractTemporalAssert.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 isnull
.NullPointerException
- if start value isnull
.NullPointerException
- if end value isnull
.DateTimeParseException
- if any of the given String can't be converted to aOffsetDateTime
.AssertionError
- if the actual value is not in ]start, end[ period.- Since:
- 3.7.1
-
usingDefaultComparator
Revert to standard comparison for the incoming assertion checks.This method should be used to disable a custom comparison strategy set by calling
usingComparator
.- Specified by:
usingDefaultComparator
in interfaceAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,
OffsetDateTime> - Overrides:
usingDefaultComparator
in classAbstractTemporalAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,
OffsetDateTime> - Returns:
this
assertion object.
-
isAtSameInstantAs
Verifies that actual and givenOffsetDateTime
are at the sameInstant
.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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not at the sameInstant
as the other.
-
parse
Obtains an instance ofTEMPORAL
from a string representation in ISO date format.- Specified by:
parse
in classAbstractTemporalAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,
OffsetDateTime> - Parameters:
offsetDateTimeAsString
- the string to parse, not null- Returns:
- the parsed
TEMPORAL
, not null
-