Class AbstractOffsetDateTimeAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>>
- java.lang.Object
-
- org.assertj.core.api.AbstractAssert<SELF,TEMPORAL>
-
- org.assertj.core.api.AbstractTemporalAssert<SELF,OffsetDateTime>
-
- org.assertj.core.api.AbstractOffsetDateTimeAssert<SELF>
-
- Type Parameters:
SELF
- the "self" type of this assertion class.
- All Implemented Interfaces:
Assert<SELF,OffsetDateTime>
,Descriptable<SELF>
,ExtensionPoints<SELF,OffsetDateTime>
- Direct Known Subclasses:
OffsetDateTimeAssert
public abstract class AbstractOffsetDateTimeAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>> extends AbstractTemporalAssert<SELF,OffsetDateTime>
Assertions forOffsetDateTime
type from new Date & Time API introduced in Java 8.- Author:
- Paweł Stawicki, Joel Costigliola, Marcin Zajączkowski, Nikolaos Georgiou
-
-
Field Summary
Fields Modifier and Type Field Description static String
NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE
-
Fields inherited from class org.assertj.core.api.AbstractTemporalAssert
comparables
-
Fields inherited from class org.assertj.core.api.AbstractAssert
actual, assertionErrorCreator, conditions, info, myself, objects, throwUnsupportedExceptionOnEquals
-
-
Constructor Summary
Constructors Modifier Constructor Description protected
AbstractOffsetDateTimeAssert(OffsetDateTime actual, Class<?> selfType)
Creates a new
.AbstractOffsetDateTimeAssert
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description private static boolean
areEqualIgnoringMinutes(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year, month, day of month and hour, false otherwise.private static boolean
areEqualIgnoringNanos(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year, month and day of month, hour, minute and second, false otherwise.private static boolean
areEqualIgnoringSeconds(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year, month, day of month, hour and minute, false otherwise.private static boolean
areEqualIgnoringTimezone(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same hour, minute, second and nanosecond false otherwise.private static void
assertOffsetDateTimeAsStringParameterIsNotNull(String offsetDateTimeAsString)
Check that theOffsetDateTime
string representation to compare actualOffsetDateTime
to is not null, otherwise throws aIllegalArgumentException
with an explicit messageprivate static void
assertOffsetDateTimeParameterIsNotNull(OffsetDateTime other)
Check that theOffsetDateTime
to compare actualOffsetDateTime
to is not null, in that case throws aIllegalArgumentException
with an explicit messageprivate void
checkIsNotNullAndNotEmpty(Object[] values)
private static Object[]
convertToOffsetDateTimeArray(String... dateTimesAsString)
private static boolean
haveSameNano(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same nanosecond, false otherwise.private static boolean
haveSameYear(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year, false otherwise.private static boolean
haveSameYearAndMonth(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year and month, false otherwise.private static boolean
haveSameYearMonthAndDayOfMonth(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year, month and day of month, false otherwise.SELF
isAfter(String offsetDateTimeAsString)
Same assertion asisAfter(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given a String that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.SELF
isAfter(OffsetDateTime other)
Verifies that the actualOffsetDateTime
is strictly after the given one.SELF
isAfterOrEqualTo(String offsetDateTimeAsString)
Same assertion asisAfterOrEqualTo(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.SELF
isAfterOrEqualTo(OffsetDateTime other)
Verifies that the actualOffsetDateTime
is after or equals to the given one.SELF
isBefore(String offsetDateTimeAsString)
Same assertion asisBefore(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.SELF
isBefore(OffsetDateTime other)
Verifies that the actualOffsetDateTime
is strictly before the given one.SELF
isBeforeOrEqualTo(String offsetDateTimeAsString)
Same assertion asisBeforeOrEqualTo(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.SELF
isBeforeOrEqualTo(OffsetDateTime other)
Verifies that the actualOffsetDateTime
is before or equals to the given one.SELF
isBetween(String startExclusive, String endExclusive)
Same assertion asisBetween(OffsetDateTime, OffsetDateTime)
but here you passOffsetDateTime
String representations which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.SELF
isBetween(OffsetDateTime startExclusive, OffsetDateTime endExclusive)
Verifies that the actualOffsetDateTime
is in the [start, end] period (start and end included).SELF
isCloseToUtcNow(TemporalUnitOffset offset)
Verifies that the actualOffsetDateTime
is close to the current date and time on the UTC timezone, according to the givenTemporalUnitOffset
.SELF
isEqualTo(String dateTimeAsString)
Same assertion asAbstractAssert.isEqualTo(Object)
(where Object is expected to beOffsetDateTime
) but here you passOffsetDateTime
String representation that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.SELF
isEqualToIgnoringHours(OffsetDateTime other)
Verifies that actual and givenOffsetDateTime
have same year, month and day fields (hour, minute, second and nanosecond fields are ignored in comparison).SELF
isEqualToIgnoringMinutes(OffsetDateTime other)
Verifies that actual and givenOffsetDateTime
have same year, month, day and hour fields (minute, second and nanosecond fields are ignored in comparison).SELF
isEqualToIgnoringNanos(OffsetDateTime other)
Verifies that actual and givenOffsetDateTime
have same year, month, day, hour, minute and second fields, (nanosecond fields are ignored in comparison).SELF
isEqualToIgnoringSeconds(OffsetDateTime other)
Verifies that actual and givenOffsetDateTime
have same year, month, day, hour and minute fields (second and nanosecond fields are ignored in comparison).SELF
isEqualToIgnoringTimezone(OffsetDateTime other)
Verifies that actual and givenOffsetDateTime
have same year, month, day, hour, minute, second and nanosecond fields, (timezone fields are ignored in comparison).SELF
isIn(String... dateTimesAsString)
Same assertion asAbstractAssert.isIn(Object...)
(where Objects are expected to beOffsetDateTime
) but here you passOffsetDateTime
String representations that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.SELF
isNotEqualTo(String dateTimeAsString)
Same assertion asAbstractAssert.isNotEqualTo(Object)
(where Object is expected to beOffsetDateTime
) but here you passOffsetDateTime
String representation that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.SELF
isNotIn(String... dateTimesAsString)
Same assertion asAbstractAssert.isNotIn(Object...)
(where Objects are expected to beOffsetDateTime
) but here you passOffsetDateTime
String representations that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.SELF
isStrictlyBetween(String startExclusive, String endExclusive)
Same assertion asisStrictlyBetween(OffsetDateTime, OffsetDateTime)
but here you passOffsetDateTime
String representations which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.SELF
isStrictlyBetween(OffsetDateTime startExclusive, OffsetDateTime endExclusive)
Verifies that the actualOffsetDateTime
is in the ]start, end[ period (start and end excluded).protected OffsetDateTime
parse(String offsetDateTimeAsString)
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, asInstanceOf, asList, asString, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, 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, newListAssertInstance, overridingErrorMessage, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, setCustomRepresentation, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, withAssertionState, withFailMessage, withRepresentation, withThreadDumpOnError
-
-
-
-
Field Detail
-
NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE
public static final String NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE
- See Also:
- Constant Field Values
-
-
Constructor Detail
-
AbstractOffsetDateTimeAssert
protected AbstractOffsetDateTimeAssert(OffsetDateTime actual, Class<?> selfType)
Creates a new
.AbstractOffsetDateTimeAssert
- Parameters:
selfType
- the "self type"actual
- the actual value to verify
-
-
Method Detail
-
isBefore
public SELF isBefore(OffsetDateTime other)
Verifies that the actualOffsetDateTime
is strictly before the given one.Example :
assertThat(parse("2000-01-01T23:59:59Z")).isBefore(parse("2000-01-02T00:00:00Z"));
- Parameters:
other
- the givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not strictly before the given one.
-
isBefore
public SELF isBefore(String offsetDateTimeAsString)
Same assertion asisBefore(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.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:
offsetDateTimeAsString
- String representing aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not strictly before theOffsetDateTime
built from given String.
-
isBeforeOrEqualTo
public SELF isBeforeOrEqualTo(OffsetDateTime other)
Verifies that the actualOffsetDateTime
is before or equals to the given one.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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not before or equals to the given one.
-
isBeforeOrEqualTo
public SELF isBeforeOrEqualTo(String offsetDateTimeAsString)
Same assertion asisBeforeOrEqualTo(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.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:
offsetDateTimeAsString
- String representing aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not before or equals to theOffsetDateTime
built from given String.
-
isAfterOrEqualTo
public SELF isAfterOrEqualTo(OffsetDateTime other)
Verifies that the actualOffsetDateTime
is after or equals to the given one.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 givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not after or equals to the given one.
-
isAfterOrEqualTo
public SELF isAfterOrEqualTo(String offsetDateTimeAsString)
Same assertion asisAfterOrEqualTo(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given String, which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.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:
offsetDateTimeAsString
- String representing aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not after or equals to theOffsetDateTime
built from given String.
-
isAfter
public SELF isAfter(OffsetDateTime other)
Verifies that the actualOffsetDateTime
is strictly after the given one.Example :
assertThat(parse("2000-01-01T00:00:00Z")).isAfter(parse("1999-12-31T23:59:59Z"));
- Parameters:
other
- the givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not strictly after the given one.
-
isAfter
public SELF isAfter(String offsetDateTimeAsString)
Same assertion asisAfter(java.time.OffsetDateTime)
but theOffsetDateTime
is built from given a String that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.Example :
// use String in comparison to avoid conversion assertThat(parse("2000-01-01T00:00:00Z")).isAfter("1999-12-31T23:59:59Z");
- Parameters:
offsetDateTimeAsString
- String representing aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not strictly after theOffsetDateTime
built from given String.
-
isCloseToUtcNow
public SELF isCloseToUtcNow(TemporalUnitOffset offset)
Verifies that the actualOffsetDateTime
is close to the current date and time on the UTC timezone, according to the givenTemporalUnitOffset
. You can build the offset parameter usingAssertions.within(long, TemporalUnit)
orAssertions.byLessThan(long, TemporalUnit)
.If the difference is equal to the offset, the assertion succeeds.
Example:
OffsetDateTime actual = OffsetDateTime.now(Clock.systemUTC()); // assertion will pass as if executed less than one second after actual was built assertThat(actual).isCloseToUtcNow(within(1, ChronoUnit.SECONDS)); // assertion will fail assertThat(actual.plusSeconds(2)).isCloseToUtcNow(within(1, ChronoUnit.SECONDS));
- Parameters:
offset
- The offset used for comparison- Returns:
- this assertion object
- Throws:
NullPointerException
- ifoffset
parameter isnull
.AssertionError
- if the actualOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is not close to the current time by less than the given offset.
-
isEqualTo
public SELF isEqualTo(String dateTimeAsString)
Same assertion asAbstractAssert.isEqualTo(Object)
(where Object is expected to beOffsetDateTime
) but here you passOffsetDateTime
String representation that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.Example :
// use String in comparison to avoid writing the code to perform the conversion assertThat(parse("2000-01-01T00:00:00Z")).isEqualTo("2000-01-01T00:00:00Z");
- Parameters:
dateTimeAsString
- String representing aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not equal to theOffsetDateTime
built from given String.
-
isNotEqualTo
public SELF isNotEqualTo(String dateTimeAsString)
Same assertion asAbstractAssert.isNotEqualTo(Object)
(where Object is expected to beOffsetDateTime
) but here you passOffsetDateTime
String representation that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.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 aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is equal to theOffsetDateTime
built from given String.
-
isIn
public SELF isIn(String... dateTimesAsString)
Same assertion asAbstractAssert.isIn(Object...)
(where Objects are expected to beOffsetDateTime
) but here you passOffsetDateTime
String representations that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.Example :
// use String based representation of OffsetDateTime assertThat(parse("2000-01-01T00:00:00Z")).isIn("1999-12-31T00:00:00Z", "2000-01-01T00:00:00Z");
- Parameters:
dateTimesAsString
- String array representingOffsetDateTime
s.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is not in theOffsetDateTime
s built from given Strings.
-
isNotIn
public SELF isNotIn(String... dateTimesAsString)
Same assertion asAbstractAssert.isNotIn(Object...)
(where Objects are expected to beOffsetDateTime
) but here you passOffsetDateTime
String representations that must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.Example :
// use String based representation of OffsetDateTime assertThat(parse("2000-01-01T00:00:00Z")).isNotIn("1999-12-31T00:00:00Z", "2000-01-02T00:00:00Z");
- Parameters:
dateTimesAsString
- Array of String representing aOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if given String is null or can't be converted to aOffsetDateTime
.AssertionError
- if the actualOffsetDateTime
is in theOffsetDateTime
s built from given Strings.
-
isEqualToIgnoringNanos
public SELF isEqualToIgnoringNanos(OffsetDateTime other)
Verifies that actual and givenOffsetDateTime
have same year, month, day, hour, minute and second fields, (nanosecond fields are ignored in comparison).Assertion can fail with OffsetDateTimes in same chronological nanosecond time window, e.g :
2000-01-01T00:00:01.000000000+01:00 and 2000-01-01T00:00:00.999999999+01:00.
Assertion fails as second fields differ even if time difference is only 1ns.
Code example :
// successful assertions OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC); OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 456, ZoneOffset.UTC); assertThat(OffsetDateTime1).isEqualToIgnoringNanos(OffsetDateTime2);
// failing assertions (even if time difference is only 1ns) OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC); OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 0, 0, 0, 999999999, ZoneOffset.UTC); assertThat(OffsetDateTimeA).isEqualToIgnoringNanos(OffsetDateTimeB);
- Parameters:
other
- the givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is are not equal with nanoseconds ignored.
-
isEqualToIgnoringTimezone
public SELF isEqualToIgnoringTimezone(OffsetDateTime other)
Verifies that actual and givenOffsetDateTime
have same year, month, day, hour, minute, second and nanosecond fields, (timezone fields are ignored in comparison).Code example :
// successful assertions OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC); OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.MAX); assertThat(OffsetDateTime1).isEqualToIgnoringTimezone(OffsetDateTime2); // failing assertions OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC); OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 0, 0, 0, 999999999, ZoneOffset.UTC); assertThat(OffsetDateTimeA).isEqualToIgnoringTimezone(OffsetDateTimeB);
- Parameters:
other
- the givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is are not equal with timezone ignored.
-
isEqualToIgnoringSeconds
public SELF isEqualToIgnoringSeconds(OffsetDateTime other)
Verifies that actual and givenOffsetDateTime
have same year, month, day, hour and minute fields (second and nanosecond fields are ignored in comparison).Assertion can fail with OffsetDateTimes in same chronological second time window, e.g :
2000-01-01T00:01:00.000+01:00 and 2000-01-01T00:00:59.000+01:00.
Assertion fails as minute fields differ even if time difference is only 1s.
Code example :
// successful assertions OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 23, 50, 0, 0, ZoneOffset.UTC); OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 23, 50, 10, 456, ZoneOffset.UTC); assertThat(OffsetDateTime1).isEqualToIgnoringSeconds(OffsetDateTime2); // failing assertions (even if time difference is only 1ms) OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 23, 50, 00, 000, ZoneOffset.UTC); OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 23, 49, 59, 999, ZoneOffset.UTC); assertThat(OffsetDateTimeA).isEqualToIgnoringSeconds(OffsetDateTimeB);
- Parameters:
other
- the givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is are not equal with second and nanosecond fields ignored.
-
isEqualToIgnoringMinutes
public SELF isEqualToIgnoringMinutes(OffsetDateTime other)
Verifies that actual and givenOffsetDateTime
have same year, month, day and hour fields (minute, second and nanosecond fields are ignored in comparison).Assertion can fail with OffsetDateTimes in same chronological second time window, e.g :
2000-01-01T01:00:00.000+01:00 and 2000-01-01T00:59:59.000+01:00.
Time difference is only 1s but hour fields differ.
Code example :
// successful assertions OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 23, 50, 0, 0, ZoneOffset.UTC); OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 23, 00, 2, 7, ZoneOffset.UTC); assertThat(OffsetDateTime1).isEqualToIgnoringMinutes(OffsetDateTime2); // failing assertions (even if time difference is only 1ms) OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 1, 01, 00, 00, 000, ZoneOffset.UTC); OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 00, 59, 59, 999, ZoneOffset.UTC); assertThat(OffsetDateTimeA).isEqualToIgnoringMinutes(OffsetDateTimeB);
- Parameters:
other
- the givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is are not equal ignoring minute, second and nanosecond fields.
-
isEqualToIgnoringHours
public SELF isEqualToIgnoringHours(OffsetDateTime other)
Verifies that actual and givenOffsetDateTime
have same year, month and day fields (hour, minute, second and nanosecond fields are ignored in comparison).Assertion can fail with OffsetDateTimes in same chronological minute time window, e.g :
2000-01-01T23:59:00.000+01:00 and 2000-01-02T00:00:00.000+01:00.
Time difference is only 1min but day fields differ.
Code example :
// successful assertions OffsetDateTime OffsetDateTime1 = OffsetDateTime.of(2000, 1, 1, 23, 59, 59, 999, ZoneOffset.UTC); OffsetDateTime OffsetDateTime2 = OffsetDateTime.of(2000, 1, 1, 00, 00, 00, 000, ZoneOffset.UTC); assertThat(OffsetDateTime1).isEqualToIgnoringHours(OffsetDateTime2); // failing assertions (even if time difference is only 1ms) OffsetDateTime OffsetDateTimeA = OffsetDateTime.of(2000, 1, 2, 00, 00, 00, 000, ZoneOffset.UTC); OffsetDateTime OffsetDateTimeB = OffsetDateTime.of(2000, 1, 1, 23, 59, 59, 999, ZoneOffset.UTC); assertThat(OffsetDateTimeA).isEqualToIgnoringHours(OffsetDateTimeB);
- Parameters:
other
- the givenOffsetDateTime
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualOffsetDateTime
isnull
.IllegalArgumentException
- if otherOffsetDateTime
isnull
.AssertionError
- if the actualOffsetDateTime
is are not equal with second and nanosecond fields ignored.
-
isBetween
public SELF isBetween(OffsetDateTime startExclusive, OffsetDateTime endExclusive)
Verifies that the actualOffsetDateTime
is in the [start, end] period (start and end included).Example:
OffsetDateTime offsetDateTime = OffsetDateTime.now(); // assertions succeed: assertThat(offsetDateTime).isBetween(offsetDateTime.minusSeconds(1), offsetDateTime.plusSeconds(1)) .isBetween(offsetDateTime, offsetDateTime.plusSeconds(1)) .isBetween(offsetDateTime.minusSeconds(1), offsetDateTime) .isBetween(offsetDateTime, offsetDateTime); // assertions fail: assertThat(offsetDateTime).isBetween(offsetDateTime.minusSeconds(10), offsetDateTime.minusSeconds(1)); assertThat(offsetDateTime).isBetween(offsetDateTime.plusSeconds(1), offsetDateTime.plusSeconds(10));
- 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
-
isBetween
public SELF isBetween(String startExclusive, String endExclusive)
Same assertion asisBetween(OffsetDateTime, OffsetDateTime)
but here you passOffsetDateTime
String representations which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.Example:
OffsetDateTime firstOfJanuary2000 = OffsetDateTime.parse("2000-01-01T00:00:00Z"); // assertions succeed: assertThat(firstOfJanuary2000).isBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:01Z") .isBetween("2000-01-01T00:00:00Z", "2000-01-01T00:00:01Z") .isBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:00Z") .isBetween("2000-01-01T00:00:00Z", "2000-01-01T00:00:00Z"); // assertion fails: assertThat(firstOfJanuary2000).isBetween("1999-01-01T00:00:01Z", "1999-12-31T23:59:59Z");
- Parameters:
startExclusive
- the start value (exclusive), expected not to be null.endExclusive
- the end value (exclusive), expected not to be null.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual value isnull
.NullPointerException
- if start value isnull
.NullPointerException
- if end value isnull
.DateTimeParseException
- if any of the given String can't be converted to aOffsetDateTime
.AssertionError
- if the actual value is not in [start, end] period.- Since:
- 3.7.1
-
isStrictlyBetween
public SELF isStrictlyBetween(OffsetDateTime startExclusive, OffsetDateTime endExclusive)
Verifies that the actualOffsetDateTime
is in the ]start, end[ period (start and end excluded).Example:
OffsetDateTime offsetDateTime = OffsetDateTime.now(); // assertion succeeds: assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime.minusSeconds(1), offsetDateTime.plusSeconds(1)); // assertions fail: assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime.minusSeconds(10), offsetDateTime.minusSeconds(1)); assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime.plusSeconds(1), offsetDateTime.plusSeconds(10)); assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime, offsetDateTime.plusSeconds(1)); assertThat(offsetDateTime).isStrictlyBetween(offsetDateTime.minusSeconds(1), offsetDateTime);
- 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
public SELF isStrictlyBetween(String startExclusive, String endExclusive)
Same assertion asisStrictlyBetween(OffsetDateTime, OffsetDateTime)
but here you passOffsetDateTime
String representations which must follow ISO OffsetDateTime format to allow callingOffsetDateTime.parse(CharSequence)
method.Example:
OffsetDateTime firstOfJanuary2000 = OffsetDateTime.parse("2000-01-01T00:00:00Z"); // assertion succeeds: assertThat(firstOfJanuary2000).isStrictlyBetween("1999-12-31T23:59:59Z", "2000-01-01T00:00:01Z"); // 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:
startExclusive
- the start value (exclusive), expected not to be null.endExclusive
- the end value (exclusive), expected not to be null.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual value isnull
.NullPointerException
- if start value isnull
.NullPointerException
- if end value isnull
.DateTimeParseException
- if any of the given String can't be converted to aOffsetDateTime
.AssertionError
- if the actual value is not in ]start, end[ period.- Since:
- 3.7.1
-
parse
protected OffsetDateTime parse(String offsetDateTimeAsString)
Obtains an instance ofTEMPORAL
from a string representation in ISO date format.- Specified by:
parse
in classAbstractTemporalAssert<SELF extends AbstractOffsetDateTimeAssert<SELF>,OffsetDateTime>
- Parameters:
offsetDateTimeAsString
- the string to parse, not null- Returns:
- the parsed
TEMPORAL
, not null
-
areEqualIgnoringNanos
private static boolean areEqualIgnoringNanos(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year, month and day of month, hour, minute and second, false otherwise.- Parameters:
actual
- the actual OffsetDateTime. expected not be nullother
- the other OffsetDateTime. expected not be null- Returns:
- true if both OffsetDateTime are in the same year, month and day of month, hour, minute and second, false otherwise.
-
areEqualIgnoringSeconds
private static boolean areEqualIgnoringSeconds(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year, month, day of month, hour and minute, false otherwise.- Parameters:
actual
- the actual OffsetDateTime. expected not be nullother
- the other OffsetDateTime. expected not be null- Returns:
- true if both OffsetDateTime are in the same year, month, day of month, hour and minute, false otherwise.
-
areEqualIgnoringMinutes
private static boolean areEqualIgnoringMinutes(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year, month, day of month and hour, false otherwise.- Parameters:
actual
- the actual OffsetDateTime. expected not be nullother
- the other OffsetDateTime. expected not be null- Returns:
- true if both OffsetDateTime are in the same year, month, day of month and hour, false otherwise.
-
haveSameYearMonthAndDayOfMonth
private static boolean haveSameYearMonthAndDayOfMonth(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year, month and day of month, false otherwise.- Parameters:
actual
- the actual OffsetDateTime. expected not be nullother
- the other OffsetDateTime. expected not be null- Returns:
- true if both OffsetDateTime are in the same year, month and day of month, false otherwise
-
haveSameYearAndMonth
private static boolean haveSameYearAndMonth(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year and month, false otherwise.- Parameters:
actual
- the actual OffsetDateTime. expected not be nullother
- the other OffsetDateTime. expected not be null- Returns:
- true if both OffsetDateTime are in the same year and month, false otherwise
-
haveSameYear
private static boolean haveSameYear(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same year, false otherwise.- Parameters:
actual
- the actual OffsetDateTime. expected not be nullother
- the other OffsetDateTime. expected not be null- Returns:
- true if both OffsetDateTime are in the same year, false otherwise
-
areEqualIgnoringTimezone
private static boolean areEqualIgnoringTimezone(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same hour, minute, second and nanosecond false otherwise.- Parameters:
actual
- the actual OffsetDateTime. expected not be nullother
- the other OffsetDateTime. expected not be null- Returns:
- true if both OffsetDateTime are in the same hour, minute, second and nanosecond false otherwise.
-
haveSameNano
private static boolean haveSameNano(OffsetDateTime actual, OffsetDateTime other)
Returns true if both OffsetDateTime are in the same nanosecond, false otherwise.- Parameters:
actual
- the actual OffsetDateTime. expected not be nullother
- the other OffsetDateTime. expected not be null- Returns:
- true if both OffsetDateTime are in the same year, false otherwise
-
convertToOffsetDateTimeArray
private static Object[] convertToOffsetDateTimeArray(String... dateTimesAsString)
-
checkIsNotNullAndNotEmpty
private void checkIsNotNullAndNotEmpty(Object[] values)
-
assertOffsetDateTimeAsStringParameterIsNotNull
private static void assertOffsetDateTimeAsStringParameterIsNotNull(String offsetDateTimeAsString)
Check that theOffsetDateTime
string representation to compare actualOffsetDateTime
to is not null, otherwise throws aIllegalArgumentException
with an explicit message- Parameters:
offsetDateTimeAsString
- String representing theOffsetDateTime
to compare actual with- Throws:
IllegalArgumentException
- with an explicit message if the givenString
is null
-
assertOffsetDateTimeParameterIsNotNull
private static void assertOffsetDateTimeParameterIsNotNull(OffsetDateTime other)
Check that theOffsetDateTime
to compare actualOffsetDateTime
to is not null, in that case throws aIllegalArgumentException
with an explicit message- Parameters:
other
- theOffsetDateTime
to check- Throws:
IllegalArgumentException
- with an explicit message if the givenOffsetDateTime
is null
-
-