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 for Instant type from new Date & Time API introduced in Java 8.

Since:

3.7.0

Field Summary

Fields inherited from class org.assertj.core.api.AbstractAssert

actual, info, myself, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractInstantAssert(Instant actual, Class<?> selfType) Creates a new AbstractInstantAssert.

Method Summary

Modifier and Type	Method and Description
SELF	isAfter(Instant other) Verifies that the actual Instant is strictly after the given one.
SELF	isAfter(String instantAsString) Same assertion as isAfter(Instant) but the Instant is built from given a String that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.
SELF	isAfterOrEqualTo(Instant other) Verifies that the actual Instant is after or equals to the given one.
SELF	isAfterOrEqualTo(String instantAsString) Same assertion as isAfterOrEqualTo(Instant) but the Instant is built from given String, which must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.
SELF	isBefore(Instant other) Verifies that the actual Instant is strictly before the given one.
SELF	isBefore(String instantAsString) Same assertion as isBefore(Instant) but the Instant is built from given String, which must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.
SELF	isBeforeOrEqualTo(Instant other) Verifies that the actual Instant is before or equals to the given one.
SELF	isBeforeOrEqualTo(String instantAsString) Same assertion as isBeforeOrEqualTo(Instant) but the Instant is built from given String, which must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.
SELF	isBetween(Instant startInclusive, Instant endInclusive) Verifies that the actual Instant is in the [start, end] period (start and end included).
SELF	isBetween(String startInclusive, String endInclusive) Same assertion as isBetween(Instant, Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.
SELF	isEqualTo(String instantAsString) Same assertion as AbstractAssert.isEqualTo(Object) (where Object is expected to be Instant) but here you pass Instant String representation that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.
SELF	isIn(String... instantsAsString) Same assertion as AbstractAssert.isIn(Object...) (where Objects are expected to be Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.
SELF	isNotEqualTo(String instantAsString) Same assertion as AbstractAssert.isNotEqualTo(Object) (where Object is expected to be Instant) but here you pass Instant String representation that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.
SELF	isNotIn(String... instantsAsString) Same assertion as AbstractAssert.isNotIn(Object...) (where Objects are expected to be Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.
SELF	isStrictlyBetween(Instant startExclusive, Instant endExclusive) Verifies that the actual Instant is in the ]start, end[ period (start and end excluded).
SELF	isStrictlyBetween(String startExclusive, String endExclusive) Same assertion as isStrictlyBetween(Instant, Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.parse(CharSequence) method.
protected Instant	parse(String instantAsString) Obtains an instance of TEMPORAL 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, 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, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

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 actual Instant 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 given Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if other Instant is null.

AssertionError - if the actual Instant is not strictly before the given one.

Since:

3.7.0

isBefore

public SELF isBefore(String instantAsString)

Same assertion as isBefore(Instant) but the Instant is built from given String, which must follow ISO Instant format to allow calling Instant.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 a Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if given String is null.

DateTimeParseException - if given String can't be converted to a Instant.

AssertionError - if the actual Instant is not strictly before the Instant built from given String.

Since:

3.7.0

isBeforeOrEqualTo

public SELF isBeforeOrEqualTo(Instant other)

Verifies that the actual Instant 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 given Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if other Instant is null.

AssertionError - if the actual Instant is not before or equals to the given one.

Since:

3.7.0

isBeforeOrEqualTo

public SELF isBeforeOrEqualTo(String instantAsString)

Same assertion as isBeforeOrEqualTo(Instant) but the Instant is built from given String, which must follow ISO Instant format to allow calling Instant.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 a Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if given String is null.

DateTimeParseException - if given String can't be converted to a Instant.

AssertionError - if the actual Instant is not before or equals to the Instant built from given String.

Since:

3.7.0

isAfterOrEqualTo

public SELF isAfterOrEqualTo(Instant other)

Verifies that the actual Instant 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 given Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if other Instant is null.

AssertionError - if the actual Instant is not after or equals to the given one.

Since:

3.7.0

isAfterOrEqualTo

public SELF isAfterOrEqualTo(String instantAsString)

Same assertion as isAfterOrEqualTo(Instant) but the Instant is built from given String, which must follow ISO Instant format to allow calling Instant.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 a Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if given String is null.

DateTimeParseException - if given String can't be converted to a Instant.

AssertionError - if the actual Instant is not after or equals to the Instant built from given String.

Since:

3.7.0

isAfter

public SELF isAfter(Instant other)

Verifies that the actual Instant 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 given Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if other Instant is null.

AssertionError - if the actual Instant is not strictly after the given one.

Since:

3.7.0

isAfter

public SELF isAfter(String instantAsString)

Same assertion as isAfter(Instant) but the Instant is built from given a String that must follow ISO Instant format to allow calling Instant.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 a Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if given String is null.

DateTimeParseException - if given String can't be converted to a Instant.

AssertionError - if the actual Instant is not strictly after the Instant built from given String.

Since:

3.7.0

isEqualTo

public SELF isEqualTo(String instantAsString)

Same assertion as AbstractAssert.isEqualTo(Object) (where Object is expected to be Instant) but here you pass Instant String representation that must follow ISO Instant format to allow calling Instant.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 a Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if given String is null.

DateTimeParseException - if given String can't be converted to a Instant.

AssertionError - if the actual Instant is not equal to the Instant built from given String.

Since:

3.7.0

isNotEqualTo

public SELF isNotEqualTo(String instantAsString)

Same assertion as AbstractAssert.isNotEqualTo(Object) (where Object is expected to be Instant) but here you pass Instant String representation that must follow ISO Instant format to allow calling Instant.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 a Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if given String is null.

DateTimeParseException - if given String can't be converted to a Instant.

AssertionError - if the actual Instant is equal to the Instant built from given String.

Since:

3.7.0

isIn

public SELF isIn(String... instantsAsString)

Same assertion as AbstractAssert.isIn(Object...) (where Objects are expected to be Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.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 representing Instants.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if given Strings are null or empty.

DateTimeParseException - if one of the given String can't be converted to a Instant.

AssertionError - if the actual Instant is not in the Instants built from given Strings.

Since:

3.7.0

isNotIn

public SELF isNotIn(String... instantsAsString)

Same assertion as AbstractAssert.isNotIn(Object...) (where Objects are expected to be Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.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 a Instant.

Returns:

this assertion object.

Throws:

AssertionError - if the actual Instant is null.

IllegalArgumentException - if given Strings are null or empty.

DateTimeParseException - if one of the given String can't be converted to a Instant.

AssertionError - if the actual Instant is in the Instants built from given Strings.

Since:

3.7.0

isBetween

public SELF isBetween(Instant startInclusive,
                      Instant endInclusive)

Verifies that the actual Instant 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 is null.

NullPointerException - if start value is null.

NullPointerException - if end value is null.

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 as isBetween(Instant, Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.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 is null.

NullPointerException - if start value is null.

NullPointerException - if end value is null.

DateTimeParseException - if any of the given String can't be converted to a Instant.

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 actual Instant 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 is null.

NullPointerException - if start value is null.

NullPointerException - if end value is null.

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 as isStrictlyBetween(Instant, Instant) but here you pass Instant String representations that must follow ISO Instant format to allow calling Instant.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 is null.

NullPointerException - if start value is null.

NullPointerException - if end value is null.

DateTimeParseException - if any of the given String can't be converted to a Instant.

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 of TEMPORAL from a string representation in ISO date format.

Specified by:

parse in class AbstractTemporalAssert<SELF extends AbstractInstantAssert<SELF>,Instant>

Parameters:

instantAsString - the string to parse, not null

Returns:

the parsed TEMPORAL, not null