Package org.assertj.core.api
Class AbstractInstantAssert<SELF extends AbstractInstantAssert<SELF>>
- java.lang.Object
-
- org.assertj.core.api.AbstractAssert<SELF,TEMPORAL>
-
- org.assertj.core.api.AbstractTemporalAssert<SELF,Instant>
-
- org.assertj.core.api.AbstractInstantAssert<SELF>
-
- Type Parameters:
SELF
- the "self" type of this assertion class.
- All Implemented Interfaces:
Assert<SELF,Instant>
,Descriptable<SELF>
,ExtensionPoints<SELF,Instant>
- Direct Known Subclasses:
InstantAssert
public class AbstractInstantAssert<SELF extends AbstractInstantAssert<SELF>> extends AbstractTemporalAssert<SELF,Instant>
Assertions forInstant
type from new Date & Time API introduced in Java 8.- Since:
- 3.7.0
-
-
Field Summary
-
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
AbstractInstantAssert(Instant actual, Class<?> selfType)
Creates a new
.AbstractInstantAssert
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description private static void
assertInstantAsStringParameterIsNotNull(String instantAsString)
Check that theInstant
string representation to compare actualInstant
to is not null, otherwise throws aIllegalArgumentException
with an explicit messageprivate static void
assertInstantParameterIsNotNull(Instant instant)
private static void
assertNotNull(AssertionInfo info, Instant actual)
private void
checkIsNotNullAndNotEmpty(Object[] values)
private static Object[]
convertToInstantArray(String[] instantsAsString)
SELF
isAfter(String instantAsString)
Same assertion asisAfter(Instant)
but theInstant
is built from given a String that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.SELF
isAfter(Instant other)
Verifies that the actualInstant
is strictly after the given one.SELF
isAfterOrEqualTo(String instantAsString)
Same assertion asisAfterOrEqualTo(Instant)
but theInstant
is built from given String, which must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.SELF
isAfterOrEqualTo(Instant other)
Verifies that the actualInstant
is after or equals to the given one.SELF
isBefore(String instantAsString)
Same assertion asisBefore(Instant)
but theInstant
is built from given String, which must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.SELF
isBefore(Instant other)
Verifies that the actualInstant
is strictly before the given one.SELF
isBeforeOrEqualTo(String instantAsString)
Same assertion asisBeforeOrEqualTo(Instant)
but theInstant
is built from given String, which must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.SELF
isBeforeOrEqualTo(Instant other)
Verifies that the actualInstant
is before or equals to the given one.SELF
isBetween(String startInclusive, String endInclusive)
Same assertion asisBetween(Instant, Instant)
but here you passInstant
String representations that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.SELF
isBetween(Instant startInclusive, Instant endInclusive)
Verifies that the actualInstant
is in the [start, end] period (start and end included).SELF
isEqualTo(String instantAsString)
Same assertion asAbstractAssert.isEqualTo(Object)
(where Object is expected to beInstant
) but here you passInstant
String representation that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.SELF
isIn(String... instantsAsString)
Same assertion asAbstractAssert.isIn(Object...)
(where Objects are expected to beInstant
) but here you passInstant
String representations that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.SELF
isNotEqualTo(String instantAsString)
Same assertion asAbstractAssert.isNotEqualTo(Object)
(where Object is expected to beInstant
) but here you passInstant
String representation that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.SELF
isNotIn(String... instantsAsString)
Same assertion asAbstractAssert.isNotIn(Object...)
(where Objects are expected to beInstant
) but here you passInstant
String representations that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.SELF
isStrictlyBetween(String startExclusive, String endExclusive)
Same assertion asisStrictlyBetween(Instant, Instant)
but here you passInstant
String representations that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.SELF
isStrictlyBetween(Instant startExclusive, Instant endExclusive)
Verifies that the actualInstant
is in the ]start, end[ period (start and end excluded).protected Instant
parse(String instantAsString)
Obtains an instance ofTEMPORAL
from a string representation in ISO date format.-
Methods inherited from class org.assertj.core.api.AbstractTemporalAssert
getActual, isCloseTo, isCloseTo, usingComparator, usingComparator, usingDefaultComparator
-
Methods inherited from class org.assertj.core.api.AbstractAssert
asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, inHexadecimal, is, isElementOfCustomAssert, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOf, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingRecursiveComparison, usingRecursiveComparison, withAssertionState, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError
-
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
-
Methods inherited from interface org.assertj.core.api.Descriptable
as, as, describedAs
-
-
-
-
Constructor Detail
-
AbstractInstantAssert
protected AbstractInstantAssert(Instant actual, Class<?> selfType)
Creates a new
.AbstractInstantAssert
- Parameters:
selfType
- the "self type"actual
- the actual value to verify
-
-
Method Detail
-
isBefore
public SELF isBefore(Instant other)
Verifies that the actualInstant
is strictly before the given one.Example :
assertThat(parse("2007-12-03T10:15:30.00Z")).isBefore(parse("2007-12-03T10:15:31.00Z"));
- Parameters:
other
- the givenInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if otherInstant
isnull
.AssertionError
- if the actualInstant
is not strictly before the given one.- Since:
- 3.7.0
-
isBefore
public SELF isBefore(String instantAsString)
Same assertion asisBefore(Instant)
but theInstant
is built from given String, which must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.Example :
// use String in comparison to avoid writing the code to perform the conversion assertThat(parse("2007-12-03T10:15:30.00Z").isBefore("2007-12-03T10:15:31.00Z");
- Parameters:
instantAsString
- String representing aInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if given String is null.DateTimeParseException
- if given String can't be converted to aInstant
.AssertionError
- if the actualInstant
is not strictly before theInstant
built from given String.- Since:
- 3.7.0
-
isBeforeOrEqualTo
public SELF isBeforeOrEqualTo(Instant other)
Verifies that the actualInstant
is before or equals to the given one.Example :
assertThat(parse("2007-12-03T10:15:30.00Z")).isBeforeOrEqualTo(parse("2007-12-03T10:15:30.00Z")) .isBeforeOrEqualTo(parse("2007-12-03T10:15:31.00Z"));
- Parameters:
other
- the givenInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if otherInstant
isnull
.AssertionError
- if the actualInstant
is not before or equals to the given one.- Since:
- 3.7.0
-
isBeforeOrEqualTo
public SELF isBeforeOrEqualTo(String instantAsString)
Same assertion asisBeforeOrEqualTo(Instant)
but theInstant
is built from given String, which must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.Example :
// use String in comparison to avoid conversion assertThat(parse("2007-12-03T10:15:30.00Z")).isBeforeOrEqualTo("2007-12-03T10:15:30.00Z") .isBeforeOrEqualTo("2007-12-03T10:15:31.00Z");
- Parameters:
instantAsString
- String representing aInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if given String is null.DateTimeParseException
- if given String can't be converted to aInstant
.AssertionError
- if the actualInstant
is not before or equals to theInstant
built from given String.- Since:
- 3.7.0
-
isAfterOrEqualTo
public SELF isAfterOrEqualTo(Instant other)
Verifies that the actualInstant
is after or equals to the given one.Example :
assertThat(parse("2007-12-03T10:15:30.00Z")).isAfterOrEqualTo(parse("2007-12-03T10:15:30.00Z")) .isAfterOrEqualTo(parse("2007-12-03T10:15:27.00Z"));
- Parameters:
other
- the givenInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if otherInstant
isnull
.AssertionError
- if the actualInstant
is not after or equals to the given one.- Since:
- 3.7.0
-
isAfterOrEqualTo
public SELF isAfterOrEqualTo(String instantAsString)
Same assertion asisAfterOrEqualTo(Instant)
but theInstant
is built from given String, which must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.Example :
// use String in comparison to avoid conversion assertThat(parse("2007-12-03T10:15:30.00Z")).isAfterOrEqualTo("2007-12-03T10:15:30.00Z") .isAfterOrEqualTo("2007-12-03T10:15:27.00Z");
- Parameters:
instantAsString
- String representing aInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if given String is null.DateTimeParseException
- if given String can't be converted to aInstant
.AssertionError
- if the actualInstant
is not after or equals to theInstant
built from given String.- Since:
- 3.7.0
-
isAfter
public SELF isAfter(Instant other)
Verifies that the actualInstant
is strictly after the given one.Example :
assertThat(parse("2007-12-03T10:15:30.00Z").isAfter(parse("2007-12-03T10:15:27.00Z"));
- Parameters:
other
- the givenInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if otherInstant
isnull
.AssertionError
- if the actualInstant
is not strictly after the given one.- Since:
- 3.7.0
-
isAfter
public SELF isAfter(String instantAsString)
Same assertion asisAfter(Instant)
but theInstant
is built from given a String that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.Example :
// use String in comparison to avoid conversion assertThat(parse("2007-12-03T10:15:30.00Z")).isAfter("2007-12-03T10:15:27.00Z");
- Parameters:
instantAsString
- String representing aInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if given String is null.DateTimeParseException
- if given String can't be converted to aInstant
.AssertionError
- if the actualInstant
is not strictly after theInstant
built from given String.- Since:
- 3.7.0
-
isEqualTo
public SELF isEqualTo(String instantAsString)
Same assertion asAbstractAssert.isEqualTo(Object)
(where Object is expected to beInstant
) but here you passInstant
String representation that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.Example :
// use directly String in comparison to avoid writing the code to perform the conversion assertThat(parse("2007-12-03T10:15:30.00Z")).isEqualTo("2007-12-03T10:15:30.00Z");
- Parameters:
instantAsString
- String representing aInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if given String is null.DateTimeParseException
- if given String can't be converted to aInstant
.AssertionError
- if the actualInstant
is not equal to theInstant
built from given String.- Since:
- 3.7.0
-
isNotEqualTo
public SELF isNotEqualTo(String instantAsString)
Same assertion asAbstractAssert.isNotEqualTo(Object)
(where Object is expected to beInstant
) but here you passInstant
String representation that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.Example :
// use directly String in comparison to avoid writing the code to perform the conversion assertThat(parse("2007-12-03T10:15:30.00Z")).isNotEqualTo("2007-12-03T10:15:00.00Z");
- Parameters:
instantAsString
- String representing aInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if given String is null.DateTimeParseException
- if given String can't be converted to aInstant
.AssertionError
- if the actualInstant
is equal to theInstant
built from given String.- Since:
- 3.7.0
-
isIn
public SELF isIn(String... instantsAsString)
Same assertion asAbstractAssert.isIn(Object...)
(where Objects are expected to beInstant
) but here you passInstant
String representations that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.Example :
// use String based representation of Instant assertThat(parse("2007-12-03T10:15:30.00Z")).isIn("2007-12-03T10:15:30.00Z", "2007-12-03T10:15:35.00Z");
- Parameters:
instantsAsString
- String array representingInstant
s.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if given Strings are null or empty.DateTimeParseException
- if one of the given String can't be converted to aInstant
.AssertionError
- if the actualInstant
is not in theInstant
s built from given Strings.- Since:
- 3.7.0
-
isNotIn
public SELF isNotIn(String... instantsAsString)
Same assertion asAbstractAssert.isNotIn(Object...)
(where Objects are expected to beInstant
) but here you passInstant
String representations that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.Example :
// use String based representation of Instant assertThat(parse("2007-12-03T10:15:30.00Z")).isNotIn("2007-12-03T10:15:35.00Z", "2007-12-03T10:15:25.00Z");
- Parameters:
instantsAsString
- Array of String representing aInstant
.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualInstant
isnull
.IllegalArgumentException
- if given Strings are null or empty.DateTimeParseException
- if one of the given String can't be converted to aInstant
.AssertionError
- if the actualInstant
is in theInstant
s built from given Strings.- Since:
- 3.7.0
-
isBetween
public SELF isBetween(Instant startInclusive, Instant endInclusive)
Verifies that the actualInstant
is in the [start, end] period (start and end included).Example:
Instant instant = Instant.now(); // assertions succeed: assertThat(instant).isBetween(instant.minusSeconds(1), instant.plusSeconds(1)) .isBetween(instant, instant.plusSeconds(1)) .isBetween(instant.minusSeconds(1), instant) .isBetween(instant, instant); // assertions fail: assertThat(instant).isBetween(instant.minusSeconds(10), instant.minusSeconds(1)); assertThat(instant).isBetween(instant.plusSeconds(1), instant.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] range.- Since:
- 3.7.1
-
isBetween
public SELF isBetween(String startInclusive, String endInclusive)
Same assertion asisBetween(Instant, Instant)
but here you passInstant
String representations that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.Example:
Instant firstOfJanuary2000 = Instant.parse("2000-01-01T00:00:00.00Z"); // assertions succeed: assertThat(firstOfJanuary2000).isBetween("1999-01-01T00:00:00.00Z", "2001-01-01T00:00:00.00Z") .isBetween("2000-01-01T00:00:00.00Z", "2001-01-01T00:00:00.00Z") .isBetween("1999-01-01T00:00:00.00Z", "2000-01-01T00:00:00.00Z") .isBetween("2000-01-01T00:00:00.00Z", "2000-01-01T00:00:00.00Z"); // assertion fails: assertThat(firstOfJanuary2000).isBetween("1999-01-01T00:00:00.00Z", "1999-12-31T23:59: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 aInstant
.AssertionError
- if the actual value is not in [start, end] range.- Since:
- 3.7.1
-
isStrictlyBetween
public SELF isStrictlyBetween(Instant startExclusive, Instant endExclusive)
Verifies that the actualInstant
is in the ]start, end[ period (start and end excluded).Example:
Instant instant = Instant.now(); // assertion succeeds: assertThat(instant).isStrictlyBetween(instant.minusSeconds(1), instant.plusSeconds(1)); // assertions fail: assertThat(instant).isStrictlyBetween(instant.minusSeconds(10), instant.minusSeconds(1)); assertThat(instant).isStrictlyBetween(instant.plusSeconds(1), instant.plusSeconds(10)); assertThat(instant).isStrictlyBetween(instant, instant.plusSeconds(1)); assertThat(instant).isStrictlyBetween(instant.minusSeconds(1), instant);
- 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[ range.- Since:
- 3.7.1
-
isStrictlyBetween
public SELF isStrictlyBetween(String startExclusive, String endExclusive)
Same assertion asisStrictlyBetween(Instant, Instant)
but here you passInstant
String representations that must follow ISO Instant format to allow callingInstant.parse(CharSequence)
method.Example:
Instant firstOfJanuary2000 = Instant.parse("2000-01-01T00:00:00.00Z"); // assertion succeeds: assertThat(firstOfJanuary2000).isStrictlyBetween("1999-01-01T00:00:00.00Z", "2001-01-01T00:00:00.00Z"); // assertions fail: assertThat(firstOfJanuary2000).isStrictlyBetween("1999-01-01T00:00:00.00Z", "1999-12-31T23:59:59.59Z"); assertThat(firstOfJanuary2000).isStrictlyBetween("2000-01-01T00:00:00.00Z", "2001-01-01T00:00:00.00Z"); assertThat(firstOfJanuary2000).isStrictlyBetween("1999-01-01T00:00:00.00Z", "2000-01-01T00:00: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 aInstant
.AssertionError
- if the actual value is not in ]start, end[ range.- Since:
- 3.7.1
-
parse
protected Instant parse(String instantAsString)
Description copied from class:AbstractTemporalAssert
Obtains an instance ofTEMPORAL
from a string representation in ISO date format.- Specified by:
parse
in classAbstractTemporalAssert<SELF extends AbstractInstantAssert<SELF>,Instant>
- Parameters:
instantAsString
- the string to parse, not null- Returns:
- the parsed
TEMPORAL
, not null
-
assertNotNull
private static void assertNotNull(AssertionInfo info, Instant actual)
-
checkIsNotNullAndNotEmpty
private void checkIsNotNullAndNotEmpty(Object[] values)
-
assertInstantAsStringParameterIsNotNull
private static void assertInstantAsStringParameterIsNotNull(String instantAsString)
Check that theInstant
string representation to compare actualInstant
to is not null, otherwise throws aIllegalArgumentException
with an explicit message- Parameters:
instantAsString
- String representing theInstant
to compare actual with- Throws:
IllegalArgumentException
- with an explicit message if the givenString
is null
-
assertInstantParameterIsNotNull
private static void assertInstantParameterIsNotNull(Instant instant)
-
-