Package org.assertj.core.api

Class AbstractDateAssert<SELF extends AbstractDateAssert<SELF>>

java.lang.Object
org.assertj.core.api.AbstractAssert<SELF,Date>
org.assertj.core.api.AbstractDateAssert<SELF>
Type Parameters:
SELF - the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.
All Implemented Interfaces:
Assert<SELF,Date>, Descriptable<SELF>, ExtensionPoints<SELF,Date>
Direct Known Subclasses:
DateAssert
public abstract class AbstractDateAssert<SELF extends AbstractDateAssert<SELF>> extends AbstractAssert<SELF,Date>
Base class for all implementations of assertions for Dates.

Note that assertions with date parameter comes with two flavor, one is obviously a Date and the other is a String representing a Date.
For the latter, the default format follows ISO 8901 : "yyyy-MM-dd", user can override it with a custom format by calling withDateFormat(DateFormat).
The user custom format will then be used for all next Date assertions (i.e not limited to the current assertion) in the test suite.
To turn back to default format, simply call withDefaultDateFormatsOnly().

Author:
Tomasz Nurkiewicz (thanks for giving assertions idea), Joel Costigliola, Mikhail Mazursky, William Delanoue, Michal Kordas, Eddú Meléndez

  • Constructor Details

    • AbstractDateAssert

      protected AbstractDateAssert(Date actual, Class<?> selfType)

  • Method Details

    • isEqualTo

      public SELF isEqualTo(String dateAsString)
      Same assertion as isEqualTo(Date date) but given date is represented as a String either with one of the supported defaults date format or a user custom date format set with method withDateFormat(DateFormat).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isEqualTo("2002-12-18");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isEqualTo("2002-12-19");

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual and given Date represented as String are not equal.
      AssertionError - if the given date as String could not be converted to a Date.

    • isEqualTo

      public SELF isEqualTo(Instant instant)
      Calls isEqualTo(Date date) after converting the given Instant to a Date.

      Example: 

       // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isEqualTo(Instant.parse("2002-12-18T00:00:00.00Z"));
      Parameters:
      instant - the given Instant to compare to actual.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if given Instant is null.
      AssertionError - if actual Date and given Instant are not equal (after converting instant to a Date).

    • isEqualToIgnoringHours

      @Deprecated public SELF isEqualToIgnoringHours(String dateAsString)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isEqualToIgnoringHours(Date) but given Date is represented as String either with one of the default supported date format or user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // OK : all dates fields are the same up to minutes excluded
 assertThat("2003-04-26T13:01:35").isEqualToIgnoringHours("2003-04-26T14:02:35");

 // KO : fail as day fields differ
 assertThat("2003-04-26T14:01:35").isEqualToIgnoringHours("2003-04-27T13:02:35")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual and given Date represented as String are not equal ignoring hours, minutes, seconds and milliseconds.
      AssertionError - if the given date as String could not be converted to a Date.

    • isEqualToIgnoringHours

      @Deprecated public SELF isEqualToIgnoringHours(Instant instant)
      Deprecated.
      Use isCloseTo(Instant, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isEqualToIgnoringHours(Date) but given Date is represented as an java.time.Instant.

      Example: 

       assertThat(new Date()).isEqualToIgnoringHours(Instant.now());
      Parameters:
      instant - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual Date and given Instant are not equal ignoring hours, minutes, seconds and milliseconds.
      Since:
      3.19.0

    • isEqualToIgnoringHours

      @Deprecated public SELF isEqualToIgnoringHours(Date date)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as AbstractAssert.isEqualTo(Object) but the comparison ignores hours, minutes, seconds and milliseconds.

      Example: 

       Date date1 = parseDatetime("2003-04-26T13:01:35");
 Date date2 = parseDatetime("2003-04-26T14:01:00");
 Date date3 = parseDatetime("2003-04-27T13:01:35");

 // OK : all dates fields are the same up to hours excluded
 assertThat(date1).isEqualToIgnoringHours(date2);

 // KO : fail as day fields differ
 assertThat(date1).isEqualToIgnoringHours(date3);
      Parameters:
      date - the given Date.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual and given Date represented as String are not equal ignoring hours, minutes, seconds and milliseconds.
      AssertionError - if the given date as String could not be converted to a Date.

    • isEqualToIgnoringMinutes

      @Deprecated public SELF isEqualToIgnoringMinutes(String dateAsString)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isEqualToIgnoringMinutes(Date) but given Date is represented as String either with one of the default supported date format or user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       withDateFormat("yyyy-MM-dd'T'HH:mm:ss");
 // OK : all dates fields are the same up to minutes excluded
 assertThat("2003-04-26T13:01:35").isEqualToIgnoringMinutes("2003-04-26T13:02:35");

 // KO : fail as hour fields differ
 assertThat("2003-04-26T14:01:35").isEqualToIgnoringMinutes("2003-04-26T13:02:35")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual and given Date represented as String are not equal ignoring minutes, seconds and milliseconds.
      AssertionError - if the given date as String could not be converted to a Date.

    • isEqualToIgnoringMinutes

      @Deprecated public SELF isEqualToIgnoringMinutes(Instant instant)
      Deprecated.
      Use isCloseTo(Instant, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isEqualToIgnoringMinutes(Date) but given Date is represented as an java.time.Instant.

      Example: 

       assertThat(new Date()).isEqualToIgnoringMinutes(Instant.now());
      Parameters:
      instant - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual Date and given Instant are not equal ignoring minutes, seconds and milliseconds.
      Since:
      3.19.0

    • isEqualToIgnoringMinutes

      @Deprecated public SELF isEqualToIgnoringMinutes(Date date)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as AbstractAssert.isEqualTo(Object) but given Date should not take care of minutes, seconds and milliseconds precision.

      Example: 

       Date date1 = parseDatetime("2003-04-26T13:01:35");
 Date date2 = parseDatetime("2003-04-26T13:02:00");
 Date date3 = parseDatetime("2003-04-26T14:02:00");

 // OK : all dates fields are the same up to minutes excluded
 assertThat(date1).isEqualToIgnoringMinutes(date2);

 // KO : fail as hour fields differ
 assertThat(date1).isEqualToIgnoringMinutes(date3);
      Parameters:
      date - the given Date.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual and given Date represented as String are not equal ignoring minutes, seconds and milliseconds.
      AssertionError - if the given date as String could not be converted to a Date.

    • isEqualToIgnoringSeconds

      @Deprecated public SELF isEqualToIgnoringSeconds(String dateAsString)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isEqualToIgnoringSeconds(Date) but given Date is represented as String either with one of the default supported date format or user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       Date date1 = parseDatetime("2003-04-26T13:01:35");

 // OK : all dates fields are the same up to seconds excluded
 assertThat(date1).isEqualToIgnoringSeconds("2003-04-26T13:01:57");

 // KO : fail as minute fields differ
 assertThat(date1).isEqualToIgnoringMinutes("2003-04-26T13:02:00")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual and given Date represented as String are not equal ignoring seconds and milliseconds.
      AssertionError - if the given date as String could not be converted to a Date.

    • isEqualToIgnoringSeconds

      @Deprecated public SELF isEqualToIgnoringSeconds(Instant instant)
      Deprecated.
      Use isCloseTo(Instant, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isEqualToIgnoringSeconds(Date) but given Date is represented as an java.time.Instant.

      Example: 

       assertThat(new Date()).isEqualToIgnoringSeconds(Instant.now());
      Parameters:
      instant - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual Date and given Instant are not equal ignoring seconds and milliseconds.
      Since:
      3.19.0

    • isEqualToIgnoringSeconds

      @Deprecated public SELF isEqualToIgnoringSeconds(Date date)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as AbstractAssert.isEqualTo(Object) but given Date should not take care of seconds and milliseconds precision.

      Example: 

       Date date1 = parseDatetime("2003-04-26T13:01:35");
 Date date2 = parseDatetime("2003-04-26T13:01:36");

 // OK : all dates fields are the same up to seconds excluded
 assertThat(date1).isEqualToIgnoringSeconds(date2);

 // KO : fail as minute fields differ
 Date date3 = parseDatetime("2003-04-26T13:02:00");
 assertThat(date1).isEqualToIgnoringSeconds(date3);
      Parameters:
      date - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual and given Date represented as String are not equal ignoring seconds and milliseconds.
      AssertionError - if the given date as String could not be converted to a Date.

    • isEqualToIgnoringMillis

      @Deprecated public SELF isEqualToIgnoringMillis(String dateAsString)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isEqualToIgnoringMillis(Date) but given Date is represented as String either with one of the default supported date format or user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       Date date1 = parseDatetimeWithMs("2003-04-26T13:01:35.998");

 // OK : all dates fields are the same up to milliseconds excluded
 assertThat().isEqualToIgnoringMillis("2003-04-26T13:01:35.997");

 // KO : fail as seconds fields differ
 assertThat("2003-04-26T13:01:35.998").isEqualToIgnoringMinutes("2003-04-26T13:01:36.998")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual and given Date represented as String are not equal ignoring milliseconds.
      AssertionError - if the given date as String could not be converted to a Date.

    • isEqualToIgnoringMillis

      @Deprecated public SELF isEqualToIgnoringMillis(Instant instant)
      Deprecated.
      Use isCloseTo(Instant, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isEqualToIgnoringMillis(Date) but given Date is represented as an java.time.Instant.

      Example: 

       assertThat(new Date()).isEqualToIgnoringMillis(Instant.now());
      Parameters:
      instant - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual Date and given Instant are not equal ignoring milliseconds.
      Since:
      3.19.0

    • isEqualToIgnoringMillis

      @Deprecated public SELF isEqualToIgnoringMillis(Date date)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as AbstractAssert.isEqualTo(Object) but given Date should not take care of milliseconds precision.

      Example: 

       Date date1 = parseDatetimeAndMs("2003-04-26T13:01:35.001");
 Date date2 = parseDatetimeAndMs("2003-04-26T13:01:35.002");
 Date date3 = parseDatetimeAndMs("2003-04-26T14:01:36.001");

 // OK : all dates fields are the same up to milliseconds excluded
 assertThat(date1).isEqualToIgnoringMillis(date2);

 // KO : fail as second fields differ
 assertThat(date1).isEqualToIgnoringMillis(date3);
      Parameters:
      date - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual and given Date represented as String are not equal ignoring milliseconds.
      AssertionError - if the given date as String could not be converted to a Date.

    • isNotEqualTo

      public SELF isNotEqualTo(String dateAsString)
      Same assertion as isNotEqualTo(Date date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isNotEqualTo("2002-12-19");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isNotEqualTo("2002-12-18")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual and given Date represented as String are equal.
      AssertionError - if the given date as String could not be converted to a Date.

    • isNotEqualTo

      public SELF isNotEqualTo(Instant instant)
      Same assertion as isNotEqualTo(Date date) but given date is represented as an java.time.Instant.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isNotEqualTo(Instant.now());
      Parameters:
      instant - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual Date and given Instant are equal.
      Since:
      3.19.0

    • isIn

      public SELF isIn(String... datesAsString)
      Same assertion as Assert.isIn(Object...)but given dates are represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isIn("2002-12-17", "2002-12-18", "2002-12-19");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isIn("2002-12-17", "2002-12-19", "2002-12-20")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      datesAsString - the given Dates represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is not in given Dates represented as String.
      AssertionError - if one of the given date as String could not be converted to a Date.

    • isIn

      public SELF isIn(Instant... instants)
      Same assertion as Assert.isIn(Object...)but given dates are represented as an java.time.Instant.

      Example: 

       // assertion will fail
 // theTwoTowers release date : 2002-12-18
 Instant now = Instant.now()
 assertThat(theTwoTowers.getReleaseDate()).isIn(now, now.plusSeconds(5), now.minusSeconds(5));
      Parameters:
      instants - the given dates represented as Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is not in given dates represented as Instant.

    • isInWithStringDateCollection

      public SELF isInWithStringDateCollection(Collection<String> datesAsString)
      Same assertion as Assert.isIn(Iterable) but given dates are represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isInWithStringDateCollection(asList("2002-12-17", "2002-12-18", "2002-12-19"));

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isInWithStringDateCollection(asList("2002-12-17", "2002-12-19", "2002-12-20"))

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Method signature could not be isIn(Collection<String>) because it would be same signature as isIn(Collection<Date>) since java collection type are erased at runtime.

      Parameters:
      datesAsString - the given Dates represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is not in given Dates represented as String.
      AssertionError - if one of the given date as String could not be converted to a Date.

    • isNotIn

      public SELF isNotIn(String... datesAsString)
      Same assertion as Assert.isNotIn(Object...) but given dates are represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isNotIn("2002-12-17", "2002-12-19");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isNotIn("2002-12-17", "2002-12-18")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      datesAsString - the given Dates represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is in given Dates represented as String.
      AssertionError - if one of the given date as String could not be converted to a Date.

    • isNotIn

      public SELF isNotIn(Instant... instants)
      Same assertion as Assert.isNotIn(Object...) but given dates are represented as java.time.Instant.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 Instant now = Instant.now()
 assertThat(theTwoTowers.getReleaseDate()).isIn(now, now.plusSeconds(5), now.minusSeconds(5));
      Parameters:
      instants - the given dates represented as Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is not in given dates represented as Instant.
      Since:
      3.19.0

    • isNotInWithStringDateCollection

      public SELF isNotInWithStringDateCollection(Collection<String> datesAsString)
      Same assertion as Assert.isNotIn(Iterable) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isNotInWithStringDateCollection(Arrays.asList("2002-12-17", "2002-12-19"));

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isNotInWithStringDateCollection(Arrays.asList("2002-12-17", "2002-12-18"))

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed. Method signature could not be isNotIn(Collection<String>) because it would be same signature as isNotIn(Collection<Date>) since java collection type are erased at runtime.

      Parameters:
      datesAsString - the given Dates represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is in given Dates represented as String.
      AssertionError - if one of the given date as String could not be converted to a Date.

    • isBefore

      public SELF isBefore(Date other)
      Verifies that the actual Date is strictly before the given one.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isBefore(theReturnOfTheKing.getReleaseDate());

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isBefore(theFellowshipOfTheRing.getReleaseDate());
      Parameters:
      other - the given Date.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if other Date is null.
      AssertionError - if the actual Date is not strictly before the given one.

    • isBefore

      public SELF isBefore(Instant other)
      Verifies that the actual Date is strictly before the given Instant.

      Example: 

       // assertion succeeds
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isBefore(Instant.parse("2002-12-19T00:00:00.00Z"));

 // assertions fail
 assertThat(theTwoTowers.getReleaseDate()).isBefore(Instant.parse("2002-12-17T00:00:00.00Z"));
 assertThat(theTwoTowers.getReleaseDate()).isBefore(Instant.parse("2002-12-18T00:00:00.00Z"));
      Parameters:
      other - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if other Instant is null.
      AssertionError - if the actual Date is not strictly before the given Instant.
      Since:
      3.19.0

    • isBefore

      public SELF isBefore(String dateAsString)
      Same assertion as isBefore(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isBefore("2002-12-19");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isBefore("2002-12-17");
 assertThat(theTwoTowers.getReleaseDate()).isBefore("2002-12-18")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if given date as String is null.
      AssertionError - if the actual Date is not strictly before the given Date represented as String.
      AssertionError - if the given date as String could not be converted to a Date.

    • isBeforeOrEqualsTo

      @Deprecated public SELF isBeforeOrEqualsTo(Date other)
      Deprecated.
      prefer calling isBeforeOrEqualTo(Date)
      Verifies that the actual Date is before or equals to the given one.

      Example: 

       SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

 // assertions will pass
 assertThat(dateFormat.parse("1990-12-01")).isBeforeOrEqualsTo(dateFormat.parse("2000-12-01"));
 assertThat(dateFormat.parse("2000-12-01")).isBeforeOrEqualsTo(dateFormat.parse("2000-12-01"));

 // assertion will fail
 assertThat(dateFormat.parse("2000-12-01")).isBeforeOrEqualsTo(dateFormat.parse("1990-12-01"));
      Parameters:
      other - the given Date.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if other Date is null.
      AssertionError - if the actual Date is not before or equals to the given one.

    • isBeforeOrEqualTo

      public SELF isBeforeOrEqualTo(Date other)
      Verifies that the actual Date is before or equal to the given one.

      Example: 

       SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

 // assertions will pass
 assertThat(dateFormat.parse("1990-12-01")).isBeforeOrEqualTo(dateFormat.parse("2000-12-01"));
 assertThat(dateFormat.parse("2000-12-01")).isBeforeOrEqualTo(dateFormat.parse("2000-12-01"));

 // assertion will fail
 assertThat(dateFormat.parse("2000-12-01")).isBeforeOrEqualTo(dateFormat.parse("1990-12-01"));
      Parameters:
      other - the given Date.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if other Date is null.
      AssertionError - if the actual Date is not before or equals to the given one.

    • isBeforeOrEqualTo

      public SELF isBeforeOrEqualTo(Instant other)
      Verifies that the actual Date is before or equal to the given Instant.

      Example: 

       // assertions succeed
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isBeforeOrEqualTo(Instant.parse("2002-12-19T00:00:00.00Z"));
 assertThat(theTwoTowers.getReleaseDate()).isBeforeOrEqualTo(Instant.parse("2002-12-18T00:00:00.00Z"));

 // assertion fails
 assertThat(theTwoTowers.getReleaseDate()).isBeforeOrEqualTo(Instant.parse("2002-12-17T00:00:00.00Z"));
      Parameters:
      other - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if other Instant is null.
      AssertionError - if the actual Date is not before or equal to the given Instant.
      Since:
      3.19.0

    • isBeforeOrEqualsTo

      @Deprecated public SELF isBeforeOrEqualsTo(String dateAsString)
      Deprecated.
      prefer calling isBeforeOrEqualTo(String)
      Same assertion as isBeforeOrEqualsTo(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isBeforeOrEqualsTo("2002-12-19");
 assertThat(theTwoTowers.getReleaseDate()).isBeforeOrEqualsTo("2002-12-18");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isBeforeOrEqualsTo("2002-12-17")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if given date as String is null.
      AssertionError - if the actual Date is not before or equals to the given Date represented as String.
      AssertionError - if the given date as String could not be converted to a Date.

    • isBeforeOrEqualTo

      public SELF isBeforeOrEqualTo(String dateAsString)
      Same assertion as isBeforeOrEqualTo(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isBeforeOrEqualTo("2002-12-19");
 assertThat(theTwoTowers.getReleaseDate()).isBeforeOrEqualTo("2002-12-18");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isBeforeOrEqualTo("2002-12-17")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if given date as String is null.
      AssertionError - if the actual Date is not before or equals to the given Date represented as String.
      AssertionError - if the given date as String could not be converted to a Date.

    • isAfter

      public SELF isAfter(Date other)
      Verifies that the actual Date is strictly after the given one.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isAfter(theFellowshipOfTheRing.getReleaseDate());

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isAfter(theReturnOfTheKing.getReleaseDate());
      Parameters:
      other - the given Date.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if other Date is null.
      AssertionError - if the actual Date is not strictly after the given one.

    • isAfter

      public SELF isAfter(Instant other)
      Verifies that the actual Date is strictly after the given Instant.

      Example: 

       // assertion succeeds
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isAfter(Instant.parse("2002-12-17T00:00:00.00Z"));

 // assertions fail
 assertThat(theTwoTowers.getReleaseDate()).isAfter(Instant.parse("2002-12-18T00:00:00.00Z"));
 assertThat(theTwoTowers.getReleaseDate()).isAfter(Instant.parse("2002-12-19T00:00:00.00Z"));
      Parameters:
      other - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if other Instant is null.
      AssertionError - if the actual Date is not strictly after the given Instant.
      Since:
      3.19.0

    • isAfter

      public SELF isAfter(String dateAsString)
      Same assertion as isAfter(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isAfter("2002-12-17");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isAfter("2002-12-18");
 assertThat(theTwoTowers.getReleaseDate()).isAfter("2002-12-19")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if given date as String is null.
      AssertionError - if the actual Date is not strictly after the given Date represented as String.
      AssertionError - if the given date as String could not be converted to a Date.

    • isAfterOrEqualsTo

      @Deprecated public SELF isAfterOrEqualsTo(Date other)
      Deprecated.
      prefer calling isAfterOrEqualTo(Date)
      Verifies that the actual Date is after or equals to the given one.

      Example: 

       SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

 // assertions will pass
 assertThat(dateFormat.parse("2000-12-01")).isAfterOrEqualsTo(dateFormat.parse("1990-12-01"));
 assertThat(dateFormat.parse("2000-12-01")).isAfterOrEqualsTo(dateFormat.parse("2000-12-01"));

 // assertion will fail
 assertThat(dateFormat.parse("1990-12-01")).isAfterOrEqualsTo(dateFormat.parse("2000-12-01"));
      Parameters:
      other - the given Date.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if other Date is null.
      AssertionError - if the actual Date is not after or equals to the given one.

    • isAfterOrEqualTo

      public SELF isAfterOrEqualTo(Date other)
      Verifies that the actual Date is after or equal to the given one.

      Example: 

       SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

 // assertions will pass
 assertThat(dateFormat.parse("2000-12-01")).isAfterOrEqualTo(dateFormat.parse("1990-12-01"));
 assertThat(dateFormat.parse("2000-12-01")).isAfterOrEqualTo(dateFormat.parse("2000-12-01"));

 // assertion will fail
 assertThat(dateFormat.parse("1990-12-01")).isAfterOrEqualTo(dateFormat.parse("2000-12-01"));
      Parameters:
      other - the given Date.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if other Date is null.
      AssertionError - if the actual Date is not after or equals to the given one.

    • isAfterOrEqualTo

      public SELF isAfterOrEqualTo(Instant other)
      Verifies that the actual Date is after or equal to the given Instant.

      Example: 

       // assertions succeed
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).assertIsAfterOrEqualTo(Instant.parse("2002-12-17T00:00:00.00Z"))
                                          .assertIsAfterOrEqualTo(Instant.parse("2002-12-18T00:00:00.00Z"));
 // assertion fails
 assertThat(theTwoTowers.getReleaseDate()).assertIsAfterOrEqualTo(Instant.parse("2002-12-19T00:00:00.00Z"));
      Parameters:
      other - the given Instant.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if other Instant is null.
      AssertionError - if the actual Date is not after or equal to the given Instant.
      Since:
      3.19.0

    • isAfterOrEqualsTo

      @Deprecated public SELF isAfterOrEqualsTo(String dateAsString)
      Deprecated.
      prefer calling isAfterOrEqualTo(String)
      Same assertion as isAfterOrEqualsTo(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isAfterOrEqualsTo("2002-12-17");
 assertThat(theTwoTowers.getReleaseDate()).isAfterOrEqualsTo("2002-12-18");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isAfterOrEqualsTo("2002-12-19")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if given date as String is null.
      AssertionError - if the actual Date is not after or equals to the given Date represented as String.
      AssertionError - if the given date as String could not be converted to a Date.

    • isAfterOrEqualTo

      public SELF isAfterOrEqualTo(String dateAsString)
      Same assertion as isAfterOrEqualTo(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isAfterOrEqualTo("2002-12-17");
 assertThat(theTwoTowers.getReleaseDate()).isAfterOrEqualTo("2002-12-18");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isAfterOrEqualTo("2002-12-19")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if given date as String is null.
      AssertionError - if the actual Date is not after or equals to the given Date represented as String.
      AssertionError - if the given date as String could not be converted to a Date.

    • isBetween

      public SELF isBetween(Date start, Date end)
      Verifies that the actual Date is in [start, end[ period (start included, end excluded).

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isBetween(theFellowshipOfTheRing.getReleaseDate(), theReturnOfTheKing.getReleaseDate());

 // assertion will fail
 assertThat(theFellowshipOfTheRing.getReleaseDate()).isBetween(theTwoTowers.getReleaseDate(), theReturnOfTheKing.getReleaseDate());
      Parameters:
      start - the period start (inclusive), expected not to be null.
      end - the period end (exclusive), expected not to be null.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if start Date is null.
      NullPointerException - if end Date is null.
      AssertionError - if the actual Date is not in [start, end[ period.

    • isBetween

      public SELF isBetween(String start, String end)
      Same assertion as isBetween(Date, Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isBetween("2002-12-17", "2002-12-19");

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isBetween("2002-12-15", "2002-12-17")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      start - the period start (inclusive), expected not to be null.
      end - the period end (exclusive), expected not to be null.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if start Date as String is null.
      NullPointerException - if end Date as String is null.
      AssertionError - if the actual Date is not in [start, end[ period.
      AssertionError - if one of the given date as String could not be converted to a Date.

    • isBetween

      public SELF isBetween(Instant start, Instant end)
      Same assertion as isBetween(Date, Date) but given period is represented with Instant.

      Example: 

       assertThat(new Date()).isBetween(Instant.now().minusSeconds(5), Instant.now().plusSeconds(5));
      Parameters:
      start - the period start (inclusive), expected not to be null.
      end - the period end (exclusive), expected not to be null.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if start Instant as String is null.
      NullPointerException - if end Instant as String is null.
      AssertionError - if the actual Date is not in [start, end[ period.
      Since:
      3.19.0

    • isBetween

      public SELF isBetween(Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd)
      Verifies that the actual Date is in the given period defined by start and end dates.
      To include start in the period set inclusiveStart parameter to true.
      To include end in the period set inclusiveEnd parameter to true.

      Example: 

       SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
 // assertions will pass
 assertThat(format.parse("2000-01-01")).isBetween(format.parse("2000-01-01"), format.parse("2100-12-01"), true, true);
 assertThat(format.parse("2000-01-01")).isBetween(format.parse("1900-01-01"), format.parse("2000-01-01"), true, true);
 assertThat(format.parse("2000-01-01")).isBetween(format.parse("1900-01-01"), format.parse("2100-01-01"), false, false);

 // assertions will fail
 assertThat(format.parse("2000-01-01")).isBetween(format.parse("2000-01-01"), format.parse("2100-12-01"), false, true);
 assertThat(format.parse("2000-01-01")).isBetween(format.parse("1900-01-01"), format.parse("2000-01-01"), true, false);
      Parameters:
      start - the period start, expected not to be null.
      end - the period end, expected not to be null.
      inclusiveStart - whether to include start date in period.
      inclusiveEnd - whether to include end date in period.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is null.
      NullPointerException - if start Date is null.
      NullPointerException - if end Date is null.
      AssertionError - if the actual Date is not in (start, end) period.

    • isBetween

      public SELF isBetween(String start, String end, boolean inclusiveStart, boolean inclusiveEnd)
      Same assertion as isBetween(Date, Date, boolean, boolean) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isBetween("2002-12-17", "2002-12-18", false, true);
 assertThat(theTwoTowers.getReleaseDate()).isBetween("2002-12-18", "2002-12-19", true, false);

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isBetween("2002-12-17", "2002-12-18", false, false)

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      start - the period start, expected not to be null.
      end - the period end, expected not to be null.
      inclusiveStart - whether to include start date in period.
      inclusiveEnd - whether to include end date in period.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is null.
      NullPointerException - if start Date as String is null.
      NullPointerException - if end Date as String is null.
      AssertionError - if the actual Date is not in (start, end) period.
      AssertionError - if one of the given date as String could not be converted to a Date.

    • isBetween

      public SELF isBetween(Instant start, Instant end, boolean inclusiveStart, boolean inclusiveEnd)
      Same assertion as isBetween(Date, Date, boolean, boolean) but given period is represented with Instant.

      Example: 

       assertThat(new Date()).isBetween(Instant.now().minusSeconds(5), Instant.now().plusSeconds(5), true, true);
      Parameters:
      start - the period start, expected not to be null.
      end - the period end, expected not to be null.
      inclusiveStart - whether to include start date in period.
      inclusiveEnd - whether to include end date in period.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is null.
      NullPointerException - if start Date as Instant is null.
      NullPointerException - if end Date as Instant is null.
      AssertionError - if the actual Date is not in (start, end) period.
      Since:
      3.19.0

    • isNotBetween

      public SELF isNotBetween(Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd)
      Verifies that the actual Date is not in the given period defined by start and end dates.
      To include start in the period set inclusiveStart parameter to true.
      To include end in the period set inclusiveEnd parameter to true.

      Example: 

       SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
 // assertions will pass
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("2000-01-01"), format.parse("2100-12-01"), false, true);
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("1900-01-01"), format.parse("2000-01-01"), true, false);

 // assertions will fail
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("2000-01-01"), format.parse("2100-12-01"), true, true);
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("1900-01-01"), format.parse("2000-01-01"), true, true);
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("1900-01-01"), format.parse("2100-01-01"), false, false);
      Parameters:
      start - the period start (inclusive), expected not to be null.
      end - the period end (exclusive), expected not to be null.
      inclusiveStart - whether to include start date in period.
      inclusiveEnd - whether to include end date in period.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is null.
      NullPointerException - if start Date is null.
      NullPointerException - if end Date is null.
      AssertionError - if the actual Date is not in (start, end) period.

    • isNotBetween

      public SELF isNotBetween(Instant start, Instant end, boolean inclusiveStart, boolean inclusiveEnd)
      Verifies that the actual Date is not in the given period defined by start and end dates.
      To include start in the period set inclusiveStart parameter to true.
      To include end in the period set inclusiveEnd parameter to true.

      Example: 

       SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
 // assertions will pass
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("2000-01-01T00:00:00Z"), format.parse("2100-12-01T00:00:00Z"), false, true);
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("1900-01-01T00:00:00Z"), format.parse("2000-01-01T00:00:00Z"), true, false);

 // assertions will fail
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("2000-01-01T00:00:00Z"), format.parse("2100-12-01T00:00:00Z"), true, true);
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("1900-01-01T00:00:00Z"), format.parse("2000-01-01T00:00:00Z"), true, true);
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("1900-01-01T00:00:00Z"), format.parse("2100-01-01T00:00:00Z"), false, false);
      Parameters:
      start - the period start (inclusive), expected not to be null.
      end - the period end (exclusive), expected not to be null.
      inclusiveStart - whether to include start date in period.
      inclusiveEnd - whether to include end date in period.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is null.
      NullPointerException - if start Instant is null.
      NullPointerException - if end Instant is null.
      AssertionError - if the actual Date is not in (start, end) period.
      Since:
      3.19.0

    • isNotBetween

      public SELF isNotBetween(String start, String end, boolean inclusiveStart, boolean inclusiveEnd)
      Same assertion as isNotBetween(Date, Date, boolean, boolean) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isNotBetween("2002-12-17", "2002-12-18", false, false);

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isNotBetween("2002-12-17", "2002-12-18", false, true);
 assertThat(theTwoTowers.getReleaseDate()).isNotBetween("2002-12-18", "2002-12-19", true, false)

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      start - the period start (inclusive), expected not to be null.
      end - the period end (exclusive), expected not to be null.
      inclusiveStart - whether to include start date in period.
      inclusiveEnd - whether to include end date in period.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if actual is null.
      NullPointerException - if start Date as String is null.
      NullPointerException - if end Date as String is null.
      AssertionError - if the actual Date is not in (start, end) period.
      AssertionError - if one of the given date as String could not be converted to a Date.

    • isNotBetween

      public SELF isNotBetween(Date start, Date end)
      Verifies that the actual Date is not in [start, end[ period

      Example: 

       SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
 // assertions will pass
 assertThat(format.parse("1900-01-01")).isNotBetween(format.parse("2000-01-01"), format.parse("2100-12-01"));
 assertThat(format.parse("2200-01-01")).isNotBetween(format.parse("2000-01-01"), format.parse("2100-12-01"));
 assertThat(format.parse("2000-01-01")).isNotBetween(format.parse("1900-01-01"), format.parse("2000-01-01"));

 // assertions will fail
 assertThat(format.parse("2001-12-24")).isNotBetween(format.parse("2000-01-01"), format.parse("2100-01-01"));
 assertThat(format.parse("1900-01-01")).isNotBetween(format.parse("1900-01-01"), format.parse("2000-01-01"));
      Parameters:
      start - the period start (inclusive), expected not to be null.
      end - the period end (exclusive), expected not to be null.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if start Date is null.
      NullPointerException - if end Date is null.
      AssertionError - if the actual Date is in [start, end[ period.

    • isNotBetween

      public SELF isNotBetween(Instant start, Instant end)
      Verifies that the actual Date is not in [start, end[ period

      Example: 

       SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
 // assertions will pass
 assertThat(format.parse("1900-01-01")).isNotBetween(Instant.parse("2000-01-01T00:00:00Z"), Instant.parse("2100-12-01T00:00:00Z"));
 assertThat(format.parse("2200-01-01")).isNotBetween(Instant.parse("2000-01-01T00:00:00Z"), Instant.parse("2100-12-01T00:00:00Z"));
 assertThat(format.parse("2000-01-01")).isNotBetween(Instant.parse("1900-01-01T00:00:00Z"), Instant.parse("2000-01-01T00:00:00Z"));

 // assertions will fail
 assertThat(format.parse("2001-12-24")).isNotBetween(Instant.parse("2000-01-01T00:00:00Z"), Instant.parse("2100-01-01T00:00:00Z"));
 assertThat(format.parse("1900-01-01")).isNotBetween(Instant.parse("1900-01-01T00:00:00Z"), Instant.parse("2000-01-01T00:00:00Z"));
      Parameters:
      start - the period start (inclusive), expected not to be null.
      end - the period end (exclusive), expected not to be null.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if start Instant is null.
      NullPointerException - if end Instant is null.
      AssertionError - if the actual Date is in [start, end[ period.
      Since:
      3.19.0

    • isNotBetween

      public SELF isNotBetween(String start, String end)
      Same assertion as isNotBetween(Date, Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       // assertion will pass
 assertThat(theFellowshipOfTheRing.getReleaseDate()).isNotBetween("2002-12-01", "2002-12-10");

 // assertion will fail
 assertThat(theFellowshipOfTheRing.getReleaseDate()).isNotBetween("2002-12-01", "2002-12-19")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      start - the period start (inclusive), expected not to be null.
      end - the period end (exclusive), expected not to be null.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if start Date as String is null.
      NullPointerException - if end Date as String is null.
      AssertionError - if the actual Date is in [start, end[ period.
      AssertionError - if one of the given date as String could not be converted to a Date.

    • isInThePast

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

      Example: 

       // assertion will pass
 assertThat(theTwoTowers.getReleaseDate()).isInThePast();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date is not in the past.

    • isToday

      public SELF isToday()
      Verifies that the actual Date is today, that is matching current year, month and day (no check on hour, minute, second, milliseconds).

      Example: 

       // assertion will pass
 assertThat(new Date()).isToday();

 // assertion will fail
 assertThat(theFellowshipOfTheRing.getReleaseDate()).isToday();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date is not today.

    • isInTheFuture

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

      Example: 

       Date now = new Date();
 // assertion succeeds:
 assertThat(new Date(now.getTime() + 1000)).isInTheFuture();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date is not in the future.

    • isBeforeYear

      public SELF isBeforeYear(int year)
      Verifies that the actual Date is strictly before the given year.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isBeforeYear(2004);

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isBeforeYear(2002);
 assertThat(theTwoTowers.getReleaseDate()).isBeforeYear(2000);
      Parameters:
      year - the year to compare actual year to
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date year is after or equals to the given year.

    • isAfterYear

      public SELF isAfterYear(int year)
      Verifies that the actual Date is strictly after the given year.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).isAfterYear(2001);

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).isAfterYear(2002);
 assertThat(theTwoTowers.getReleaseDate()).isAfterYear(2004);
      Parameters:
      year - the year to compare actual year to
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date year is before or equals to the given year.

    • hasYear

      public SELF hasYear(int year)
      Verifies that the actual Date year is equal to the given year.

      Note that using a custom comparator has no effect on this assertion.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).hasYear(2002);

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).hasYear(2004);
      Parameters:
      year - the year to compare actual year to
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date year is not equal to the given year.

    • isWithinYear

      @Deprecated public SELF isWithinYear(int year)
      Deprecated.
      use hasYear(int) instead.
      Parameters:
      year - the year to compare actual year to
      Returns:
      this assertion object.

    • hasMonth

      public SELF hasMonth(int month)
      Verifies that the actual Date month is equal to the given month, month value starting at 1 (January=1, February=2, ...).

      Note that using a custom comparator has no effect on this assertion.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).hasMonth(12);

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).hasMonth(10);
      Parameters:
      month - the month to compare actual month to, month value starting at 1 (January=1, February=2, ...).
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date month is not equal to the given month.

    • isWithinMonth

      @Deprecated public SELF isWithinMonth(int month)
      Deprecated.
      use hasMonth(int) instead.
      Parameters:
      month - the month to compare actual month to, month value starting at 1 (January=1, February=2, ...).
      Returns:
      this assertion object.

    • hasDayOfMonth

      public SELF hasDayOfMonth(int dayOfMonth)
      Verifies that the actual Date day of month is equal to the given day of month.

      Note that using a custom comparator has no effect on this assertion.

      Example: 

       // assertion will pass
 // theTwoTowers release date : 2002-12-18
 assertThat(theTwoTowers.getReleaseDate()).hasDayOfMonth(18);

 // assertion will fail
 assertThat(theTwoTowers.getReleaseDate()).hasDayOfMonth(20);
      Parameters:
      dayOfMonth - the day of month to compare actual day of month to
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date month is not equal to the given day of month.

    • isWithinDayOfMonth

      @Deprecated public SELF isWithinDayOfMonth(int dayOfMonth)
      Deprecated.
      use hasDayOfMonth(int) instead.
      Parameters:
      dayOfMonth - the day of month to compare actual day of month to
      Returns:
      this assertion object.

    • hasDayOfWeek

      public SELF hasDayOfWeek(int dayOfWeek)
      Verifies that the actual Date day of week is equal to the given day of week (see Calendar.DAY_OF_WEEK for valid values).

      Note that using a custom comparator has no effect on this assertion.

      Example: 

       // assertion will pass
 assertThat(new Date(parseDatetime("2003-04-26T13:20:35").getTime()).hasDayOfWeek(Calendar.SATURDAY);

 // assertion will fail
 assertThat(new Date(parseDatetime("2003-04-26T13:20:35").getTime()).hasDayOfWeek(Calendar.MONDAY);
      Parameters:
      dayOfWeek - the day of week to compare actual day of week to, see Calendar.DAY_OF_WEEK for valid values
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date week is not equal to the given day of week.

    • isWithinDayOfWeek

      @Deprecated public SELF isWithinDayOfWeek(int dayOfWeek)
      Deprecated.
      use hasDayOfWeek(int) instead.
      Parameters:
      dayOfWeek - the day of week to compare actual day of week to, see Calendar.DAY_OF_WEEK for valid values
      Returns:
      this assertion object.

    • hasHourOfDay

      public SELF hasHourOfDay(int hourOfDay)
      Verifies that the actual Date hour of day is equal to the given hour of day (24-hour clock).

      Note that using a custom comparator has no effect on this assertion.

      Example: 

       // assertion will pass
 assertThat(new Date(parseDatetime("2003-04-26T13:20:35").getTime()).hasHourOfDay(13);

 // assertion will fail
 assertThat(new Date(parseDatetime("2003-04-26T13:20:35").getTime()).hasHourOfDay(22);
      Parameters:
      hourOfDay - the hour of day to compare actual hour of day to (24-hour clock)
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date hour is not equal to the given hour.

    • isWithinHourOfDay

      @Deprecated public SELF isWithinHourOfDay(int hourOfDay)
      Deprecated.
      use hasHourOfDay(int) instead.
      Parameters:
      hourOfDay - the hour of day to compare actual hour of day to (24-hour clock)
      Returns:
      this assertion object.

    • hasMinute

      public SELF hasMinute(int minute)
      Verifies that the actual Date minute is equal to the given minute.

      Note that using a custom comparator has no effect on this assertion.

      Example: 

       // assertion will pass
 assertThat(new Date(parseDatetime("2003-04-26T13:20:35").getTime()).hasMinute(20);

 // assertion will fail
 assertThat(new Date(parseDatetime("2003-04-26T13:20:35").getTime()).hasMinute(17);
      Parameters:
      minute - the minute to compare actual minute to
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date minute is not equal to the given minute.

    • isWithinMinute

      @Deprecated public SELF isWithinMinute(int minute)
      Deprecated.
      use hasMinute(int) instead.
      Parameters:
      minute - the minute to compare actual minute to
      Returns:
      this assertion object.

    • hasSecond

      public SELF hasSecond(int second)
      Verifies that the actual Date second is equal to the given second.

      Note that using a custom comparator has no effect on this assertion.

      Example: 

       // assertion will pass
 assertThat(new Date(parseDatetime("2003-04-26T13:20:35").getTime()).hasSecond(35);

 // assertion will fail
 assertThat(new Date(parseDatetime("2003-04-26T13:20:35").getTime()).hasSecond(11);
      Parameters:
      second - the second to compare actual second to
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date second is not equal to the given second.

    • isWithinSecond

      @Deprecated public SELF isWithinSecond(int second)
      Deprecated.
      use hasSecond(int) instead.
      Parameters:
      second - the second to compare actual second to
      Returns:
      this assertion object.

    • hasMillisecond

      public SELF hasMillisecond(int millisecond)
      Verifies that the actual Date millisecond is equal to the given millisecond.

      Examples: 

       // assertion will pass
 assertThat(parseDatetimeWithMs("2003-04-26T13:20:35.017")).hasMillisecond(17);

 // assertion will fail
 assertThat(parseDatetimeWithMs("2003-04-26T13:20:35.017")).hasMillisecond(25);
      Note that using a custom comparator has no effect on this assertion.
      Parameters:
      millisecond - the millisecond to compare actual millisecond to
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date millisecond is not equal to the given millisecond.

    • isWithinMillisecond

      @Deprecated public SELF isWithinMillisecond(int millisecond)
      Deprecated.
      use hasMillisecond(int) instead.
      Parameters:
      millisecond - the millisecond to compare actual millisecond to
      Returns:
      this assertion object.

    • isInSameYearAs

      public SELF isInSameYearAs(Date other)
      Verifies that actual and given Date are in the same year.

      Example: 

       Date date1 = parse("2003-04-26");
 Date date2 = parse("2003-05-27");

 assertThat(date1).isInSameYearAs(date2);
      Note that using a custom comparator has no effect on this assertion.
      Parameters:
      other - the given Date to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Date parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same year.

    • isInSameYearAs

      public SELF isInSameYearAs(Instant other)
      Verifies that actual Date and given Instant are in the same year.

      Example: 

       Date date = parse("2003-04-26");
 Instant instant = Instant.parse("2003-04-26T12:30:00Z");

 assertThat(date).isInSameYearAs(instant);
      Note that using a custom comparator has no effect on this assertion.
      Parameters:
      other - the given Instant to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Instant parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual Date and given Instant are not in the same year.
      Since:
      3.19.0

    • isInSameYearAs

      public SELF isInSameYearAs(String dateAsString)
      Same assertion as isInSameYearAs(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       Date date1 = parse("2003-04-26");
 assertThat(date1).isInSameYearAs("2003-05-27")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if dateAsString parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date represented as String are not in the same year.
      AssertionError - if the given date as String could not be converted to a Date.

    • isInSameMonthAs

      public SELF isInSameMonthAs(Date other)
      Verifies that actual and given Date have same month and year fields.

      Example: 

       Date date1 = parse("2003-04-26");
 Date date2 = parse("2003-04-27");

 assertThat(date1).isInSameMonthAs(date2);
      Note that using a custom comparator has no effect on this assertion.
      Parameters:
      other - the given Date to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Date parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same month and year.

    • isInSameMonthAs

      public SELF isInSameMonthAs(Instant other)
      Verifies that actual Date and given Instant have same month and year fields.

      Example: 

       Date date = parse("2003-04-26");
 Instant instant = Instant.parse("2003-04-27T12:30:00Z");

 assertThat(date).isInSameMonthAs(instant);

      Note that using a custom comparator has no effect on this assertion.

      Parameters:
      other - the given Instant to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Instant parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual Date and given Instant are not in the same month and year.
      Since:
      3.19.0

    • isInSameMonthAs

      public SELF isInSameMonthAs(String dateAsString)
      Same assertion as isInSameMonthAs(Date)but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       Date date1 = parse("2003-04-26");
 assertThat(date1).isInSameMonthAs("2003-04-27")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if dateAsString parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same month.

    • isInSameDayAs

      public SELF isInSameDayAs(Date other)
      Verifies that actual and given Date have the same day of month, month and year fields values.

      Example: 

       Date date1 = parseDatetime("2003-04-26T23:17:00");
 Date date2 = parseDatetime("2003-04-26T12:30:00");

 assertThat(date1).isInSameDayAs(date2);

      Note that using a custom comparator has no effect on this assertion.

      This assertion is logically equivalent to isEqualToIgnoringHours(Date).

      Parameters:
      other - the given Date to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Date parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same day, month and year.

    • isInSameDayAs

      public SELF isInSameDayAs(Instant other)
      Verifies that actual Date and given Instant have the same day of month, month and year fields values.

      Example: 

       Date date = parseDatetime("2003-04-26T23:17:00");
 Instant instant = Instant.parse("2003-04-26T12:30:00Z");

 assertThat(date).isInSameDayAs(instant);
      Note that using a custom comparator has no effect on this assertion.

      This assertion is logically equivalent to isEqualToIgnoringHours(Instant).

      Parameters:
      other - the given Date to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Instant parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual Date and given Instant are not in the same day, month and year.
      Since:
      3.19.0

    • isInSameDayAs

      public SELF isInSameDayAs(String dateAsString)
      Same assertion as isInSameDayAs(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       Date date1 = parseDatetime("2003-04-26T23:17:00");
 assertThat(date1).isInSameDayAs("2003-04-26")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      This assertion is logically equivalent to isEqualToIgnoringHours(String).

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if dateAsString parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same day of month.

    • isInSameHourWindowAs

      public SELF isInSameHourWindowAs(Date other)
      Verifies that actual and given Date are chronologically in the same hour (i.e. their time difference < 1 hour).

      This assertion succeeds as time difference is exactly < 1h: 

       Date date1 = parseDatetime("2003-04-26T13:00:00");
 Date date2 = parseDatetime("2003-04-26T13:30:00");
 assertThat(date1).isInSameHourWindowAs(date2);
      Two dates can have different hour fields and yet be in the same chronological hour, example: 
       Date date1 = parseDatetime("2003-04-26T13:00:00");
 Date date2 = parseDatetime("2003-04-26T12:59:59");
 // succeeds as time difference == 1s
 assertThat(date1).isInSameHourWindowAs(date2);
      These assertions fail as time difference is equal to or greater than one hour: 
       Date date1 = parseDatetime("2003-04-26T13:00:00");
 Date date2 = parseDatetime("2003-04-26T14:00:01");
 Date date3 = parseDatetime("2003-04-26T14:00:00");
 assertThat(date1).isInSameHourWindowAs(date2);
 assertThat(date1).isInSameHourWindowAs(date3);

      Note that using a custom comparator has no effect on this assertion.

      Parameters:
      other - the given Date to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Date parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same hour.

    • isInSameHourWindowAs

      public SELF isInSameHourWindowAs(Instant other)
      Verifies that actual Date and given Instant are chronologically in the same hour (i.e. their time difference < 1 hour).

      This assertion succeeds as time difference is exactly = 1h: 

       Date date = parseDatetime("2003-04-26T13:00:00Z");
 Instant instant = Instant.parse("2003-04-26T14:00:00Z");
 assertThat(date).isInSameHourWindowAs(instant);
      Two date/instant can have different hour fields and yet be in the same chronological hour, example: 
       Date date = parseDatetime("2003-04-26T13:00:00Z");
 Instant instant = Instant.parse("2003-04-26T12:59:59Z");
 // succeeds as time difference == 1s
 assertThat(date).isInSameHourWindowAs(instant);
      These assertions fail as time difference is equal to or greater than one hour: 
       Date date = parseDatetime("2003-04-26T13:00:00Z");
 Instant instant = Instant.parse("2003-04-26T14:00:01Z");
 Instant instant2 = Instant.parse("2003-04-26T14:00:00Z");
 assertThat(date).isInSameHourWindowAs(instant);
 assertThat(date).isInSameHourWindowAs(instant2);

      Note that using a custom comparator has no effect on this assertion.

      Parameters:
      other - the given Instant to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Instant parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual Date and given Instant are not in the same hour.
      Since:
      3.19.0

    • isInSameHourWindowAs

      public SELF isInSameHourWindowAs(String dateAsString)
      Same assertion as isInSameHourWindowAs(java.util.Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if dateAsString parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same day of month.

    • isInSameHourAs

      @Deprecated public SELF isInSameHourAs(Date other)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Verifies that actual and given Date have same hour, day, month and year fields values.

      Example: 

       Date date1 = parseDatetime("2003-01-01T12:00:00");
 Date date2 = parseDatetime("2003-01-01T12:30:00");

 // succeeds
 assertThat(date1).isInSameHourAs(date2);
      This assertion does not make a true chronological comparison since two dates can have different hour fields and yet be in the same chronological hour, e.g: 
       // dates in the same hour time window but with different hour fields
 Date date1 = parseDatetime("2003-01-01T12:00:00");
 Date date2 = parseDatetime("2003-01-01T11:59:00");
      If you want to assert that two dates are chronologically in the same hour time window use isInSameHourWindowAs assertion (note that if isInSameHourAs succeeds then isInSameHourWindowAs will succeed too).

      Note that using a custom comparator has no effect on this assertion.

      This assertion is logically equivalent to isEqualToIgnoringMinutes(Date).

      Parameters:
      other - the given Date to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Date parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same hour, day, month and year.

    • isInSameHourAs

      @Deprecated public SELF isInSameHourAs(String dateAsString)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isInSameHourAs(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      This assertion is logically equivalent to isEqualToIgnoringMinutes(String).

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if dateAsString parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same hour.

    • isInSameMinuteWindowAs

      public SELF isInSameMinuteWindowAs(Date other)
      Verifies that actual and given Date are chronologically in the same minute (i.e. their time difference < 1 minute).

      Example: 

       Date date1 = parseDatetime("2003-01-01T12:01:00");
 Date date2 = parseDatetime("2003-01-01T12:01:30");

 // succeeds because date time difference < 1 min
 assertThat(date1).isInSameMinuteWindowAs(date2);
      Two dates can have different minute fields and yet be in the same chronological minute, example: 
       Date date1 = parseDatetime("2003-01-01T12:01:00");
 Date date3 = parseDatetime("2003-01-01T12:00:59");

 // succeeds as time difference == 1s even though minute fields differ
 assertThat(date1).isInSameMinuteWindowAs(date3);
      This assertion fails as time difference is ≥ 1 min: 
       Date date1 = parseDatetime("2003-01-01T12:01:00");
 Date date2 = parseDatetime("2003-01-01T12:02:00");
 assertThat(date1).isInSameMinuteWindowAs(date2);
      Note that using a custom comparator has no effect on this assertion.
      Parameters:
      other - the given Date to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Date parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same minute.

    • isInSameMinuteWindowAs

      public SELF isInSameMinuteWindowAs(Instant other)
      Verifies that actual Date and given Instant are chronologically in the same minute (i.e. their time difference < 1 minute).

      Example: 

       Date date = parseDatetime("2003-01-01T12:01:00Z");
 Instant instant = Instant.parse("2003-01-01T12:01:30Z");

 // succeeds because date time difference < 1 min
 assertThat(date).isInSameMinuteWindowAs(instant);
      Two date/instant can have different minute fields and yet be in the same chronological minute, example: 
       Date date = parseDatetime("2003-01-01T12:01:00Z");
 Instant instant = Instant.parse("2003-01-01T12:00:59Z");

 // succeeds as time difference == 1s even though minute fields differ
 assertThat(date).isInSameMinuteWindowAs(instant);
      This assertion fails as time difference is ≥ 1 min: 
       Date date = parseDatetime("2003-01-01T12:01:00Z");
 Instant instant = Instant.parse("2003-01-01T12:02:00Z");
 assertThat(date).isInSameMinuteWindowAs(instant);
      Note that using a custom comparator has no effect on this assertion.
      Parameters:
      other - the given Instant to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Instant parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual Date and given Instant are not in the same minute.
      Since:
      3.19.0

    • isInSameMinuteWindowAs

      public SELF isInSameMinuteWindowAs(String dateAsString)
      Same assertion as isInSameMinuteWindowAs(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if dateAsString parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same minute.

    • isInSameMinuteAs

      @Deprecated public SELF isInSameMinuteAs(Date other)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Verifies that actual and given Date have same minute, same hour, day, month and year fields values.

      Example: 

       Date date1 = parseDatetime("2003-01-01T12:01:00");
 Date date2 = parseDatetime("2003-01-01T12:01:30");

 // succeeds because the all the fields up to minutes are the same
 assertThat(date1).isInSameMinuteAs(date2);
      It does not make a true chronological comparison since two dates can have different minute fields and yet be in the same chronological minute, e.g: 
       // dates in the same minute time window but with different minute fields
 Date date1 = parseDatetime("2003-01-01T12:01:00");
 Date date3 = parseDatetime("2003-01-01T12:00:59");

 // fails because minutes fields differ even though time difference is only 1s !
 assertThat(date1).isInSameMinuteAs(date3); // ERROR
      If you want to assert that two dates are in the same minute time window use isInSameMinuteWindowAs assertion (note that if isInSameMinuteAs succeeds then isInSameMinuteWindowAs will succeed too).

      Note that using a custom comparator has no effect on this assertion.

      This assertion is logically equivalent to isEqualToIgnoringSeconds(Date).

      Parameters:
      other - the given Date to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Date parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same minute.

    • isInSameMinuteAs

      @Deprecated public SELF isInSameMinuteAs(String dateAsString)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isInSameMinuteAs(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      This assertion is logically equivalent to isEqualToIgnoringSeconds(String).

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if dateAsString parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same minute.

    • isInSameSecondWindowAs

      public SELF isInSameSecondWindowAs(Date other)
      Verifies that actual and given Date are chronologically strictly in the same second (i.e. their time difference < 1 second).

      Example: 

       Date date1 = parseDatetimeWithMs("2003-04-26T13:01:02.123");
 Date date2 = parseDatetimeWithMs("2003-04-26T13:01:02.456");

 // succeeds as time difference is < 1s
 assertThat(date1).isInSameSecondWindowAs(date2);
      Two dates can have different second fields and yet be in the same chronological second, example: 
       Date date1 = parseDatetimeWithMs("2003-04-26T13:01:02.999");
 Date date2 = parseDatetimeWithMs("2003-04-26T13:01:03.000");

 // succeeds as time difference is 1ms < 1s
 assertThat(date1).isInSameSecondWindowAs(date2);
      Those assertions fail as time difference is greater or equal to one second: 
       Date date1 = parseDatetimeWithMs("2003-04-26T13:01:01.000");
 Date date2 = parseDatetimeWithMs("2003-04-26T13:01:02.000");

 // fails as time difference = 1s
 assertThat(date1).isInSameSecondWindowAs(date2);

 Date date3 = parseDatetimeWithMs("2003-04-26T13:01:02.001");
 // fails as time difference > 1s
 assertThat(date1).isInSameSecondWindowAs(date3);
      Note that using a custom comparator has no effect on this assertion.
      Parameters:
      other - the given Date to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Date parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same second.

    • isInSameSecondWindowAs

      public SELF isInSameSecondWindowAs(Instant other)
      Verifies that actual Date and given Instant are chronologically strictly in the same second (i.e. their time difference < 1 second).

      Example: 

       Date date = parseDatetimeWithMs("2003-04-26T13:01:02.123Z");
 Instant instant = Instant.parse("2003-04-26T13:01:02.456Z");

 // succeeds as time difference is < 1s
 assertThat(date).isInSameSecondWindowAs(instant);
      Two dates can have different second fields and yet be in the same chronological second, example: 
       Date date = parseDatetimeWithMs("2003-04-26T13:01:02.999Z");
 Instant instant = Instant.parse("2003-04-26T13:01:03.000Z");

 // succeeds as time difference is 1ms < 1s
 assertThat(date).isInSameSecondWindowAs(instant);
      Those assertions fail as time difference is greater or equal to one second: 
       Date date = parseDatetimeWithMs("2003-04-26T13:01:01.000Z");
 Instant instant = Instant.parse("2003-04-26T13:01:02.000Z");

 // fails as time difference = 1s
 assertThat(date).isInSameSecondWindowAs(instant);

 Instant instant2 = Instant.parse("2003-04-26T13:01:02.001Z");
 // fails as time difference > 1s
 assertThat(date).isInSameSecondWindowAs(instant2);
      Note that using a custom comparator has no effect on this assertion.
      Parameters:
      other - the given Instant to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Instant parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual Date and given Instant are not in the same second.
      Since:
      3.19.0

    • isInSameSecondWindowAs

      public SELF isInSameSecondWindowAs(String dateAsString)
      Same assertion as isInSameSecondWindowAs(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if dateAsString parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same second.

    • isInSameSecondAs

      @Deprecated public SELF isInSameSecondAs(Date other)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Verifies that actual and given Date have same second, minute, hour, day, month and year fields values. 
       Date date1 = parseDatetimeWithMs("2003-01-01T12:00:01.000");
 Date date2 = parseDatetimeWithMs("2003-01-01T12:00:01.250");

 // succeeds because the all the time fields up to seconds are the same
 assertThat(date1).isInSameSecondAs(date2);
      It does not make a true chronological comparison since two dates can have different second fields and yet be in the same chronological second, e.g: 
       Date date1 = parseDatetimeWithMs("2003-01-01T12:00:01.000");
 Date date3 = parseDatetimeWithMs("2003-01-01T12:00:00.999");

 // fails because seconds fields differ even though time difference is only 1ms !
 assertThat(date1).isInSameSecondAs(date3); // ERROR
      If you want to assert that two dates are in the same second time window use isInSameSecondWindowAs assertion.

      If you want to compare second fields only (without minute, hour, day, month and year), you could write : assertThat(myDate).hasSecond(secondOf(otherDate))
      using DateUtil.secondOf(Date) to get the second of a given Date.

      Note that using a custom comparator has no effect on this assertion.

      This assertion is logically equivalent to isEqualToIgnoringMillis(Date).

      Parameters:
      other - the given Date to compare actual Date to.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Date parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if actual and given Date are not in the same second.

    • isInSameSecondAs

      @Deprecated public SELF isInSameSecondAs(String dateAsString)
      Deprecated.
      Use isCloseTo(Date, long) instead, although not exactly the same semantics, this is the right way to compare with a given precision.
      Same assertion as isInSameSecondAs(Date) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      This assertion is logically equivalent to isEqualToIgnoringMillis(String).

      Parameters:
      dateAsString - the given Date represented as String.
      Returns:
      this assertion object.

    • isCloseTo

      public SELF isCloseTo(Date other, long deltaInMilliseconds)
      Verifies that the actual Date is close to the other date by less than delta (expressed in milliseconds), if difference is equal to delta it's ok.

      One can use handy TimeUnit to convert a duration in milliseconds, for example you can express a delta of 5 seconds with TimeUnit.SECONDS.toMillis(5).

      Note that using a custom comparator has no effect on this assertion.

      Example: 

       Date date1 = new Date();
 Date date2 = new Date(date1.getTime() + 100);

 // assertion succeeds
 assertThat(date1).isCloseTo(date2, 101)
                  .isCloseTo(date2, 100);

 // assertion fails
 assertThat(date1).isCloseTo(date2, 80);
      Parameters:
      other - the date to compare actual to
      deltaInMilliseconds - the delta used for date comparison, expressed in milliseconds
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Date parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date is not close to the given date by less than delta.

    • isCloseTo

      public SELF isCloseTo(Instant other, long deltaInMilliseconds)
      Verifies that the actual Date is close to the given Instant by less than delta (expressed in milliseconds), if the difference is equal to delta the assertion succeeds.

      One can use handy TimeUnit to convert a duration in milliseconds, for example you can express a delta of 5 seconds with TimeUnit.SECONDS.toMillis(5).

      Note that using a custom comparator has no effect on this assertion.

      Example: 

       Date date = new Date();

 // assertions succeed
 assertThat(date).isCloseTo(date.toInstant().plusMillis(80), 80)
                 .isCloseTo(date.toInstant().plusMillis(80), 100);

 // assertions fails
 assertThat(date).isCloseTo(date.toInstant().minusMillis(101), 100);
      Parameters:
      other - the Instant to compare actual to
      deltaInMilliseconds - the delta used for date comparison, expressed in milliseconds
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if Instant parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date is not close to the given Instant by less than delta.
      Since:
      3.19.0

    • isCloseTo

      public SELF isCloseTo(String dateAsString, long deltaInMilliseconds)
      Same assertion as isCloseTo(Date, long) but given date is represented as String either with one of the supported defaults date format or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      deltaInMilliseconds - the delta used for date comparison, expressed in milliseconds
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if dateAsString parameter is null.
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date is not close to the given date by less than delta.

    • hasTime

      public SELF hasTime(long timestamp)
      Verifies that the actual Date has the same time as the given timestamp.

      Both time or timestamp express a number of milliseconds since January 1, 1970, 00:00:00 GMT.

      Example: 

       assertThat(new Date(42)).hasTime(42);
      Parameters:
      timestamp - the timestamp to compare actual time to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date time is not equal to the given timestamp.
      See Also:

    • hasSameTimeAs

      public SELF hasSameTimeAs(Date date)
      Verifies that the actual Date has the same time as the given date, useful to compare Date and Timestamp.

      Example: 

       Date date = new Date();
 Timestamp timestamp = new Timestamp(date.getTime());

 // Fail as date is not an instance of Timestamp
 assertThat(date).isEqualTo(timestamp);

 // Succeed as we compare date and timestamp time.
 assertThat(date).hasSameTimeAs(timestamp);
      Parameters:
      date - the date to compare actual time to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      AssertionError - if the actual Date time is not equal to the given date time.
      NullPointerException - if Date parameter is null.
      See Also:

    • hasSameTimeAs

      public SELF hasSameTimeAs(String dateAsString)
      Verifies that the actual Date represents the same time as the given date in String format.

      It is the same assertion as hasSameTimeAs(Date) but given date is represented as String either with one of the supported default date formats or a user custom date format (set with method withDateFormat(DateFormat)).

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Example: 

       Date date = parseDatetime("2003-04-26T12:00:00");

 // assertion will pass
 assertThat(date).hasSameTimeAs("2003-04-26T12:00:00");

 // assertion will fail
 assertThat(date).hasSameTimeAs("2003-04-26T12:00:01");
 assertThat(date).hasSameTimeAs("2003-04-27T12:00:00")

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

      Parameters:
      dateAsString - the given Date represented as String in default or custom date format.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Date is null.
      NullPointerException - if given date as String is null.
      AssertionError - if the actual Date time is not equal to the time from date represented as String.
      AssertionError - if the given date as String could not be converted to a Date.

    • withDateFormat

      public SELF withDateFormat(DateFormat userCustomDateFormat)
      Instead of using default date formats for the date String based Date assertions like isEqualTo(String), AssertJ is gonna use any date formats registered with one of these methods :

      Beware that :

      • this will be the case for all future Date assertions in the test suite
      • once a custom date format is registered, the default date formats are not used anymore

      To revert to default format, call useDefaultDateFormatsOnly() or withDefaultDateFormatsOnly().

      Parameters:
      userCustomDateFormat - the new Date format used for String based Date assertions.
      Returns:
      this assertion object.

    • withDateFormat

      public SELF withDateFormat(String userCustomDateFormatPattern)
      Instead of using default date formats for the date String based Date assertions like isEqualTo(String), AssertJ is gonna use any date formats registered with one of these methods :

      Beware that :

      • this will be the case for all future Date assertions in the test suite
      • once a custom date format is registered, the default date formats are not used anymore

      To revert to default format, call useDefaultDateFormatsOnly() or withDefaultDateFormatsOnly().

      Parameters:
      userCustomDateFormatPattern - the new Date format string pattern used for String based Date assertions.
      Returns:
      this assertion object.

    • setLenientDateParsing

      public static void setLenientDateParsing(boolean value)
      Instead of using default strict date/time parsing, it is possible to use lenient parsing mode for default date formats parser to interpret inputs that do not precisely match supported date formats (lenient parsing).

      With strict parsing, inputs must match exactly date/time format.

      Example: 

       final Date date = Dates.parse("2001-02-03");
 final Date dateTime = parseDatetime("2001-02-03T04:05:06");
 final Date dateTimeWithMs = parseDatetimeWithMs("2001-02-03T04:05:06.700");

 AbstractDateAssert.setLenientDateParsing(true);

 // assertions will pass
 assertThat(date).isEqualTo("2001-02-03");
 assertThat(date).isEqualTo("2001-02-02T24:00:00");
 assertThat(date).isEqualTo("2001-02-04T-24:00:00.000");
 assertThat(dateTime).isEqualTo("2001-02-03T04:05:05.1000");
 assertThat(dateTime).isEqualTo("2001-02-03T04:04:66");
 assertThat(dateTimeWithMs).isEqualTo("2001-02-03T04:05:07.-300");

 // assertions will fail
 assertThat(date).hasSameTimeAs("2001-02-04"); // different date
 assertThat(dateTime).hasSameTimeAs("2001-02-03 04:05:06"); // leniency does not help here
      To revert to default strict date parsing, call setLenientDateParsing(false).
      Parameters:
      value - whether lenient parsing mode should be enabled or not

    • registerCustomDateFormat

      public static void registerCustomDateFormat(DateFormat userCustomDateFormat)
      Add the given date format to the ones used to parse date String in String based Date assertions like isEqualTo(String).

      User date formats are used before default ones in the order they have been registered (first registered, first used).

      AssertJ is gonna use any date formats registered with one of these methods :

      Beware that AssertJ will use the newly registered format for all remaining Date assertions in the test suite

      To revert to default formats only, call useDefaultDateFormatsOnly() or withDefaultDateFormatsOnly().

      Code examples: 

       Date date = ... // set to 2003 April the 26th
 assertThat(date).isEqualTo("2003-04-26");

 try {
   // date with a custom format : failure since the default formats don't match.
   assertThat(date).isEqualTo("2003/04/26");
 } catch (AssertionError e) {
   assertThat(e).hasMessage("Failed to parse 2003/04/26 with any of these date formats: " +
                            "[yyyy-MM-dd'T'HH:mm:ss.SSS, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd]");
 }

 // registering a custom date format to make the assertion pass
 registerCustomDateFormat(new SimpleDateFormat("yyyy/MM/dd")); // registerCustomDateFormat("yyyy/MM/dd") would work to.
 assertThat(date).isEqualTo("2003/04/26");

 // the default formats are still available and should work
 assertThat(date).isEqualTo("2003-04-26");
      Parameters:
      userCustomDateFormat - the new Date format used for String based Date assertions.

    • registerCustomDateFormat

      public static void registerCustomDateFormat(String userCustomDateFormatPattern)
      Add the given date format to the ones used to parse date String in String based Date assertions like isEqualTo(String).

      User date formats are used before default ones in the order they have been registered (first registered, first used).

      AssertJ is gonna use any date formats registered with one of these methods :

      Beware that AssertJ will use the newly registered format for all remaining Date assertions in the test suite

      To revert to default formats only, call useDefaultDateFormatsOnly() or withDefaultDateFormatsOnly().

      Code examples: 

       Date date = ... // set to 2003 April the 26th
 assertThat(date).isEqualTo("2003-04-26");

 try {
   // date with a custom format : failure since the default formats don't match.
   assertThat(date).isEqualTo("2003/04/26");
 } catch (AssertionError e) {
   assertThat(e).hasMessage("Failed to parse 2003/04/26 with any of these date formats: " +
                            "[yyyy-MM-dd'T'HH:mm:ss.SSS, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd]");
 }

 // registering a custom date format to make the assertion pass
 registerCustomDateFormat("yyyy/MM/dd");
 assertThat(date).isEqualTo("2003/04/26");

 // the default formats are still available and should work
 assertThat(date).isEqualTo("2003-04-26");
      Parameters:
      userCustomDateFormatPattern - the new Date format pattern used for String based Date assertions.

    • useDefaultDateFormatsOnly

      public static void useDefaultDateFormatsOnly()
      Remove all registered custom date formats => use only the defaults date formats to parse string as date.

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26

      If you are getting an IllegalArgumentException with "Unknown pattern character 'X'" message (some Android versions don't support it), you can explicitly specify the date format to use so that the default ones are bypassed.

    • withDefaultDateFormatsOnly

      public SELF withDefaultDateFormatsOnly()
      Remove all registered custom date formats => use only the defaults date formats to parse string as date.

      User custom date format take precedence over the default ones.

      Unless specified otherwise, beware that the default formats are expressed in the current local timezone.

      Defaults date format (expressed in the local time zone unless specified otherwise) are:

      • yyyy-MM-dd'T'HH:mm:ss.SSSX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss.SSS
      • yyyy-MM-dd HH:mm:ss.SSS
      • yyyy-MM-dd'T'HH:mm:ssX (in ISO Time zone)
      • yyyy-MM-dd'T'HH:mm:ss
      • yyyy-MM-dd

      Example of valid string date representations:

      • 2003-04-26T03:01:02.758+00:00
      • 2003-04-26T03:01:02.999
      • 2003-04-26 03:01:02.999
      • 2003-04-26T03:01:02+00:00
      • 2003-04-26T13:01:02
      • 2003-04-26
      Returns:
      this assertion

    • usingComparator

      public SELF usingComparator(Comparator<? super Date> customComparator)
      Description copied from class: AbstractAssert
      Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.

      The custom comparator is bound to assertion instance, meaning that if a new assertion instance is created, the default comparison strategy will be used.

      Examples : 

       // frodo and sam are instances of Character with Hobbit race (obviously :).
 // raceComparator implements Comparator<Character>
 assertThat(frodo).usingComparator(raceComparator).isEqualTo(sam);
      Specified by:
      usingComparator in interface Assert<SELF extends AbstractDateAssert<SELF>,Date>
      Overrides:
      usingComparator in class AbstractAssert<SELF extends AbstractDateAssert<SELF>,Date>
      Parameters:
      customComparator - the comparator to use for the incoming assertion checks.
      Returns:
      this assertion object.

    • usingComparator

      public SELF usingComparator(Comparator<? super Date> customComparator, String customComparatorDescription)
      Description copied from class: AbstractAssert
      Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.

      The custom comparator is bound to assertion instance, meaning that if a new assertion instance is created, the default comparison strategy will be used.

      Examples : 

       // frodo and sam are instances of Character with Hobbit race (obviously :).
 // raceComparator implements Comparator<Character>
 assertThat(frodo).usingComparator(raceComparator, "Hobbit Race Comparator").isEqualTo(sam);
      Specified by:
      usingComparator in interface Assert<SELF extends AbstractDateAssert<SELF>,Date>
      Overrides:
      usingComparator in class AbstractAssert<SELF extends AbstractDateAssert<SELF>,Date>
      Parameters:
      customComparator - the comparator to use for the incoming assertion checks.
      customComparatorDescription - comparator description to be used in assertion error messages
      Returns:
      this assertion object.

    • usingDefaultComparator

      public SELF usingDefaultComparator()
      Description copied from class: AbstractAssert
      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 AbstractDateAssert<SELF>,Date>
      Overrides:
      usingDefaultComparator in class AbstractAssert<SELF extends AbstractDateAssert<SELF>,Date>
      Returns:
      this assertion object.