Class AbstractZonedDateTimeAssert<SELF extends AbstractZonedDateTimeAssert<SELF>>
- All Implemented Interfaces:
Assert<SELF,
,ZonedDateTime> Descriptable<SELF>
,ExtensionPoints<SELF,
ZonedDateTime>
- Direct Known Subclasses:
ZonedDateTimeAssert
-
Field Summary
Fields inherited from class org.assertj.core.api.AbstractAssert
actual, info, myself, objects, throwUnsupportedExceptionOnEquals
-
Constructor Summary
ModifierConstructorDescriptionprotected
AbstractZonedDateTimeAssert
(ZonedDateTime actual, Class<?> selfType) -
Method Summary
Modifier and TypeMethodDescriptionSame assertion asisAfter(ZonedDateTime)
but theZonedDateTime
is built from given String, which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.isAfter
(ZonedDateTime other) Verifies that the actualZonedDateTime
is strictly after the given one according to the comparator in use.isAfterOrEqualTo
(String dateTimeAsString) Same assertion asisAfterOrEqualTo(ZonedDateTime)
but theZonedDateTime
is built from given String which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.isAfterOrEqualTo
(ZonedDateTime other) Verifies that the actualZonedDateTime
is after or equals to the given one according to the comparator in use.Same assertion asisBefore(ZonedDateTime)
but theZonedDateTime
is built from given String, which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.isBefore
(ZonedDateTime other) Verifies that the actualZonedDateTime
is strictly before the given one according to the comparator in use.isBeforeOrEqualTo
(String dateTimeAsString) Same assertion asisBeforeOrEqualTo(ZonedDateTime)
but theZonedDateTime
is built from given String which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.isBeforeOrEqualTo
(ZonedDateTime other) Verifies that the actualZonedDateTime
is before or equals to the given one according to the comparator in use.Same assertion asisBetween(ZonedDateTime, ZonedDateTime)
but here you passZonedDateTime
String representations which must follow ISO ZonedDateTime format to allow callingZonedDateTime.parse(CharSequence)
method.isBetween
(ZonedDateTime startInclusive, ZonedDateTime endInclusive) Verifies that the actualZonedDateTime
is in the [start, end] period (start and end included) according to the comparator in use.isCloseTo
(ZonedDateTime other, TemporalOffset<? super ZonedDateTime> offset) Verifies that the actualZonedDateTime
is close to the other according to the givenTemporalOffset
.Verifies that the actualZonedDateTime
is equal to the given one according to the comparator in use.Same assertion asisEqualTo(Object)
but theZonedDateTime
is built from given String which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.Deprecated.Deprecated.UseisCloseTo(ZonedDateTime, TemporalOffset)
instead, although not exactly the same semantics, this is the right way to compare with a given precision.Deprecated.UseisCloseTo(ZonedDateTime, TemporalOffset)
instead, although not exactly the same semantics, this is the right way to compare with a given precision.Deprecated.UseisCloseTo(ZonedDateTime, TemporalOffset)
instead, although not exactly the same semantics, this is the right way to compare with a given precision.Same assertion asisIn(ZonedDateTime...)
but theZonedDateTime
are built from given String, which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.isIn
(ZonedDateTime... expected) Verifies that the actualZonedDateTime
is equal to one of the givenZonedDateTime
in the actual ZonedDateTime'sZoneId
.Verifies that the actualZonedDateTime
is strictly in the future.Verifies that the actualZonedDateTime
is strictly in the past.isNotEqualTo
(Object expected) Verifies that the actual value is not equal to the given one according to the comparator in use.isNotEqualTo
(String dateTimeAsString) Same assertion as#isNotEqualTo(Object)
but theZonedDateTime
is built from given String which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.Same assertion asisNotIn(ZonedDateTime...)
but theZonedDateTime
is built from given String, which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.isNotIn
(ZonedDateTime... expected) Verifies that the actualZonedDateTime
is equal to one of the givenZonedDateTime
in the actual ZonedDateTime'sZoneId
.isStrictlyBetween
(String startExclusive, String endExclusive) Same assertion asisStrictlyBetween(ZonedDateTime, ZonedDateTime)
but here you passZonedDateTime
String representations which must follow ISO ZonedDateTime format to allow callingZonedDateTime.parse(CharSequence)
method.isStrictlyBetween
(ZonedDateTime startExclusive, ZonedDateTime endExclusive) Verifies that the actualZonedDateTime
is in the ]start, end[ period (start and end excluded) according to the comparator in use.protected ZonedDateTime
Obtains an instance ofZonedDateTime
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, usingComparator, usingComparator
Methods inherited from class org.assertj.core.api.AbstractAssert
areEqual, asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, 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, describedAs
-
Field Details
-
NULL_DATE_TIME_PARAMETER_MESSAGE
- See Also:
-
-
Constructor Details
-
AbstractZonedDateTimeAssert
-
-
Method Details
-
isBefore
Verifies that the actualZonedDateTime
is strictly before the given one according to the comparator in use.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
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 ZonedDateTime 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 ZonedDateTime refer to the same instant and ZonedDateTime natural comparator is used. assertThat(parse("2000-01-02T00:00:00Z")).usingComparator(ZonedDateTime::compareTo) .isBefore(parse("2000-01-02T01:00:00+01:00"));
- Parameters:
other
- the givenZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if otherZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is not strictly before the given one.
-
isBefore
Same assertion asisBefore(ZonedDateTime)
but theZonedDateTime
is built from given String, which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
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 ZonedDateTime 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 ZonedDateTime refer to the same instant and ZonedDateTime natural comparator is used. assertThat(parse("2000-01-02T00:00:00Z")).usingComparator(ZonedDateTime::compareTo) .isBefore("2000-01-02T01:00:00+01:00");
- Parameters:
dateTimeAsString
- String representing aZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aZonedDateTime
.AssertionError
- if the actualZonedDateTime
is not strictly before theZonedDateTime
built from given String.
-
isBeforeOrEqualTo
Verifies that the actualZonedDateTime
is before or equals to the given one according to the comparator in use.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
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 ZonedDateTime natural comparator is used and ZonedDateTime are on different offsets assertThat(parse("2000-01-01T01:00:00Z")).usingComparator(ZonedDateTime::compareTo) .isBeforeOrEqualTo(parse("2000-01-01T00:00:00-01:00"));
- Parameters:
other
- the givenZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if otherZonedDateTime
isnull
.AssertionError
- if the actualZoneDateTime
is not before or equals to the given one.
-
isBeforeOrEqualTo
Same assertion asisBeforeOrEqualTo(ZonedDateTime)
but theZonedDateTime
is built from given String which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
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 ZonedDateTime natural comparator is used and ZonedDateTime are on different offsets assertThat(parse("2000-01-01T01:00:00Z")).usingComparator(ZonedDateTime::compareTo) .isBeforeOrEqualTo("2000-01-01T00:00:00-01:00");
- Parameters:
dateTimeAsString
- String representing aZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aZonedDateTime
.AssertionError
- if the actualZonedDateTime
is not before or equals to theZonedDateTime
built from given String.
-
isAfterOrEqualTo
Verifies that the actualZonedDateTime
is after or equals to the given one according to the comparator in use.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
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 ZonedDateTime natural comparator assertThat(parse("2000-01-01T00:00:00Z")).usingComparator(ZonedDateTime::compareTo) .isAfterOrEqualTo(parse("2000-01-01T01:00:00+01:00"));
- Parameters:
other
- the givenZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if otherZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is not after or equals to the given one.
-
isAfterOrEqualTo
Same assertion asisAfterOrEqualTo(ZonedDateTime)
but theZonedDateTime
is built from given String which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
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 .isAfter("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 ZonedDateTime natural comparator assertThat(parse("2000-01-01T00:00:00Z")).usingComparator(ZonedDateTime::compareTo) .isAfterOrEqualTo("2000-01-01T01:00:00+01:00");
- Parameters:
dateTimeAsString
- String representing aZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aZonedDateTime
.AssertionError
- if the actualZonedDateTime
is not after or equals to theZonedDateTime
built from given String.
-
isAfter
Verifies that the actualZonedDateTime
is strictly after the given one according to the comparator in use.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
This behaviour can be overridden byAbstractTemporalAssert.usingComparator(Comparator)
.Example :
// assertion succeeds assertThat(parse("2000-01-01T01:00:00Z")).isAfter(parse("1999-01-01T00:00:00Z")); // 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 ZonedDateTime 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(ZonedDateTime::compareTo) .isAfter(parse("2000-01-01T00:00:00-01:00"));
- Parameters:
other
- the givenZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if otherZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is not strictly after the given one.
-
isAfter
Same assertion asisAfter(ZonedDateTime)
but theZonedDateTime
is built from given String, which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
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 ZonedDateTime 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(ZonedDateTime::compareTo) .isAfter("2000-01-01T00:00:00-01:00");
- Parameters:
dateTimeAsString
- String representing aZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aZonedDateTime
.AssertionError
- if the actualZonedDateTime
is not strictly after theZonedDateTime
built from the given String.
-
isEqualToIgnoringNanos
Deprecated.UseisCloseTo(ZonedDateTime, TemporalOffset)
instead, although not exactly the same semantics, this is the right way to compare with a given precision.Verifies that actual and givenZonedDateTime
have same year, month, day, hour, minute and second fields, (nanosecond fields are ignored in comparison).Note that given
ZonedDateTime
is converted in the actual'sZoneId
before comparison.Assertion can fail with dateTimes in same chronological nanosecond time window, e.g :
2000-01-01T00:00:01.000000000 and 2000-01-01T00:00:00.999999999.
Assertion fails as second fields differ even if time difference is only 1ns.
Code example :
// successful assertions ZonedDateTime dateTime1 = ZonedDateTime.of(2000, 1, 1, 0, 0, 1, 0); ZonedDateTime dateTime2 = ZonedDateTime.of(2000, 1, 1, 0, 0, 1, 456); assertThat(dateTime1).isEqualToIgnoringNanos(dateTime2); // failing assertions (even if time difference is only 1ms) ZonedDateTime dateTimeA = ZonedDateTime.of(2000, 1, 1, 0, 0, 1, 0); ZonedDateTime dateTimeB = ZonedDateTime.of(2000, 1, 1, 0, 0, 0, 999999999); assertThat(dateTimeA).isEqualToIgnoringNanos(dateTimeB);
- Parameters:
other
- the givenZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if otherZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is are not equal with nanoseconds ignored.
-
isEqualToIgnoringSeconds
Deprecated.UseisCloseTo(ZonedDateTime, TemporalOffset)
instead, although not exactly the same semantics, this is the right way to compare with a given precision.Verifies that actual and givenZonedDateTime
have same year, month, day, hour and minute fields (second and nanosecond fields are ignored in comparison).Note that given
ZonedDateTime
is converted in the actual'sZoneId
before comparison.Assertion can fail with ZonedDateTimes in same chronological second time window, e.g :
2000-01-01T00:01:00.000 and 2000-01-01T00:00:59.000.
Assertion fails as minute fields differ even if time difference is only 1ns.
Code example :
// successful assertions ZonedDateTime dateTime1 = ZonedDateTime.of(2000, 1, 1, 23, 50, 0, 0); ZonedDateTime dateTime2 = ZonedDateTime.of(2000, 1, 1, 23, 50, 10, 456); assertThat(dateTime1).isEqualToIgnoringSeconds(dateTime2); // failing assertions (even if time difference is only 1ns) ZonedDateTime dateTimeA = ZonedDateTime.of(2000, 1, 1, 23, 50, 00, 0); ZonedDateTime dateTimeB = ZonedDateTime.of(2000, 1, 1, 23, 49, 59, 999999999); assertThat(dateTimeA).isEqualToIgnoringSeconds(dateTimeB);
- Parameters:
other
- the givenZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if otherZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is are not equal with second and nanosecond fields ignored.
-
isEqualToIgnoringMinutes
Deprecated.UseisCloseTo(ZonedDateTime, TemporalOffset)
instead, although not exactly the same semantics, this is the right way to compare with a given precision.Verifies that actual and givenZonedDateTime
have same year, month, day and hour fields (minute, second and nanosecond fields are ignored in comparison).Note that given
ZonedDateTime
is converted in the actual'sZoneId
before comparison.Assertion can fail with dateTimes in same chronological second time window, e.g :
2000-01-01T01:00:00.000 and 2000-01-01T00:59:59.000.
Time difference is only 1s but hour fields differ.
Code example :
// successful assertions ZonedDateTime dateTime1 = ZonedDateTime.of(2000, 1, 1, 23, 50, 0, 0); ZonedDateTime dateTime2 = ZonedDateTime.of(2000, 1, 1, 23, 00, 2, 7); assertThat(dateTime1).isEqualToIgnoringMinutes(dateTime2); // failing assertions (even if time difference is only 1ms) ZonedDateTime dateTimeA = ZonedDateTime.of(2000, 1, 1, 01, 00, 00, 000); ZonedDateTime dateTimeB = ZonedDateTime.of(2000, 1, 1, 00, 59, 59, 999); assertThat(dateTimeA).isEqualToIgnoringMinutes(dateTimeB);
- Parameters:
other
- the givenZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if otherZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is are not equal ignoring minute, second and nanosecond fields.
-
isEqualToIgnoringHours
Deprecated.UseisCloseTo(ZonedDateTime, TemporalOffset)
instead, although not exactly the same semantics, this is the right way to compare with a given precision.Verifies that actual and givenZonedDateTime
have same year, month and day fields (hour, minute, second and nanosecond fields are ignored in comparison).Note that given
ZonedDateTime
is converted in the actual'sZoneId
before comparison.Assertion can fail with dateTimes in same chronological minute time window, e.g :
2000-01-01T23:59:00.000 and 2000-01-02T00:00:00.000.
Time difference is only 1min but day fields differ.
Code example :
// successful assertions ZonedDateTime dateTime1 = ZonedDateTime.of(2000, 1, 1, 23, 59, 59, 999, ZoneId.systemDefault()); ZonedDateTime dateTime2 = ZonedDateTime.of(2000, 1, 1, 00, 00, 00, 000, ZoneId.systemDefault()); assertThat(dateTime1).isEqualToIgnoringHours(dateTime2); // failing assertions (even if time difference is only 1ms) ZonedDateTime dateTimeA = ZonedDateTime.of(2000, 1, 2, 00, 00, 00, 000, ZoneId.systemDefault()); ZonedDateTime dateTimeB = ZonedDateTime.of(2000, 1, 1, 23, 59, 59, 999, ZoneId.systemDefault()); assertThat(dateTimeA).isEqualToIgnoringHours(dateTimeB);
- Parameters:
other
- the givenZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if otherZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is are not equal with second and nanosecond fields ignored.
-
isEqualTo
Verifies that the actualZonedDateTime
is equal to the given one according to the comparator in use.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
This behaviour can be overridden byAbstractTemporalAssert.usingComparator(Comparator)
.Example :
ZonedDateTime firstOfJanuary2000InUTC = ZonedDateTime.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(ZonedDateTime::compareTo) .isEqualTo(parse("2000-01-01T01:00:00+01:00"));
- Specified by:
isEqualTo
in interfaceAssert<SELF extends AbstractZonedDateTimeAssert<SELF>,
ZonedDateTime> - Overrides:
isEqualTo
in classAbstractAssert<SELF extends AbstractZonedDateTimeAssert<SELF>,
ZonedDateTime> - Parameters:
expected
- the given value to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actualZonedDateTime
is not equal to theZonedDateTime
according to the comparator in use.
-
isEqualTo
Same assertion asisEqualTo(Object)
but theZonedDateTime
is built from given String which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
This behaviour can be overridden byAbstractTemporalAssert.usingComparator(Comparator)
.Example :
ZonedDateTime firstOfJanuary2000InUTC = ZonedDateTime.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(ZonedDateTime::compareTo) .isEqualTo("2000-01-01T01:00:00+01:00");
- Parameters:
dateTimeAsString
- String representing aZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aZonedDateTime
.AssertionError
- if the actualZonedDateTime
is not equal to theZonedDateTime
built from the given String.
-
isNotEqualTo
Verifies that the actual value is not equal to the given one according to the comparator in use.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
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 ZonedDateTime comparator checks the offsets assertThat(parse("2000-01-01T00:00:00Z")).usingComparator(ZonedDateTime::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 AbstractZonedDateTimeAssert<SELF>,
ZonedDateTime> - Overrides:
isNotEqualTo
in classAbstractAssert<SELF extends AbstractZonedDateTimeAssert<SELF>,
ZonedDateTime> - Parameters:
expected
- the given value to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actualZonedDateTime
is equal to theZonedDateTime
according to the comparator in use.
-
isNotEqualTo
Same assertion as#isNotEqualTo(Object)
but theZonedDateTime
is built from given String which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
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 ZonedDateTime comparator checks the offsets assertThat(parse("2000-01-01T00:00:00Z")).usingComparator(ZonedDateTime::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 aZonedDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aZonedDateTime
.AssertionError
- if the actualZonedDateTime
is equal to theZonedDateTime
built from givenString
.
-
isIn
Verifies that the actualZonedDateTime
is equal to one of the givenZonedDateTime
in the actual ZonedDateTime'sZoneId
.Example :
assertThat(parse("2000-01-01T00:00:00Z")).isIn(parse("1999-12-31T23:59:59Z"), parse("2000-01-01T00:00:00Z"));
- Parameters:
expected
- the givenZonedDateTime
s to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is not in the givenZonedDateTime
s.
-
isIn
Same assertion asisIn(ZonedDateTime...)
but theZonedDateTime
are built from given String, which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.Note that the
ZonedDateTime
s created from the given Strings are built in theZoneId
of theZonedDateTime
to check..Example :
// use String based representation of LocalDateTime assertThat(parse("2000-01-01T00:00:00Z")).isIn("1999-12-31T23:59:59Z", "2000-01-01T00:00:00Z");
- Parameters:
dateTimesAsString
- String array representingZonedDateTime
s.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aZonedDateTime
.AssertionError
- if the actualZonedDateTime
is not in theZonedDateTime
s built from given Strings.
-
isNotIn
Verifies that the actualZonedDateTime
is equal to one of the givenZonedDateTime
in the actual ZonedDateTime'sZoneId
.Example :
assertThat(parse("2000-01-01T00:00:00Z")).isNotIn(parse("1999-12-31T23:59:59Z"), parse("2000-01-02T00:00:00Z"));
- Parameters:
expected
- the givenZonedDateTime
s to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is not in the givenZonedDateTime
s.
-
isNotIn
Same assertion asisNotIn(ZonedDateTime...)
but theZonedDateTime
is built from given String, which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.Note that the
ZonedDateTime
s created from the given Strings are built in theZoneId
of theZonedDateTime
to check..Example :
// use String based representation of ZonedDateTime assertThat(parse("2000-01-01T00:00:00Z")).isNotIn("1999-12-31T23:59:59Z", "2000-01-02T00:00:00Z");
- Parameters:
dateTimesAsString
- String array representingZonedDateTime
s.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aZonedDateTime
.AssertionError
- if the actualZonedDateTime
is not equal to theZonedDateTime
built from given String.
-
isInThePast
Verifies that the actualZonedDateTime
is strictly in the past.Example:
// assertion succeeds: assertThat(ZonedDateTime.now().minusMinutes(1)).isInThePast();
- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is not in the past.- Since:
- 3.25.0
-
isInTheFuture
Verifies that the actualZonedDateTime
is strictly in the future.Example:
// assertion succeeds: assertThat(ZonedDateTime.now().plusMinutes(1)).isInTheFuture();
- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is not in the future.- Since:
- 3.25.0
-
isBetween
Verifies that the actualZonedDateTime
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
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
This behaviour can be overridden byAbstractTemporalAssert.usingComparator(Comparator)
.Example:
ZonedDateTime zonedDateTime = ZonedDateTime.now(); // assertions succeed: assertThat(zonedDateTime).isBetween(zonedDateTime.minusSeconds(1), zonedDateTime.plusSeconds(1)) .isBetween(zonedDateTime, zonedDateTime.plusSeconds(1)) .isBetween(zonedDateTime.minusSeconds(1), zonedDateTime) .isBetween(zonedDateTime, zonedDateTime); // 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(zonedDateTime).isBetween(zonedDateTime.minusSeconds(10), zonedDateTime.minusSeconds(1)); assertThat(zonedDateTime).isBetween(zonedDateTime.plusSeconds(1), zonedDateTime.plusSeconds(10)); // fails because the comparator checks the offsets are the same assertThat(parse("2010-01-01T00:00:00Z")).usingComparator(ZonedDateTime::compareTo) .isBetween(parse("2010-01-01T01:00:00+01:00"), parse("2010-01-01T01:00:00+01:00"));
- 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 isnull
.NullPointerException
- if start value isnull
.NullPointerException
- if end value isnull
.AssertionError
- if the actual value is not in [start, end] period.- Since:
- 3.7.1
-
isBetween
Same assertion asisBetween(ZonedDateTime, ZonedDateTime)
but here you passZonedDateTime
String representations which must follow ISO ZonedDateTime format to allow callingZonedDateTime.parse(CharSequence)
method.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
This behaviour can be overridden byAbstractTemporalAssert.usingComparator(Comparator)
.Example:
ZonedDateTime firstOfJanuary2000 = ZonedDateTime.parse("2000-01-01T00:00:00Z"); // assertions succeed: assertThat(firstOfJanuary2000).isBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:01Z") .isBetween("2000-01-01T00:00:00Z", "2000-01-01T00:00:01Z") .isBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:00Z") .isBetween("2000-01-01T00:00:00Z", "2000-01-01T00:00:00Z") // 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:
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 isnull
.NullPointerException
- if start value isnull
.NullPointerException
- if end value isnull
.DateTimeParseException
- if any of the given String can't be converted to aZonedDateTime
.AssertionError
- if the actual value is not in [start, end] period.- Since:
- 3.7.1
-
isStrictlyBetween
Verifies that the actualZonedDateTime
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
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
This behaviour can be overridden byAbstractTemporalAssert.usingComparator(Comparator)
.Example:
ZonedDateTime zonedDateTime = ZonedDateTime.now(); // assertions succeed: assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime.minusSeconds(1), zonedDateTime.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(ZonedDateTime::compareTo) .isStrictlyBetween(parse("2010-01-01T12:59:59+01:00"), parse("2010-01-01T13:00:00+01:00")); // assertions fail: assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime.minusSeconds(10), zonedDateTime.minusSeconds(1)); assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime.plusSeconds(1), zonedDateTime.plusSeconds(10)); assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime, zonedDateTime.plusSeconds(1)); assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime.minusSeconds(1), zonedDateTime); // 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.- Since:
- 3.7.1
-
isStrictlyBetween
Same assertion asisStrictlyBetween(ZonedDateTime, ZonedDateTime)
but here you passZonedDateTime
String representations which must follow ISO ZonedDateTime format to allow callingZonedDateTime.parse(CharSequence)
method.Breaking change: since 3.15.0 the default comparator uses
ChronoZonedDateTime.timeLineOrder()
which only compares the underlying instant and not the chronology. The underlying comparison is equivalent to comparing the epoch-second and nano-of-second.
This behaviour can be overridden byAbstractTemporalAssert.usingComparator(Comparator)
.Example:
ZonedDateTime firstOfJanuary2000 = ZonedDateTime.parse("2000-01-01T00:00:00Z"); // assertions succeed: 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(ZonedDateTime::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 aZonedDateTime
.AssertionError
- if the actual value is not in ]start, end[ period.- Since:
- 3.7.1
-
isCloseTo
Verifies that the actualZonedDateTime
is close to the other according to the givenTemporalOffset
.You can build the offset parameter using
Assertions.within(long, TemporalUnit)
orAssertions.byLessThan(long, TemporalUnit)
.Example:
ZonedDateTime zonedDateTime = ZonedDateTime.parse("2000-01-01T00:00:00Z"); // assertions succeeds: assertThat(zonedDateTime).isCloseTo(zonedDateTime.plusHours(1), within(90, ChronoUnit.MINUTES)); // assertions fails: assertThat(zonedDateTime).isCloseTo(zonedDateTime.plusHours(1), within(30, ChronoUnit.MINUTES));
- Overrides:
isCloseTo
in classAbstractTemporalAssert<SELF extends AbstractZonedDateTimeAssert<SELF>,
ZonedDateTime> - Parameters:
other
- the ZonedDateTime to compare actual tooffset
- the offset used for comparison- Returns:
- this assertion object
- Throws:
NullPointerException
- ifZonedDateTime
orTemporalOffset
parameter isnull
.AssertionError
- if the actualZonedDateTime
isnull
.AssertionError
- if the actualZonedDateTime
is not close to the given one for a provided offset.
-
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 AbstractZonedDateTimeAssert<SELF>,
ZonedDateTime> - Overrides:
usingDefaultComparator
in classAbstractTemporalAssert<SELF extends AbstractZonedDateTimeAssert<SELF>,
ZonedDateTime> - Returns:
this
assertion object.
-
parse
Obtains an instance ofZonedDateTime
from a string representation in ISO date format.- Specified by:
parse
in classAbstractTemporalAssert<SELF extends AbstractZonedDateTimeAssert<SELF>,
ZonedDateTime> - Parameters:
dateTimeAsString
- the string to parse- Returns:
- the parsed
ZonedDateTime
-
isCloseTo(ZonedDateTime, TemporalOffset)
instead, although not exactly the same semantics, this is the right way to compare with a given precision.