Class AbstractLocalDateTimeAssert<SELF extends AbstractLocalDateTimeAssert<SELF>>
- Type Parameters:
SELF
- the "self" type of this assertion class.
- All Implemented Interfaces:
Assert<SELF,
,LocalDateTime> Descriptable<SELF>
,ExtensionPoints<SELF,
LocalDateTime>
- Direct Known Subclasses:
LocalDateTimeAssert
LocalDateTime
type from new Date & Time API introduced in Java 8.-
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
AbstractLocalDateTimeAssert
(LocalDateTime actual, Class<?> selfType) Creates a new
.AbstractLocalDateTimeAssert
-
Method Summary
Modifier and TypeMethodDescriptionprivate static boolean
areEqualIgnoringMinutes
(LocalDateTime actual, LocalDateTime other) Returns true if both datetime are in the same year, month, day of month and hour, false otherwise.private static boolean
areEqualIgnoringNanos
(LocalDateTime actual, LocalDateTime 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
(LocalDateTime actual, LocalDateTime other) Returns true if both datetime are in the same year, month, day of month, hour and minute, false otherwise.private static void
assertLocalDateTimeAsStringParameterIsNotNull
(String localDateTimeAsString) Check that theLocalDateTime
string representation to compare actualLocalDateTime
to is not null, otherwise throws aIllegalArgumentException
with an explicit messageprivate static void
Check that theLocalDateTime
to compare actualLocalDateTime
to is not null, in that case throws aIllegalArgumentException
with an explicit messageprivate void
checkIsNotNullAndNotEmpty
(Object[] values) private static Object[]
convertToLocalDateTimeArray
(String... dateTimesAsString) private static boolean
haveSameYear
(LocalDateTime actual, LocalDateTime other) Returns true if both datetime are in the same year, false otherwise.private static boolean
haveSameYearAndMonth
(LocalDateTime actual, LocalDateTime other) Returns true if both datetime are in the same year and month, false otherwise.private static boolean
haveSameYearMonthAndDayOfMonth
(LocalDateTime actual, LocalDateTime other) Returns true if both datetime are in the same year, month and day of month, false otherwise.Same assertion asisAfter(LocalDateTime)
but theLocalDateTime
is built from given a String that must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.isAfter
(LocalDateTime other) Verifies that the actualLocalDateTime
is strictly after the given one.isAfterOrEqualTo
(String localDateTimeAsString) Same assertion asisAfterOrEqualTo(LocalDateTime)
but theLocalDateTime
is built from given String, which must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.isAfterOrEqualTo
(LocalDateTime other) Verifies that the actualLocalDateTime
is after or equals to the given one.Same assertion asisBefore(LocalDateTime)
but theLocalDateTime
is built from given String, which must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.isBefore
(LocalDateTime other) Verifies that the actualLocalDateTime
is strictly before the given one.isBeforeOrEqualTo
(String localDateTimeAsString) Same assertion asisBeforeOrEqualTo(LocalDateTime)
but theLocalDateTime
is built from given String, which must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.isBeforeOrEqualTo
(LocalDateTime other) Verifies that the actualLocalDateTime
is before or equals to the given one.Same assertion asisBetween(LocalDateTime, LocalDateTime)
but here you passLocalDateTime
String representations which must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.isBetween
(LocalDateTime startInclusive, LocalDateTime endInclusive) Verifies that the actualLocalDateTime
is in the [start, end] period (start and end included).Same assertion asAbstractAssert.isEqualTo(Object)
(where Object is expected to beLocalDateTime
) but here you passLocalDateTime
String representation that must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Verifies that actual and givenLocalDateTime
have same year, month and day fields (hour, minute, second and nanosecond fields are ignored in comparison).Verifies that actual and givenLocalDateTime
have same year, month, day and hour fields (minute, second and nanosecond fields are ignored in comparison).Verifies that actual and givenLocalDateTime
have same year, month, day, hour, minute and second fields, (nanosecond fields are ignored in comparison).Verifies that actual and givenLocalDateTime
have same year, month, day, hour and minute fields (second and nanosecond fields are ignored in comparison).Same assertion asAbstractAssert.isIn(Object...)
(where Objects are expected to beLocalDateTime
) but here you passLocalDateTime
String representations that must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.isNotEqualTo
(String dateTimeAsString) Same assertion asAbstractAssert.isNotEqualTo(Object)
(where Object is expected to beLocalDateTime
) but here you passLocalDateTime
String representation that must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Same assertion asAbstractAssert.isNotIn(Object...)
(where Objects are expected to beLocalDateTime
) but here you passLocalDateTime
String representations that must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.isStrictlyBetween
(String startInclusive, String endInclusive) Same assertion asisStrictlyBetween(LocalDateTime, LocalDateTime)
but here you passLocalDateTime
String representations which must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.isStrictlyBetween
(LocalDateTime startInclusive, LocalDateTime endInclusive) Verifies that the actualLocalDateTime
is in the ]start, end[ period (start and end excluded).protected LocalDateTime
Obtains an instance ofTEMPORAL
from a string representation in ISO date format.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_LOCAL_DATE_TIME_PARAMETER_MESSAGE
- See Also:
-
-
Constructor Details
-
AbstractLocalDateTimeAssert
Creates a new
.AbstractLocalDateTimeAssert
- Parameters:
actual
- the actual value to verifyselfType
- the "self type"
-
-
Method Details
-
isBefore
Verifies that the actualLocalDateTime
is strictly before the given one.Example :
assertThat(parse("2000-01-01T23:59:59")).isBefore(parse("2000-01-02T00:00:00"));
- Parameters:
other
- the givenLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if otherLocalDateTime
isnull
.AssertionError
- if the actualLocalDateTime
is not strictly before the given one.
-
isBefore
Same assertion asisBefore(LocalDateTime)
but theLocalDateTime
is built from given String, which must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Example :
// use String in comparison to avoid writing the code to perform the conversion assertThat(parse("2000-01-01T23:59:59")).isBefore("2000-01-02T00:00:00");
- Parameters:
localDateTimeAsString
- String representing aLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aLocalDateTime
.AssertionError
- if the actualLocalDateTime
is not strictly before theLocalDateTime
built from given String.
-
isBeforeOrEqualTo
Verifies that the actualLocalDateTime
is before or equals to the given one.Example :
assertThat(parse("2000-01-01T23:59:59")).isBeforeOrEqualTo(parse("2000-01-01T23:59:59")) .isBeforeOrEqualTo(parse("2000-01-02T00:00:00"));
- Parameters:
other
- the givenLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if otherLocalDateTime
isnull
.AssertionError
- if the actualLocalDateTime
is not before or equals to the given one.
-
isBeforeOrEqualTo
Same assertion asisBeforeOrEqualTo(LocalDateTime)
but theLocalDateTime
is built from given String, which must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Example :
// use String in comparison to avoid conversion assertThat(parse("2000-01-01T23:59:59")).isBeforeOrEqualTo("2000-01-01T23:59:59") .isBeforeOrEqualTo("2000-01-02T00:00:00");
- Parameters:
localDateTimeAsString
- String representing aLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aLocalDateTime
.AssertionError
- if the actualLocalDateTime
is not before or equals to theLocalDateTime
built from given String.
-
isAfterOrEqualTo
Verifies that the actualLocalDateTime
is after or equals to the given one.Example :
assertThat(parse("2000-01-01T00:00:00")).isAfterOrEqualTo(parse("2000-01-01T00:00:00")) .isAfterOrEqualTo(parse("1999-12-31T23:59:59"));
- Parameters:
other
- the givenLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if otherLocalDateTime
isnull
.AssertionError
- if the actualLocalDateTime
is not after or equals to the given one.
-
isAfterOrEqualTo
Same assertion asisAfterOrEqualTo(LocalDateTime)
but theLocalDateTime
is built from given String, which must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Example :
// use String in comparison to avoid conversion assertThat(parse("2000-01-01T00:00:00")).isAfterOrEqualTo("2000-01-01T00:00:00") .isAfterOrEqualTo("1999-12-31T23:59:59");
- Parameters:
localDateTimeAsString
- String representing aLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aLocalDateTime
.AssertionError
- if the actualLocalDateTime
is not after or equals to theLocalDateTime
built from given String.
-
isAfter
Verifies that the actualLocalDateTime
is strictly after the given one.Example :
assertThat(parse("2000-01-01T00:00:00")).isAfter(parse("1999-12-31T23:59:59"));
- Parameters:
other
- the givenLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if otherLocalDateTime
isnull
.AssertionError
- if the actualLocalDateTime
is not strictly after the given one.
-
isAfter
Same assertion asisAfter(LocalDateTime)
but theLocalDateTime
is built from given a String that must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Example :
// use String in comparison to avoid conversion assertThat(parse("2000-01-01T00:00:00")).isAfter("1999-12-31T23:59:59");
- Parameters:
localDateTimeAsString
- String representing aLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aLocalDateTime
.AssertionError
- if the actualLocalDateTime
is not strictly after theLocalDateTime
built from given String.
-
isEqualTo
Same assertion asAbstractAssert.isEqualTo(Object)
(where Object is expected to beLocalDateTime
) but here you passLocalDateTime
String representation that must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Example :
// use String in comparison to avoid writing the code to perform the conversion assertThat(parse("2000-01-01T00:00:00")).isEqualTo("2000-01-01T00:00:00");
- Parameters:
dateTimeAsString
- String representing aLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aLocalDateTime
.AssertionError
- if the actualLocalDateTime
is not equal to theLocalDateTime
built from given String.
-
isNotEqualTo
Same assertion asAbstractAssert.isNotEqualTo(Object)
(where Object is expected to beLocalDateTime
) but here you passLocalDateTime
String representation that must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Example :
// use String in comparison to avoid writing the code to perform the conversion assertThat(parse("2000-01-01T00:00:00")).isNotEqualTo("2000-01-15T00:00:00");
- Parameters:
dateTimeAsString
- String representing aLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aLocalDateTime
.AssertionError
- if the actualLocalDateTime
is equal to theLocalDateTime
built from given String.
-
isIn
Same assertion asAbstractAssert.isIn(Object...)
(where Objects are expected to beLocalDateTime
) but here you passLocalDateTime
String representations that must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Example :
// use String based representation of LocalDateTime assertThat(parse("2000-01-01T00:00:00")).isIn("1999-12-31T00:00:00", "2000-01-01T00:00:00");
- Parameters:
dateTimesAsString
- String array representingLocalDateTime
s.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aLocalDateTime
.AssertionError
- if the actualLocalDateTime
is not in theLocalDateTime
s built from given Strings.
-
isNotIn
Same assertion asAbstractAssert.isNotIn(Object...)
(where Objects are expected to beLocalDateTime
) but here you passLocalDateTime
String representations that must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Example :
// use String based representation of LocalDateTime assertThat(parse("2000-01-01T00:00:00")).isNotIn("1999-12-31T00:00:00", "2000-01-02T00:00:00");
- Parameters:
dateTimesAsString
- Array of String representing aLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aLocalDateTime
.AssertionError
- if the actualLocalDateTime
is in theLocalDateTime
s built from given Strings.
-
convertToLocalDateTimeArray
-
checkIsNotNullAndNotEmpty
-
assertLocalDateTimeAsStringParameterIsNotNull
Check that theLocalDateTime
string representation to compare actualLocalDateTime
to is not null, otherwise throws aIllegalArgumentException
with an explicit message- Parameters:
localDateTimeAsString
- String representing theLocalDateTime
to compare actual with- Throws:
IllegalArgumentException
- with an explicit message if the givenString
is null
-
assertLocalDateTimeParameterIsNotNull
Check that theLocalDateTime
to compare actualLocalDateTime
to is not null, in that case throws aIllegalArgumentException
with an explicit message- Parameters:
other
- theLocalDateTime
to check- Throws:
IllegalArgumentException
- with an explicit message if the givenLocalDateTime
is null
-
isEqualToIgnoringNanos
Verifies that actual and givenLocalDateTime
have same year, month, day, hour, minute and second fields, (nanosecond fields are ignored in comparison).Assertion can fail with localDateTimes 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 LocalDateTime localDateTime1 = LocalDateTime.of(2000, 1, 1, 0, 0, 1, 0); LocalDateTime localDateTime2 = LocalDateTime.of(2000, 1, 1, 0, 0, 1, 456); assertThat(localDateTime1).isEqualToIgnoringNanos(localDateTime2); // failing assertions (even if time difference is only 1ms) LocalDateTime localDateTimeA = LocalDateTime.of(2000, 1, 1, 0, 0, 1, 0); LocalDateTime localDateTimeB = LocalDateTime.of(2000, 1, 1, 0, 0, 0, 999999999); assertThat(localDateTimeA).isEqualToIgnoringNanos(localDateTimeB);
- Parameters:
other
- the givenLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if otherLocalDateTime
isnull
.AssertionError
- if the actualLocalDateTime
is are not equal with nanoseconds ignored.
-
isEqualToIgnoringSeconds
Verifies that actual and givenLocalDateTime
have same year, month, day, hour and minute fields (second and nanosecond fields are ignored in comparison).Assertion can fail with LocalDateTimes 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 1s.
Code example :
// successful assertions LocalDateTime localDateTime1 = LocalDateTime.of(2000, 1, 1, 23, 50, 0, 0); LocalDateTime localDateTime2 = LocalDateTime.of(2000, 1, 1, 23, 50, 10, 456); assertThat(localDateTime1).isEqualToIgnoringSeconds(localDateTime2); // failing assertions (even if time difference is only 1ms) LocalDateTime localDateTimeA = LocalDateTime.of(2000, 1, 1, 23, 50, 00, 000); LocalDateTime localDateTimeB = LocalDateTime.of(2000, 1, 1, 23, 49, 59, 999); assertThat(localDateTimeA).isEqualToIgnoringSeconds(localDateTimeB);
- Parameters:
other
- the givenLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if otherLocalDateTime
isnull
.AssertionError
- if the actualLocalDateTime
is are not equal with second and nanosecond fields ignored.
-
isEqualToIgnoringMinutes
Verifies that actual and givenLocalDateTime
have same year, month, day and hour fields (minute, second and nanosecond fields are ignored in comparison).Assertion can fail with localDateTimes 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 LocalDateTime localDateTime1 = LocalDateTime.of(2000, 1, 1, 23, 50, 0, 0); LocalDateTime localDateTime2 = LocalDateTime.of(2000, 1, 1, 23, 00, 2, 7); assertThat(localDateTime1).isEqualToIgnoringMinutes(localDateTime2); // failing assertions (even if time difference is only 1ms) LocalDateTime localDateTimeA = LocalDateTime.of(2000, 1, 1, 01, 00, 00, 000); LocalDateTime localDateTimeB = LocalDateTime.of(2000, 1, 1, 00, 59, 59, 999); assertThat(localDateTimeA).isEqualToIgnoringMinutes(localDateTimeB);
- Parameters:
other
- the givenLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if otherLocalDateTime
isnull
.AssertionError
- if the actualLocalDateTime
is are not equal ignoring minute, second and nanosecond fields.
-
isEqualToIgnoringHours
Verifies that actual and givenLocalDateTime
have same year, month and day fields (hour, minute, second and nanosecond fields are ignored in comparison).Assertion can fail with localDateTimes 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 LocalDateTime localDateTime1 = LocalDateTime.of(2000, 1, 1, 23, 59, 59, 999); LocalDateTime localDateTime2 = LocalDateTime.of(2000, 1, 1, 00, 00, 00, 000); assertThat(localDateTime1).isEqualToIgnoringHours(localDateTime2); // failing assertions (even if time difference is only 1ms) LocalDateTime localDateTimeA = LocalDateTime.of(2000, 1, 2, 00, 00, 00, 000); LocalDateTime localDateTimeB = LocalDateTime.of(2000, 1, 1, 23, 59, 59, 999); assertThat(localDateTimeA).isEqualToIgnoringHours(localDateTimeB);
- Parameters:
other
- the givenLocalDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualLocalDateTime
isnull
.IllegalArgumentException
- if otherLocalDateTime
isnull
.AssertionError
- if the actualLocalDateTime
is are not equal with second and nanosecond fields ignored.
-
isBetween
Verifies that the actualLocalDateTime
is in the [start, end] period (start and end included).Example:
LocalDateTime localDateTime = LocalDateTime.now(); // assertions succeed: assertThat(localDateTime).isBetween(localDateTime.minusSeconds(1), localDateTime.plusSeconds(1)) .isBetween(localDateTime, localDateTime.plusSeconds(1)) .isBetween(localDateTime.minusSeconds(1), localDateTime) .isBetween(localDateTime, localDateTime); // assertions fail: assertThat(localDateTime).isBetween(localDateTime.minusSeconds(10), localDateTime.minusSeconds(1)); assertThat(localDateTime).isBetween(localDateTime.plusSeconds(1), localDateTime.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(LocalDateTime, LocalDateTime)
but here you passLocalDateTime
String representations which must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Example:
LocalDateTime firstOfJanuary2000 = LocalDateTime.parse("2000-01-01T00:00:00"); // assertions succeed: assertThat(firstOfJanuary2000).isBetween("1999-12-31T23:59:59", "2000-01-01T00:00:01") .isBetween("2000-01-01T00:00:00", "2000-01-01T00:00:01") .isBetween("1999-12-31T23:59:59", "2000-01-01T00:00:00") .isBetween("2000-01-01T00:00:00", "2000-01-01T00:00:00"); // assertion fails: assertThat(firstOfJanuary2000).isBetween("1999-01-01T00:00:01", "1999-12-31T23:59:59");
- 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 aLocalDateTime
.AssertionError
- if the actual value is not in [start, end] period.- Since:
- 3.7.1
-
isStrictlyBetween
Verifies that the actualLocalDateTime
is in the ]start, end[ period (start and end excluded).Example:
LocalDateTime localDateTime = LocalDateTime.now(); // assertion succeeds: assertThat(localDateTime).isStrictlyBetween(localDateTime.minusSeconds(1), localDateTime.plusSeconds(1)); // assertions fail: assertThat(localDateTime).isStrictlyBetween(localDateTime.minusSeconds(10), localDateTime.minusSeconds(1)); assertThat(localDateTime).isStrictlyBetween(localDateTime.plusSeconds(1), localDateTime.plusSeconds(10)); assertThat(localDateTime).isStrictlyBetween(localDateTime, localDateTime.plusSeconds(1)); assertThat(localDateTime).isStrictlyBetween(localDateTime.minusSeconds(1), localDateTime);
- 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(LocalDateTime, LocalDateTime)
but here you passLocalDateTime
String representations which must follow ISO LocalDateTime format to allow callingLocalDateTime.parse(CharSequence)
method.Example:
LocalDateTime firstOfJanuary2000 = LocalDateTime.parse("2000-01-01T00:00:00"); // assertion succeeds: assertThat(firstOfJanuary2000).isStrictlyBetween("1999-12-31T23:59:59", "2000-01-01T00:00:01"); // assertions fail: assertThat(firstOfJanuary2000).isStrictlyBetween("1999-01-01T00:00:01", "1999-12-31T23:59:59"); assertThat(firstOfJanuary2000).isStrictlyBetween("2000-01-01T00:00:00", "2000-01-01T00:00:01"); assertThat(firstOfJanuary2000).isStrictlyBetween("1999-12-31T23:59:59", "2000-01-01T00:00: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
.DateTimeParseException
- if any of the given String can't be converted to aLocalDateTime
.AssertionError
- if the actual value is not in ]start, end[ period.- Since:
- 3.7.1
-
parse
Obtains an instance ofTEMPORAL
from a string representation in ISO date format.- Specified by:
parse
in classAbstractTemporalAssert<SELF extends AbstractLocalDateTimeAssert<SELF>,
LocalDateTime> - Parameters:
localDateTimeAsString
- the string to parse, not null- Returns:
- the parsed
TEMPORAL
, not 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
-