Package org.assertj.core.api

Class AbstractLocalDateTimeAssert<SELF extends AbstractLocalDateTimeAssert<SELF>>

java.lang.Object
org.assertj.core.api.AbstractAssert<SELF,LocalDateTime>
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, Nikolaos Georgiou

  • Field Details

    • NULL_LOCAL_DATE_TIME_PARAMETER_MESSAGE

      public static final String NULL_LOCAL_DATE_TIME_PARAMETER_MESSAGE
      See Also:

  • Constructor Details

    • AbstractLocalDateTimeAssert

      protected AbstractLocalDateTimeAssert(LocalDateTime actual, Class<?> selfType)
      Creates a new AbstractLocalDateTimeAssert.
      Parameters:
      actual - the actual value to verify
      selfType - the "self type"

  • Method Details

    • isBefore

      public SELF isBefore(LocalDateTime other)
      Verifies that the actual LocalDateTime is strictly before the given one according to the ChronoLocalDateTime.timeLineOrder() comparator which is consistent with LocalDateTime.isBefore(ChronoLocalDateTime).

      ChronoLocalDateTime.timeLineOrder() compares LocalDateTime in time-line order ignoring the chronology, this is equivalent to comparing the epoch-day and nano-of-day.

      This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

      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 according to the ChronoLocalDateTime.timeLineOrder() comparator which is consistent with LocalDateTime.isBefore(ChronoLocalDateTime).

      ChronoLocalDateTime.timeLineOrder() compares LocalDateTime in time-line order ignoring the chronology, this is equivalent to comparing the epoch-day and nano-of-day.

      This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

      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 according to the ChronoLocalDateTime.timeLineOrder() comparator which is consistent with LocalDateTime.isAfter(ChronoLocalDateTime).

      ChronoLocalDateTime.timeLineOrder() compares LocalDateTime in time-line order ignoring the chronology, this is equivalent to comparing the epoch-day and nano-of-day.

      This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

      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 according to the ChronoLocalDateTime.timeLineOrder() comparator which is consistent with LocalDateTime.isAfter(ChronoLocalDateTime).

      ChronoLocalDateTime.timeLineOrder() compares LocalDateTime in time-line order ignoring the chronology, this is equivalent to comparing the epoch-day and nano-of-day.

      This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

      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(Object other)
      Verifies that the actual LocalDateTime is equal to the given one according to the ChronoLocalDateTime.timeLineOrder() comparator which is consistent with LocalDateTime.isEqual(ChronoLocalDateTime).

      ChronoLocalDateTime.timeLineOrder() compares LocalDateTime in time-line order ignoring the chronology, this is equivalent to comparing the epoch-day and nano-of-day.

      This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

      Example : 

       assertThat(parse("2000-01-01T00:00:00")).isEqualTo(parse("2000-01-01T00:00:00"));
      Specified by:
      isEqualTo in interface Assert<SELF extends AbstractLocalDateTimeAssert<SELF>,LocalDateTime>
      Overrides:
      isEqualTo in class AbstractAssert<SELF extends AbstractLocalDateTimeAssert<SELF>,LocalDateTime>
      Parameters:
      other - the given LocalDateTime.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime differs from the given LocalDateTime according to the comparator in use.

    • isEqualTo

      public SELF isEqualTo(String dateTimeAsString)
      Same assertion as 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(Object other)
      Verifies that the actual LocalDateTime is not equal to the given one according to the ChronoLocalDateTime.timeLineOrder() comparator which is consistent with LocalDateTime.isEqual(ChronoLocalDateTime).

      ChronoLocalDateTime.timeLineOrder() compares LocalDateTime in time-line order ignoring the chronology, this is equivalent to comparing the epoch-day and nano-of-day.

      This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

      Example : 

       assertThat(parse("2000-01-01T00:00:00")).isEqualTo(parse("2000-01-01T00:00:00"));
      Specified by:
      isNotEqualTo in interface Assert<SELF extends AbstractLocalDateTimeAssert<SELF>,LocalDateTime>
      Overrides:
      isNotEqualTo in class AbstractAssert<SELF extends AbstractLocalDateTimeAssert<SELF>,LocalDateTime>
      Parameters:
      other - the given value to compare the actual value to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime equals to the given LocalDateTime according to the comparator in use.

    • isNotEqualTo

      public SELF isNotEqualTo(String dateTimeAsString)
      Same assertion as 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.

    • isCloseToUtcNow

      public SELF isCloseToUtcNow(TemporalUnitOffset offset)
      Verifies that the actual LocalDateTime is close to the current date and time on the UTC timezone, according to the given TemporalUnitOffset. You can build the offset parameter using Assertions.within(long, TemporalUnit) or Assertions.byLessThan(long, TemporalUnit).

      If the difference is equal to the offset, the assertion succeeds.

      Example: 

       LocalDateTime actual = LocalDateTime.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 - if offset parameter is null.
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not close to the current time by less than the given offset.

    • usingDefaultComparator

      public SELF usingDefaultComparator()
      Revert to standard comparison for the incoming assertion checks.

      This method should be used to disable a custom comparison strategy set by calling usingComparator.

      Specified by:
      usingDefaultComparator in interface Assert<SELF extends AbstractLocalDateTimeAssert<SELF>,LocalDateTime>
      Overrides:
      usingDefaultComparator in class AbstractTemporalAssert<SELF extends AbstractLocalDateTimeAssert<SELF>,LocalDateTime>
      Returns:
      this assertion object.

    • 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

      @Deprecated public SELF isEqualToIgnoringSeconds(LocalDateTime other)
      Deprecated.
      Use isCloseTo(LocalDateTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      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

      @Deprecated public SELF isEqualToIgnoringMinutes(LocalDateTime other)
      Deprecated.
      Use isCloseTo(LocalDateTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      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

      @Deprecated public SELF isEqualToIgnoringHours(LocalDateTime other)
      Deprecated.
      Use isCloseTo(LocalDateTime, TemporalOffset) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      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.

    • isInThePast

      public SELF isInThePast()
      Verifies that the actual LocalDateTime is strictly in the past.

      Example: 

       // assertion succeeds:
 assertThat(LocalDateTime.now().minusMinutes(1)).isInThePast();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not in the past.
      Since:
      3.25.0

    • isInTheFuture

      public SELF isInTheFuture()
      Verifies that the actual LocalDateTime is strictly in the future.

      Example: 

       // assertion succeeds:
 assertThat(LocalDateTime.now().plusMinutes(1)).isInTheFuture();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not in the future.
      Since:
      3.25.0

    • isBetween

      public SELF isBetween(LocalDateTime startInclusive, LocalDateTime endInclusive)
      Verifies that the actual LocalDateTime is in the [start, end] period (start and end included) according to the ChronoLocalDateTime.timeLineOrder() comparator.

      ChronoLocalDateTime.timeLineOrder() compares LocalDateTime in time-line order ignoring the chronology, this is equivalent to comparing the epoch-day and nano-of-day.

      This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

      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) according to the ChronoLocalDateTime.timeLineOrder() comparator.

      ChronoLocalDateTime.timeLineOrder() compares LocalDateTime in time-line order ignoring the chronology, this is equivalent to comparing the epoch-day and nano-of-day.

      This behaviour can be overridden by AbstractTemporalAssert.usingComparator(Comparator).

      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

    • hasYear

      public SELF hasYear(int year)
      Verifies that actual LocalDateTime is in the given year.

      Example: 

       // Assertion succeeds:
 assertThat(LocalDateTime.of(2002, 1, 1, 0, 0, 0)).hasYear(2002);

 // Assertion fails:
 assertThat(LocalDate.of(2002, 1, 1, 0, 0, 0)).hasYear(2001);
      Parameters:
      year - the given year.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not in the given year.
      Since:
      3.23.0

    • hasMonth

      public SELF hasMonth(Month month)
      Verifies that actual LocalDateTime is in the given Month.

      Example: 

       // Assertion succeeds:
 assertThat(LocalDateTime.of(2022, Month.APRIL, 16, 20, 18, 59)).hasMonth(Month.APRIL);

 // Assertion fails:
 assertThat(LocalDateTime.of(2022, Month.APRIL, 16, 20, 18, 59)).hasMonth(Month.MAY);
      Parameters:
      month - the given Month.
      Returns:
      this assertion object.
      Throws:
      IllegalArgumentException - if the given Month is null.
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not in the given Month.
      Since:
      3.23.0

    • hasMonthValue

      public SELF hasMonthValue(int monthVal)
      Verifies that actual LocalDateTime has same month value.

      Example: 

       // Assertion succeeds:
 assertThat(LocalDateTime.of(2000, 12, 31, 23, 59, 59)).hasMonthValue(12);

 // Assertion fails:
 assertThat(LocalDateTime.of(2000, 12, 31, 23, 59, 59)).hasMonthValue(3);
      Parameters:
      monthVal - the given month value between 1 and 12 inclusive.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not equal with month field.
      Since:
      3.23.0

    • hasDayOfMonth

      public SELF hasDayOfMonth(int dayOfMonth)
      Verifies that actual LocalDateTime is in the given day of month.

      Example: 

       // Assertion succeeds:
 assertThat(LocalDateTime.of(2002, 1, 1, 0, 0, 0)).hasDayOfMonth(1);

 // Assertion fails:
 assertThat(LocalDate.of(2002, 1, 1, 0, 0, 0)).hasDayOfMonth(2);
      Parameters:
      dayOfMonth - the given numeric day.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not in the given day of month.
      Since:
      3.23.0

    • hasHour

      public SELF hasHour(int hour)
      Verifies that actual LocalDateTime is in the given hour.

      Example: 

       // Assertion succeeds:
 assertThat(LocalDateTime.of(2021, 12, 31, 23, 59, 59)).hasHour(23);

 // Assertion fails:
 assertThat(LocalDateTime.of(2021, 12, 31, 23, 59, 59)).hasHour(22);
      Parameters:
      hour - the given hour.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not in the given hour.
      Since:
      3.23.0

    • hasMinute

      public SELF hasMinute(int minute)
      Verifies that actual LocalDateTime is in the given minute.

      Example: 

       // Assertion succeeds:
 assertThat(LocalDateTime.of(2021, 12, 31, 23, 59, 00)).hasMinute(59);

 // Assertion fails:
 assertThat(LocalDateTime.of(2021, 12, 31, 23, 59, 00)).hasMinute(58);
      Parameters:
      minute - the given minute.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not in the given minute.
      Since:
      3.23.0

    • hasSecond

      public SELF hasSecond(int second)
      Verifies that actual LocalDateTime is in the given second.

      Example: 

       // Assertion succeeds:
 assertThat(LocalDateTime.of(2021, 12, 31, 23, 59, 00)).hasSecond(00);

 // Assertion fails:
 assertThat(LocalDateTime.of(2021, 12, 31, 23, 59, 00)).hasSecond(17);
      Parameters:
      second - the given second.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not in the given second.
      Since:
      3.23.0

    • hasNano

      public SELF hasNano(int nano)
      Verifies that actual LocalDateTime is in the given nanosecond.

      Example: 

       // Assertion succeeds:
 assertThat(LocalDateTime.of(2021, 12, 31, 23, 59, 15)).hasNano(15);

 // Assertion fails:
 assertThat(LocalDateTime.of(2021, 12, 31, 23, 59, 00)).hasNano(15);
      Parameters:
      nano - the given second.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not in the given nanosecond.
      Since:
      3.23.0

    • isCloseTo

      public SELF isCloseTo(LocalDateTime other, TemporalOffset<? super LocalDateTime> offset)
      Verifies that the actual LocalDateTime is close to the other according to the given TemporalOffset.

      You can build the offset parameter using Assertions.within(long, TemporalUnit) or Assertions.byLessThan(long, TemporalUnit).

      Example: 

       LocalDateTime localDateTime = LocalDateTime.now();

 // assertion succeeds:
 assertThat(localDateTime).isCloseTo(localDateTime.plusHours(1), within(32, ChronoUnit.MINUTES));

 // assertion fails:
 assertThat(localDateTime).isCloseTo(localDateTime.plusHours(1), within(10, ChronoUnit.SECONDS));
      Overrides:
      isCloseTo in class AbstractTemporalAssert<SELF extends AbstractLocalDateTimeAssert<SELF>,LocalDateTime>
      Parameters:
      other - the localDateTime to compare actual to
      offset - the offset used for comparison
      Returns:
      this assertion object
      Throws:
      NullPointerException - if LocalDateTime or TemporalOffset parameter is null.
      AssertionError - if the actual LocalDateTime is null.
      AssertionError - if the actual LocalDateTime is not close to the given one for a provided offset.

    • 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