AbstractLocalDateTimeAssert (AssertJ fluent assertions 3.12.0 API)

java.lang.Object
- org.assertj.core.api.AbstractAssert<SELF,TEMPORAL>
- - org.assertj.core.api.AbstractTemporalAssert<SELF,LocalDateTime>
  - - org.assertj.core.api.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
```
public abstract class AbstractLocalDateTimeAssert<SELF extends AbstractLocalDateTimeAssert<SELF>>
extends AbstractTemporalAssert<SELF,LocalDateTime>
```
Assertions for LocalDateTime type from new Date & Time API introduced in Java 8.

Author:

Paweł Stawicki, Joel Costigliola, Marcin Zajączkowski

Field Summary

Fields
Modifier and Type Field and Description

static String NULL_LOCAL_DATE_TIME_PARAMETER_MESSAGE
- Fields inherited from class org.assertj.core.api.AbstractAssert
  actual, info, myself, throwUnsupportedExceptionOnEquals

Fields
Modifier and Type	Field and Description
`static String`	`NULL_LOCAL_DATE_TIME_PARAMETER_MESSAGE`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractLocalDateTimeAssert(LocalDateTime actual, Class<?> selfType)` Creates a new `AbstractLocalDateTimeAssert`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`SELF`	`isAfter(LocalDateTime other)` Verifies that the actual `LocalDateTime` is strictly after the given one.
`SELF`	`isAfter(String localDateTimeAsString)` Same assertion as `isAfter(LocalDateTime)` but the `LocalDateTime` is built from given a String that must follow ISO LocalDateTime format to allow calling `LocalDateTime.parse(CharSequence)` method.
`SELF`	`isAfterOrEqualTo(LocalDateTime other)` Verifies that the actual `LocalDateTime` is after or equals to the given one.
`SELF`	`isAfterOrEqualTo(String localDateTimeAsString)` Same assertion as `isAfterOrEqualTo(LocalDateTime)` but the `LocalDateTime` is built from given String, which must follow ISO LocalDateTime format to allow calling `LocalDateTime.parse(CharSequence)` method.
`SELF`	`isBefore(LocalDateTime other)` Verifies that the actual `LocalDateTime` is strictly before the given one.
`SELF`	`isBefore(String localDateTimeAsString)` Same assertion as `isBefore(LocalDateTime)` but the `LocalDateTime` is built from given String, which must follow ISO LocalDateTime format to allow calling `LocalDateTime.parse(CharSequence)` method.
`SELF`	`isBeforeOrEqualTo(LocalDateTime other)` Verifies that the actual `LocalDateTime` is before or equals to the given one.
`SELF`	`isBeforeOrEqualTo(String localDateTimeAsString)` Same assertion as `isBeforeOrEqualTo(LocalDateTime)` but the `LocalDateTime` is built from given String, which must follow ISO LocalDateTime format to allow calling `LocalDateTime.parse(CharSequence)` method.
`SELF`	`isBetween(LocalDateTime startInclusive, LocalDateTime endInclusive)` Verifies that the actual `LocalDateTime` is in the [start, end] period (start and end included).
`SELF`	`isBetween(String startInclusive, String endInclusive)` Same assertion as `isBetween(LocalDateTime, LocalDateTime)` but here you pass `LocalDateTime` String representations which must follow ISO LocalDateTime format to allow calling `LocalDateTime.parse(CharSequence)` method.
`SELF`	`isEqualTo(String dateTimeAsString)` Same assertion as `AbstractAssert.isEqualTo(Object)` (where Object is expected to be `LocalDateTime`) but here you pass `LocalDateTime` String representation that must follow ISO LocalDateTime format to allow calling `LocalDateTime.parse(CharSequence)` method.
`SELF`	`isEqualToIgnoringHours(LocalDateTime other)` Verifies that actual and given `LocalDateTime` have same year, month and day fields (hour, minute, second and nanosecond fields are ignored in comparison).
`SELF`	`isEqualToIgnoringMinutes(LocalDateTime other)` Verifies that actual and given `LocalDateTime` have same year, month, day and hour fields (minute, second and nanosecond fields are ignored in comparison).
`SELF`	`isEqualToIgnoringNanos(LocalDateTime other)` Verifies that actual and given `LocalDateTime` have same year, month, day, hour, minute and second fields, (nanosecond fields are ignored in comparison).
`SELF`	`isEqualToIgnoringSeconds(LocalDateTime other)` Verifies that actual and given `LocalDateTime` have same year, month, day, hour and minute fields (second and nanosecond fields are ignored in comparison).
`SELF`	`isIn(String... dateTimesAsString)` Same assertion as `AbstractAssert.isIn(Object...)` (where Objects are expected to be `LocalDateTime`) but here you pass `LocalDateTime` String representations that must follow ISO LocalDateTime format to allow calling `LocalDateTime.parse(CharSequence)` method.
`SELF`	`isNotEqualTo(String dateTimeAsString)` Same assertion as `AbstractAssert.isNotEqualTo(Object)` (where Object is expected to be `LocalDateTime`) but here you pass `LocalDateTime` String representation that must follow ISO LocalDateTime format to allow calling `LocalDateTime.parse(CharSequence)` method.
`SELF`	`isNotIn(String... dateTimesAsString)` Same assertion as `AbstractAssert.isNotIn(Object...)` (where Objects are expected to be `LocalDateTime`) but here you pass `LocalDateTime` String representations that must follow ISO LocalDateTime format to allow calling `LocalDateTime.parse(CharSequence)` method.
`SELF`	`isStrictlyBetween(LocalDateTime startExclusive, LocalDateTime endExclusive)` Verifies that the actual `LocalDateTime` is in the ]start, end[ period (start and end excluded).
`SELF`	`isStrictlyBetween(String startExclusive, String endExclusive)` Same assertion as `isStrictlyBetween(LocalDateTime, LocalDateTime)` but here you pass `LocalDateTime` String representations which must follow ISO LocalDateTime format to allow calling `LocalDateTime.parse(CharSequence)` method.
`protected LocalDateTime`	`parse(String localDateTimeAsString)` 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

- Field Detail
  - NULL_LOCAL_DATE_TIME_PARAMETER_MESSAGE
```
public static final String NULL_LOCAL_DATE_TIME_PARAMETER_MESSAGE
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - AbstractLocalDateTimeAssert
```
protected AbstractLocalDateTimeAssert(LocalDateTime actual,
                                      Class<?> selfType)
```
    Creates a new AbstractLocalDateTimeAssert.
    
    Parameters:
    
    selfType - the "self type"
    
    actual - the actual value to verify
- Method Detail
  - isBefore
```
public SELF isBefore(LocalDateTime other)
```
    Verifies that the actual LocalDateTime is strictly before the given one.
    Example :
```
 assertThat(parse("2000-01-01T23:59:59")).isBefore(parse("2000-01-02T00:00:00"));
```
    Parameters:
    
    other - the given LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if other LocalDateTime is null.
    
    AssertionError - if the actual LocalDateTime is not strictly before the given one.
  - isBefore
```
public SELF isBefore(String localDateTimeAsString)
```
    Same assertion as isBefore(LocalDateTime) but the LocalDateTime is built from given String, which must follow ISO LocalDateTime format to allow calling LocalDateTime.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 a LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if given String is null or can't be converted to a LocalDateTime.
    
    AssertionError - if the actual LocalDateTime is not strictly before the LocalDateTime built from given String.
  - isBeforeOrEqualTo
```
public SELF isBeforeOrEqualTo(LocalDateTime other)
```
    Verifies that the actual LocalDateTime 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 given LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if other LocalDateTime is null.
    
    AssertionError - if the actual LocalDateTime is not before or equals to the given one.
  - isBeforeOrEqualTo
```
public SELF isBeforeOrEqualTo(String localDateTimeAsString)
```
    Same assertion as isBeforeOrEqualTo(LocalDateTime) but the LocalDateTime is built from given String, which must follow ISO LocalDateTime format to allow calling LocalDateTime.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 a LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if given String is null or can't be converted to a LocalDateTime.
    
    AssertionError - if the actual LocalDateTime is not before or equals to the LocalDateTime built from given String.
  - isAfterOrEqualTo
```
public SELF isAfterOrEqualTo(LocalDateTime other)
```
    Verifies that the actual LocalDateTime 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 given LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if other LocalDateTime is null.
    
    AssertionError - if the actual LocalDateTime is not after or equals to the given one.
  - isAfterOrEqualTo
```
public SELF isAfterOrEqualTo(String localDateTimeAsString)
```
    Same assertion as isAfterOrEqualTo(LocalDateTime) but the LocalDateTime is built from given String, which must follow ISO LocalDateTime format to allow calling LocalDateTime.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 a LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if given String is null or can't be converted to a LocalDateTime.
    
    AssertionError - if the actual LocalDateTime is not after or equals to the LocalDateTime built from given String.
  - isAfter
```
public SELF isAfter(LocalDateTime other)
```
    Verifies that the actual LocalDateTime is strictly after the given one.
    Example :
```
 assertThat(parse("2000-01-01T00:00:00")).isAfter(parse("1999-12-31T23:59:59"));
```
    Parameters:
    
    other - the given LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if other LocalDateTime is null.
    
    AssertionError - if the actual LocalDateTime is not strictly after the given one.
  - isAfter
```
public SELF isAfter(String localDateTimeAsString)
```
    Same assertion as isAfter(LocalDateTime) but the LocalDateTime is built from given a String that must follow ISO LocalDateTime format to allow calling LocalDateTime.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 a LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if given String is null or can't be converted to a LocalDateTime.
    
    AssertionError - if the actual LocalDateTime is not strictly after the LocalDateTime built from given String.
  - isEqualTo
```
public SELF isEqualTo(String dateTimeAsString)
```
    Same assertion as AbstractAssert.isEqualTo(Object) (where Object is expected to be LocalDateTime) but here you pass LocalDateTime String representation that must follow ISO LocalDateTime format to allow calling LocalDateTime.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 a LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if given String is null or can't be converted to a LocalDateTime.
    
    AssertionError - if the actual LocalDateTime is not equal to the LocalDateTime built from given String.
  - isNotEqualTo
```
public SELF isNotEqualTo(String dateTimeAsString)
```
    Same assertion as AbstractAssert.isNotEqualTo(Object) (where Object is expected to be LocalDateTime) but here you pass LocalDateTime String representation that must follow ISO LocalDateTime format to allow calling LocalDateTime.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 a LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if given String is null or can't be converted to a LocalDateTime.
    
    AssertionError - if the actual LocalDateTime is equal to the LocalDateTime built from given String.
  - isIn
```
public SELF isIn(String... dateTimesAsString)
```
    Same assertion as AbstractAssert.isIn(Object...) (where Objects are expected to be LocalDateTime) but here you pass LocalDateTime String representations that must follow ISO LocalDateTime format to allow calling LocalDateTime.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 representing LocalDateTimes.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if given String is null or can't be converted to a LocalDateTime.
    
    AssertionError - if the actual LocalDateTime is not in the LocalDateTimes built from given Strings.
  - isNotIn
```
public SELF isNotIn(String... dateTimesAsString)
```
    Same assertion as AbstractAssert.isNotIn(Object...) (where Objects are expected to be LocalDateTime) but here you pass LocalDateTime String representations that must follow ISO LocalDateTime format to allow calling LocalDateTime.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 a LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if given String is null or can't be converted to a LocalDateTime.
    
    AssertionError - if the actual LocalDateTime is in the LocalDateTimes built from given Strings.
  - isEqualToIgnoringNanos
```
public SELF isEqualToIgnoringNanos(LocalDateTime other)
```
    Verifies that actual and given LocalDateTime 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 given LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if other LocalDateTime is null.
    
    AssertionError - if the actual LocalDateTime is are not equal with nanoseconds ignored.
  - isEqualToIgnoringSeconds
```
public SELF isEqualToIgnoringSeconds(LocalDateTime other)
```
    Verifies that actual and given LocalDateTime 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 given LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if other LocalDateTime is null.
    
    AssertionError - if the actual LocalDateTime is are not equal with second and nanosecond fields ignored.
  - isEqualToIgnoringMinutes
```
public SELF isEqualToIgnoringMinutes(LocalDateTime other)
```
    Verifies that actual and given LocalDateTime 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 given LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if other LocalDateTime is null.
    
    AssertionError - if the actual LocalDateTime is are not equal ignoring minute, second and nanosecond fields.
  - isEqualToIgnoringHours
```
public SELF isEqualToIgnoringHours(LocalDateTime other)
```
    Verifies that actual and given LocalDateTime 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 given LocalDateTime.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual LocalDateTime is null.
    
    IllegalArgumentException - if other LocalDateTime is null.
    
    AssertionError - if the actual LocalDateTime is are not equal with second and nanosecond fields ignored.
  - isBetween
```
public SELF isBetween(LocalDateTime startInclusive,
                      LocalDateTime endInclusive)
```
    Verifies that the actual LocalDateTime 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 is null.
    
    NullPointerException - if start value is null.
    
    NullPointerException - if end value is null.
    
    AssertionError - if the actual value is not in [start, end] period.
    
    Since:
    
    3.7.1
  - isBetween
```
public SELF isBetween(String startInclusive,
                      String endInclusive)
```
    Same assertion as isBetween(LocalDateTime, LocalDateTime) but here you pass LocalDateTime String representations which must follow ISO LocalDateTime format to allow calling LocalDateTime.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 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 LocalDateTime.
    
    AssertionError - if the actual value is not in [start, end] period.
    
    Since:
    
    3.7.1
  - isStrictlyBetween
```
public SELF isStrictlyBetween(LocalDateTime startExclusive,
                              LocalDateTime endExclusive)
```
    Verifies that the actual LocalDateTime 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:
    
    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[ period.
    
    Since:
    
    3.7.1
  - isStrictlyBetween
```
public SELF isStrictlyBetween(String startExclusive,
                              String endExclusive)
```
    Same assertion as isStrictlyBetween(LocalDateTime, LocalDateTime) but here you pass LocalDateTime String representations which must follow ISO LocalDateTime format to allow calling LocalDateTime.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:
    
    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 LocalDateTime.
    
    AssertionError - if the actual value is not in ]start, end[ period.
    
    Since:
    
    3.7.1
  - parse
```
protected LocalDateTime parse(String localDateTimeAsString)
```
    Obtains an instance of TEMPORAL from a string representation in ISO date format.
    
    Specified by:
    
    parse in class AbstractTemporalAssert<SELF extends AbstractLocalDateTimeAssert<SELF>,LocalDateTime>
    
    Parameters:
    
    localDateTimeAsString - the string to parse, not null
    
    Returns:
    
    the parsed TEMPORAL, not null

Class AbstractLocalDateTimeAssert<SELF extends AbstractLocalDateTimeAssert<SELF>>

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class org.assertj.core.api.AbstractTemporalAssert

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

Methods inherited from class java.lang.Object

Field Detail

NULL_LOCAL_DATE_TIME_PARAMETER_MESSAGE

Constructor Detail

AbstractLocalDateTimeAssert

Method Detail

isBefore

isBefore

isBeforeOrEqualTo

isBeforeOrEqualTo

isAfterOrEqualTo

isAfterOrEqualTo

isAfter

isAfter

isEqualTo

isNotEqualTo

isIn

isNotIn

isEqualToIgnoringNanos

isEqualToIgnoringSeconds

isEqualToIgnoringMinutes

isEqualToIgnoringHours

isBetween

isBetween

isStrictlyBetween

isStrictlyBetween

parse