Class AbstractZonedDateTimeAssert<SELF extends AbstractZonedDateTimeAssert<SELF>>
- All Implemented Interfaces:
Assert<SELF,
,ZonedDateTime> Descriptable<SELF>
,ExtensionPoints<SELF,
ZonedDateTime>
- Direct Known Subclasses:
ZonedDateTimeAssert
-
Field Summary
FieldsFields inherited from class org.assertj.core.api.AbstractTemporalAssert
comparables
Fields inherited from class org.assertj.core.api.AbstractAssert
actual, conditions, info, myself, objects
-
Constructor Summary
ConstructorsModifierConstructorDescriptionprotected
AbstractZonedDateTimeAssert
(ZonedDateTime actual, Class<?> selfType) -
Method Summary
Modifier and TypeMethodDescriptionprivate static boolean
areEqualIgnoringMinutes
(ZonedDateTime actual, ZonedDateTime other) Returns true if both datetime are in the same year, month, day of month and hour, false otherwise.private static boolean
areEqualIgnoringNanos
(ZonedDateTime actual, ZonedDateTime other) Returns true if both datetime are in the same year, month and day of month, hour, minute and second, false otherwise.private static boolean
areEqualIgnoringSeconds
(ZonedDateTime actual, ZonedDateTime other) Returns true if both datetime are in the same year, month, day of month, hour and minute, false otherwise.private static void
assertDateTimeAsStringParameterIsNotNull
(String dateTimeAsString) Check that theZonedDateTime
string representation to compare actualZonedDateTime
to is not null, otherwise throws aIllegalArgumentException
with an explicit messageprivate static void
Check that theZonedDateTime
to compare actualZonedDateTime
to is not null, otherwise throws aIllegalArgumentException
with an explicit messageprivate ZonedDateTime[]
changeToActualTimeZone
(ZonedDateTime... dateTimes) private void
checkIsNotNullAndNotEmpty
(Object[] values) private ZonedDateTime[]
convertToDateTimeArray
(String... dateTimesAsString) private static boolean
haveSameYear
(ZonedDateTime actual, ZonedDateTime other) Returns true if both datetime are in the same year, false otherwise.private static boolean
haveSameYearAndMonth
(ZonedDateTime actual, ZonedDateTime other) Returns true if both datetime are in the same year and month, false otherwise.private static boolean
haveSameYearMonthAndDayOfMonth
(ZonedDateTime actual, ZonedDateTime other) Returns true if both datetime are in the same year, month and day of month, false otherwise.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.isAfter
(ZonedDateTime other) Verifies that the actualZonedDateTime
is strictly after the given one.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.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.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.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).Same assertion asisEqualTo(ZonedDateTime)
but theZonedDateTime
is built from given String, which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.isEqualTo
(ZonedDateTime expected) Verifies that the actualZonedDateTime
is equal to the given one in the actual'sZoneId
.Verifies that actual and givenZonedDateTime
have same year, month and day fields (hour, minute, second and nanosecond fields are ignored in comparison).Verifies that actual and givenZonedDateTime
have same year, month, day and hour fields (minute, second and nanosecond fields are ignored in comparison).Verifies that actual and givenZonedDateTime
have same year, month, day, hour, minute and second fields, (nanosecond fields are ignored in comparison).Verifies that actual and givenZonedDateTime
have same year, month, day, hour and minute fields (second and nanosecond fields are ignored in comparison).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
.isNotEqualTo
(String dateTimeAsString) Same assertion asisNotEqualTo(ZonedDateTime)
but theZonedDateTime
is built from given String, which must follow ISO date-time format to allow callingZonedDateTime.parse(CharSequence, DateTimeFormatter)
method.isNotEqualTo
(ZonedDateTime expected) Verifies that the actual value is not equal to the given one in the actual ZonedDateTime's java.time.ZoneId.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 startInclusive, String endInclusive) 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 startInclusive, ZonedDateTime endInclusive) Verifies that the actualZonedDateTime
is in the ]start, end[ period (start and end excluded).protected ZonedDateTime
Obtains an instance ofZonedDateTime
from a string representation in ISO date format.private ZonedDateTime
sameInstantInActualTimeZone
(ZonedDateTime zonedDateTime) Methods inherited from class org.assertj.core.api.AbstractTemporalAssert
getActual, isCloseTo, isCloseTo
Methods inherited from class org.assertj.core.api.AbstractAssert
as, as, asList, asString, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasToString, inBinary, inHexadecimal, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, overridingErrorMessage, satisfies, setCustomRepresentation, throwAssertionError, usingComparator, usingDefaultComparator, withFailMessage, withRepresentation, withThreadDumpOnError
-
Field Details
-
NULL_DATE_TIME_PARAMETER_MESSAGE
- See Also:
-
-
Constructor Details
-
AbstractZonedDateTimeAssert
-
-
Method Details
-
assertDateTimeParameterIsNotNull
Check that theZonedDateTime
to compare actualZonedDateTime
to is not null, otherwise throws aIllegalArgumentException
with an explicit message- Parameters:
dateTime
- theZonedDateTime
to check- Throws:
IllegalArgumentException
- with an explicit message if the givenZonedDateTime
is null
-
isBefore
Verifies that the actualZonedDateTime
is strictly before the given one.Comparison is done on
ZonedDateTime
's instant (i.e.ChronoZonedDateTime.toEpochSecond()
)Example :
assertThat(parse("2000-01-01T23:59:59Z")).isBefore(parse("2000-01-02T00:00:00Z"));
- 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.Note that the
ZonedDateTime
created from the given String is built in theZoneId
of theZonedDateTime
to check..Example :
// use String in comparison to avoid writing the code to perform the conversion assertThat(parse("2000-01-01T23:59:59Z")).isBefore("2000-01-02T00:00:00Z");
- Parameters:
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.Comparison is done on
ZonedDateTime
's instant (i.e.ChronoZonedDateTime.toEpochSecond()
)Example :
assertThat(parse("2000-01-01T23:59:59Z")).isBeforeOrEqualTo(parse("2000-01-01T23:59:59Z")) .isBeforeOrEqualTo(parse("2000-01-02T00:00:00Z"));
- Parameters:
other
- the 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.Note that the
ZonedDateTime
created from the given String is built in theZoneId
of theZonedDateTime
to check..Example :
// use String in comparison to avoid conversion assertThat(parse("2000-01-01T23:59:59Z")).isBeforeOrEqualTo("2000-01-01T23:59:59Z") .isBeforeOrEqualTo("2000-01-02T00:00:00Z");
- Parameters:
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.Comparison is done on
ZonedDateTime
's instant (i.e.ChronoZonedDateTime.toEpochSecond()
)Example :
assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo(parse("2000-01-01T00:00:00Z")) .isAfterOrEqualTo(parse("1999-12-31T23:59:59Z"));
- Parameters:
other
- the 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.Note that the
ZonedDateTime
created from the given String is built in theZoneId
of theZonedDateTime
to check.Example :
// use String in comparison to avoid conversion assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo("2000-01-01T00:00:00Z") .isAfterOrEqualTo("1999-12-31T23:59:59Z");
- Parameters:
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.Comparison is done on
ZonedDateTime
's instant (i.e.ChronoZonedDateTime.toEpochSecond()
)Example :
assertThat(parse("2000-01-01T00:00:00Z")).isAfter(parse("1999-12-31T23:59:59Z"));
- 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.Note that the
ZonedDateTime
created from the given String is built in theZoneId
of theZonedDateTime
to check.Example :
// use String in comparison to avoid conversion assertThat(parse("2000-01-01T00:00:00Z")).isAfter("1999-12-31T23:59:59Z");
- 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 given String.
-
isEqualToIgnoringNanos
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
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
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
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 in the actual'sZoneId
.Example :
ZonedDateTime firstOfJanuary2000InUTC = ZonedDateTime.parse("2000-01-01T00:00:00Z"); assertThat(firstOfJanuary2000InUTC).isEqualTo(parse("2000-01-01T00:00:00Z")); // the following assertion succeeds as ZonedDateTime are compared in actual's time zone // 2000-01-01T01:00:00+01:00 = 2000-01-01T00:00:00 in UTC assertThat(firstOfJanuary2000InUTC).isEqualTo(parse("2000-01-01T01:00:00+01:00"));
- 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
in the actual ZonedDateTime's java.time.ZoneId.
-
isEqualTo
Same assertion asisEqualTo(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
created from the given String is built in theZoneId
of theZonedDateTime
to check.Example :
// use String in comparison to avoid writing the code to perform the conversion ZonedDateTime firstOfJanuary2000InUTC = ZonedDateTime.parse("2000-01-01T00:00:00Z"); assertThat(firstOfJanuary2000InUTC).isEqualTo("2000-01-01T00:00:00Z"); // the following assertion succeeds as ZonedDateTime are compared in actual's time zone // 2000-01-01T01:00:00+01:00 = 2000-01-01T00:00:00 in UTC assertThat(firstOfJanuary2000InUTC).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 given String.
-
isNotEqualTo
Verifies that the actual value is not equal to the given one in the actual ZonedDateTime's java.time.ZoneId.Example :
assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo(parse("2000-01-15T00:00:00Z"));
- Parameters:
expected
- the given value to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actualZonedDateTime
is equal to theZonedDateTime
in the actual ZonedDateTime's java.time.ZoneId.
-
isNotEqualTo
Same assertion asisNotEqualTo(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
created from the given String is built in theZoneId
of theZonedDateTime
to check..ZonedDateTime
.Example :
// use String in comparison to avoid writing the code to perform the conversion assertThat(parse("2000-01-01T00:00:00Z")).isNotEqualTo("2000-01-15T00:00:00Z");
- Parameters:
dateTimeAsString
- String representing 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 given String.
-
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.
-
isBetween
Verifies that the actualZonedDateTime
is in the [start, end] period (start and end included).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); // assertions fail: assertThat(zonedDateTime).isBetween(zonedDateTime.minusSeconds(10), zonedDateTime.minusSeconds(1)); assertThat(zonedDateTime).isBetween(zonedDateTime.plusSeconds(1), zonedDateTime.plusSeconds(10));
- Parameters:
startInclusive
- the start value (inclusive), expected not to be null.endInclusive
- the end value (inclusive), expected not to be null.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual value 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.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"); // 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).Example:
ZonedDateTime zonedDateTime = ZonedDateTime.now(); // assertion succeeds: assertThat(zonedDateTime).isStrictlyBetween(zonedDateTime.minusSeconds(1), zonedDateTime.plusSeconds(1)); // 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);
- 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
-
isStrictlyBetween
Same assertion asisStrictlyBetween(ZonedDateTime, ZonedDateTime)
but here you passZonedDateTime
String representations which must follow ISO ZonedDateTime format to allow callingZonedDateTime.parse(CharSequence)
method.Example:
ZonedDateTime firstOfJanuary2000 = ZonedDateTime.parse("2000-01-01T00:00:00Z"); // assertion succeeds: assertThat(firstOfJanuary2000).isStrictlyBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:01Z"); // assertions fail: assertThat(firstOfJanuary2000).isStrictlyBetween("1999-01-01T00:00:01Z", "1999-12-31T23:59:59Z"); assertThat(firstOfJanuary2000).isStrictlyBetween("2000-01-01T00:00:00Z", "2000-01-01T00:00:01Z"); assertThat(firstOfJanuary2000).isStrictlyBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:00Z");
- Parameters:
startInclusive
- the start value (inclusive), expected not to be null.endInclusive
- the end value (inclusive), expected not to be null.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual value 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
-
convertToDateTimeArray
-
changeToActualTimeZone
-
checkIsNotNullAndNotEmpty
-
parse
Obtains an instance ofZonedDateTime
from a string representation in ISO date format. Note that theZonedDateTime
created from the given String is built in theZoneId
of the actualZonedDateTime
.- Specified by:
parse
in classAbstractTemporalAssert<SELF extends AbstractZonedDateTimeAssert<SELF>,
ZonedDateTime> - Parameters:
dateTimeAsString
- the string to parse- Returns:
- the parsed
ZonedDateTime
-
sameInstantInActualTimeZone
-
assertDateTimeAsStringParameterIsNotNull
Check that theZonedDateTime
string representation to compare actualZonedDateTime
to is not null, otherwise throws aIllegalArgumentException
with an explicit message- Parameters:
dateTimeAsString
- String representing the ZonedDateTime to compare actual with- Throws:
IllegalArgumentException
- with an explicit message if the givenString
is null
-
areEqualIgnoringNanos
Returns true if both datetime are in the same year, month and day of month, hour, minute and second, false otherwise.- Parameters:
actual
- the actual datetime. expected not be nullother
- the other datetime. expected not be null- Returns:
- true if both datetime are in the same year, month and day of month, hour, minute and second, false otherwise.
-
areEqualIgnoringSeconds
Returns true if both datetime are in the same year, month, day of month, hour and minute, false otherwise.- Parameters:
actual
- the actual datetime. expected not be nullother
- the other datetime. expected not be null- Returns:
- true if both datetime are in the same year, month, day of month, hour and minute, false otherwise.
-
areEqualIgnoringMinutes
Returns true if both datetime are in the same year, month, day of month and hour, false otherwise.- Parameters:
actual
- the actual datetime. expected not be nullother
- the other datetime. expected not be null- Returns:
- true if both datetime are in the same year, month, day of month and hour, false otherwise.
-
haveSameYearMonthAndDayOfMonth
Returns true if both datetime are in the same year, month and day of month, false otherwise.- Parameters:
actual
- the actual datetime. expected not be nullother
- the other datetime. expected not be null- Returns:
- true if both datetime are in the same year, month and day of month, false otherwise
-
haveSameYearAndMonth
Returns true if both datetime are in the same year and month, false otherwise.- Parameters:
actual
- the actual datetime. expected not be nullother
- the other datetime. expected not be null- Returns:
- true if both datetime are in the same year and month, false otherwise
-
haveSameYear
Returns true if both datetime are in the same year, false otherwise.- Parameters:
actual
- the actual datetime. expected not be nullother
- the other datetime. expected not be null- Returns:
- true if both datetime are in the same year, false otherwise
-