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

Field Summary

Fields
Modifier and Type	Field	Description
`private static String`	`DATE_FORMAT_PATTERN_SHOULD_NOT_BE_NULL`
`private static String`	`DATE_FORMAT_SHOULD_NOT_BE_NULL`
`(package private) org.assertj.core.internal.Dates`	`dates`
`(package private) static List<DateFormat>`	`DEFAULT_DATE_FORMATS`	the default DateFormat used to parse any String date representation.
`(package private) static ThreadLocal<LinkedHashSet<DateFormat>>`	`userDateFormats`	Used in String based Date assertions - like `isAfter(String)` - to convert input date represented as string to Date. It keeps the insertion order so first format added will be first format used.

Fields inherited from class org.assertj.core.api.AbstractAssert
actual, assertionErrorCreator, conditions, customRepresentation, info, myself, objects, printAssertionsDescription, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors
Modifier Constructor Description

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`private List<DateFormat>`	`dateFormatsInOrderOfUsage()`
`SELF`	`hasDayOfMonth(int dayOfMonth)`	Verifies that the actual `Date` day of month is equal to the given day of month.
`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).
`SELF`	`hasHourOfDay(int hourOfDay)`	Verifies that the actual `Date` hour of day is equal to the given hour of day (24-hour clock).
`SELF`	`hasMillisecond(int millisecond)`	Verifies that the actual `Date` millisecond is equal to the given millisecond.
`SELF`	`hasMinute(int minute)`	Verifies that the actual `Date` minute is equal to the given minute.
`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, ...).
`SELF`	`hasSameTimeAs(String dateAsString)`	Verifies that the actual `Date` represents the same time as the given date in `String` format.
`SELF`	`hasSameTimeAs(Date date)`	Verifies that the actual `Date` has the same time as the given date, useful to compare `Date` and `Timestamp`.
`SELF`	`hasSecond(int second)`	Verifies that the actual `Date` second is equal to the given second.
`SELF`	`hasTime(long timestamp)`	Verifies that the actual `Date` has the same time as the given timestamp.
`SELF`	`hasYear(int year)`	Verifies that the actual `Date` year is equal to the given year.
`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)`).
`SELF`	`isAfter(Instant other)`	Verifies that the actual `Date` is strictly after the given `Instant`.
`SELF`	`isAfter(Date other)`	Verifies that the actual `Date` is strictly after the given one.
`SELF`	`isAfterOrEqualsTo(String dateAsString)`	Deprecated. prefer calling `isAfterOrEqualTo(String)`
`SELF`	`isAfterOrEqualsTo(Date other)`	Deprecated. prefer calling `isAfterOrEqualTo(Date)`
`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)`).
`SELF`	`isAfterOrEqualTo(Instant other)`	Verifies that the actual `Date` is after or equal to the given `Instant`.
`SELF`	`isAfterOrEqualTo(Date other)`	Verifies that the actual `Date` is after or equal to the given one.
`SELF`	`isAfterYear(int year)`	Verifies that the actual `Date` is strictly after the given year.
`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)`).
`SELF`	`isBefore(Instant other)`	Verifies that the actual `Date` is strictly before the given `Instant`.
`SELF`	`isBefore(Date other)`	Verifies that the actual `Date` is strictly before the given one.
`SELF`	`isBeforeOrEqualsTo(String dateAsString)`	Deprecated. prefer calling `isBeforeOrEqualTo(String)`
`SELF`	`isBeforeOrEqualsTo(Date other)`	Deprecated. prefer calling `isBeforeOrEqualTo(Date)`
`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)`).
`SELF`	`isBeforeOrEqualTo(Instant other)`	Verifies that the actual `Date` is before or equal to the given `Instant`.
`SELF`	`isBeforeOrEqualTo(Date other)`	Verifies that the actual `Date` is before or equal to the given one.
`SELF`	`isBeforeYear(int year)`	Verifies that the actual `Date` is strictly before the given year.
`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)`).
`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)`).
`SELF`	`isBetween(Instant start, Instant end)`	Same assertion as `isBetween(Date, Date)` but given period is represented with `Instant`.
`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`.
`SELF`	`isBetween(Date start, Date end)`	Verifies that the actual `Date` is in [start, end[ period (start included, end excluded).
`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`.
`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)`).
`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.
`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.
`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)`.
`SELF`	`isEqualTo(Instant instant)`	Calls `isEqualTo(Date date)` after converting the given `Instant` to a `Date`.
`SELF`	`isEqualToIgnoringHours(String dateAsString)`	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)`).
`SELF`	`isEqualToIgnoringHours(Instant instant)`	Same assertion as `isEqualToIgnoringHours(Date)` but given Date is represented as an `java.time.Instant`.
`SELF`	`isEqualToIgnoringHours(Date date)`	Same assertion as `AbstractAssert.isEqualTo(Object)` but the comparison ignores hours, minutes, seconds and milliseconds.
`SELF`	`isEqualToIgnoringMillis(String dateAsString)`	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)`).
`SELF`	`isEqualToIgnoringMillis(Instant instant)`	Same assertion as `isEqualToIgnoringMillis(Date)` but given Date is represented as an `java.time.Instant`.
`SELF`	`isEqualToIgnoringMillis(Date date)`	Same assertion as `AbstractAssert.isEqualTo(Object)` but given Date should not take care of milliseconds precision.
`SELF`	`isEqualToIgnoringMinutes(String dateAsString)`	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)`).
`SELF`	`isEqualToIgnoringMinutes(Instant instant)`	Same assertion as `isEqualToIgnoringMinutes(Date)` but given Date is represented as an `java.time.Instant`.
`SELF`	`isEqualToIgnoringMinutes(Date date)`	Same assertion as `AbstractAssert.isEqualTo(Object)` but given Date should not take care of minutes, seconds and milliseconds precision.
`SELF`	`isEqualToIgnoringSeconds(String dateAsString)`	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)`).
`SELF`	`isEqualToIgnoringSeconds(Instant instant)`	Same assertion as `isEqualToIgnoringSeconds(Date)` but given Date is represented as an `java.time.Instant`.
`SELF`	`isEqualToIgnoringSeconds(Date date)`	Same assertion as `AbstractAssert.isEqualTo(Object)` but given Date should not take care of seconds and milliseconds precision.
`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)`).
`SELF`	`isIn(Instant... instants)`	Same assertion as `Assert.isIn(Object...)`but given dates are represented as an `java.time.Instant`.
`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)`).
`SELF`	`isInSameDayAs(Instant other)`	Verifies that actual `Date` and given `Instant` have the same day of month, month and year fields values.
`SELF`	`isInSameDayAs(Date other)`	Verifies that actual and given `Date` have the same day of month, month and year fields values.
`SELF`	`isInSameHourAs(String dateAsString)`	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)`).
`SELF`	`isInSameHourAs(Date other)`	Verifies that actual and given `Date` have same hour, day, month and year fields values.
`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)`).
`SELF`	`isInSameHourWindowAs(Instant other)`	Verifies that actual `Date` and given `Instant` are chronologically in the same hour (i.e.
`SELF`	`isInSameHourWindowAs(Date other)`	Verifies that actual and given `Date` are chronologically in the same hour (i.e.
`SELF`	`isInSameMinuteAs(String dateAsString)`	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)`).
`SELF`	`isInSameMinuteAs(Date other)`	Verifies that actual and given `Date` have same minute, same hour, day, month and year fields values.
`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)`).
`SELF`	`isInSameMinuteWindowAs(Instant other)`	Verifies that actual `Date` and given `Instant` are chronologically in the same minute (i.e.
`SELF`	`isInSameMinuteWindowAs(Date other)`	Verifies that actual and given `Date` are chronologically in the same minute (i.e.
`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)`).
`SELF`	`isInSameMonthAs(Instant other)`	Verifies that actual `Date` and given `Instant` have same month and year fields.
`SELF`	`isInSameMonthAs(Date other)`	Verifies that actual and given `Date` have same month and year fields.
`SELF`	`isInSameSecondAs(String dateAsString)`	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)`).
`SELF`	`isInSameSecondAs(Date other)`	Verifies that actual and given `Date` have same second, minute, hour, day, month and year fields values.
`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)`).
`SELF`	`isInSameSecondWindowAs(Instant other)`	Verifies that actual `Date` and given `Instant` are chronologically strictly in the same second (i.e.
`SELF`	`isInSameSecondWindowAs(Date other)`	Verifies that actual and given `Date` are chronologically strictly in the same second (i.e.
`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)`).
`SELF`	`isInSameYearAs(Instant other)`	Verifies that actual `Date` and given `Instant` are in the same year.
`SELF`	`isInSameYearAs(Date other)`	Verifies that actual and given `Date` are in the same year.
`SELF`	`isInTheFuture()`	Verifies that the actual `Date` is strictly in the future.
`SELF`	`isInThePast()`	Verifies that the actual `Date` is strictly in the past.
`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)`).
`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)`).
`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)`).
`SELF`	`isNotBetween(Instant start, Instant end)`	Verifies that the actual `Date` is not in [start, end[ period
`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`.
`SELF`	`isNotBetween(Date start, Date end)`	Verifies that the actual `Date` is not in [start, end[ period
`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`.
`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)`).
`SELF`	`isNotEqualTo(Instant instant)`	Same assertion as `isNotEqualTo(Date date)` but given date is represented as an `java.time.Instant`.
`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)`).
`SELF`	`isNotIn(Instant... instants)`	Same assertion as `Assert.isNotIn(Object...)` but given dates are represented as `java.time.Instant`.
`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)`).
`SELF`	`isToday()`	Verifies that the actual `Date` is today, that is matching current year, month and day (no check on hour, minute, second, milliseconds).
`SELF`	`isWithinDayOfMonth(int dayOfMonth)`	Deprecated. use `hasDayOfMonth(int)` instead.
`SELF`	`isWithinDayOfWeek(int dayOfWeek)`	Deprecated. use `hasDayOfWeek(int)` instead.
`SELF`	`isWithinHourOfDay(int hourOfDay)`	Deprecated. use `hasHourOfDay(int)` instead.
`SELF`	`isWithinMillisecond(int millisecond)`	Deprecated. use `hasMillisecond(int)` instead.
`SELF`	`isWithinMinute(int minute)`	Deprecated. use `hasMinute(int)` instead.
`SELF`	`isWithinMonth(int month)`	Deprecated. use `hasMonth(int)` instead.
`SELF`	`isWithinSecond(int second)`	Deprecated. use `hasSecond(int)` instead.
`SELF`	`isWithinYear(int year)`	Deprecated. use `hasYear(int)` instead.
`(package private) Date`	`parse(String dateAsString)`	Thread safe utility method to parse a Date with `userDateFormats` first, then `DEFAULT_DATE_FORMATS`.
`private Date`	`parseDateWith(String dateAsString, Collection<DateFormat> dateFormats)`
`private Date`	`parseDateWithDefaultDateFormats(String dateAsString)`
`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)`.
`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)`.
`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).
`private static <T> Date[]`	`toDateArray(T[] values, Function<T,Date> converter)`
`static void`	`useDefaultDateFormatsOnly()`	Remove all registered custom date formats => use only the defaults date formats to parse string as date.
`SELF`	`usingComparator(Comparator<? super Date> customComparator)`	Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
`SELF`	`usingComparator(Comparator<? super Date> customComparator, String customComparatorDescription)`	Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
`SELF`	`usingDefaultComparator()`	Revert to standard comparison for the incoming assertion checks.
`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 : this method `withDateFormat(java.text.DateFormat)` `registerCustomDateFormat(java.text.DateFormat)` `registerCustomDateFormat(String)`
`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 : `withDateFormat(String)` this method `registerCustomDateFormat(java.text.DateFormat)` `registerCustomDateFormat(String)`
`SELF`	`withDefaultDateFormatsOnly()`	Remove all registered custom date formats => use only the defaults date formats to parse string as date.

Methods inherited from class org.assertj.core.api.AbstractAssert
asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, inHexadecimal, is, isElementOfCustomAssert, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOfForProxy, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingRecursiveComparison, usingRecursiveComparison, withAssertionState, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.assertj.core.api.Descriptable
as, as, as, describedAs

- Field Detail
  - DEFAULT_DATE_FORMATS
```
static final List<DateFormat> DEFAULT_DATE_FORMATS
```
    the default DateFormat used to parse any String date representation.
  - DATE_FORMAT_PATTERN_SHOULD_NOT_BE_NULL
```
private static final String DATE_FORMAT_PATTERN_SHOULD_NOT_BE_NULL
```
    See Also:
    
    Constant Field Values
  - DATE_FORMAT_SHOULD_NOT_BE_NULL
```
private static final String DATE_FORMAT_SHOULD_NOT_BE_NULL
```
    See Also:
    
    Constant Field Values
  - userDateFormats
```
static ThreadLocal<LinkedHashSet<DateFormat>> userDateFormats
```
    Used in String based Date assertions - like isAfter(String) - to convert input date represented as string to Date.
    It keeps the insertion order so first format added will be first format used.
  - dates
```
org.assertj.core.internal.Dates dates
```
- Constructor Detail
  - AbstractDateAssert
```
protected AbstractDateAssert(Date actual,
                             Class<?> selfType)
```
- Method Detail
  - 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
```
public SELF isEqualToIgnoringHours(String dateAsString)
```
    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
```
public SELF isEqualToIgnoringHours(Instant instant)
```
    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
```
public SELF isEqualToIgnoringHours(Date date)
```
    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
```
public SELF isEqualToIgnoringMinutes(String dateAsString)
```
    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
```
public SELF isEqualToIgnoringMinutes(Instant instant)
```
    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
```
public SELF isEqualToIgnoringMinutes(Date date)
```
    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
```
public SELF isEqualToIgnoringSeconds(String dateAsString)
```
    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
```
public SELF isEqualToIgnoringSeconds(Instant instant)
```
    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
```
public SELF isEqualToIgnoringSeconds(Date date)
```
    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
```
public SELF isEqualToIgnoringMillis(String dateAsString)
```
    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
```
public SELF isEqualToIgnoringMillis(Instant instant)
```
    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
```
public SELF isEqualToIgnoringMillis(Date date)
```
    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:
    // assertion will fail assertThat(theTwoTowers.getReleaseDate()).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
```
public SELF isInSameHourAs(Date other)
```
    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
```
public SELF isInSameHourAs(String dateAsString)
```
    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
```
public SELF isInSameMinuteAs(Date other)
```
    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
```
public SELF isInSameMinuteAs(String dateAsString)
```
    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
```
public SELF isInSameSecondAs(Date other)
```
    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
```
public SELF isInSameSecondAs(String dateAsString)
```
    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, 80) .isCloseTo(date2, 100); // assertion fails assertThat(date1).isCloseTo(date2, 101);
    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:
    
    Date.getTime()
  - 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:
    
    Date.getTime()
  - 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 :
    
    withDateFormat(String)
    
    this method
    
    registerCustomDateFormat(java.text.DateFormat)
    
    registerCustomDateFormat(String)
    
    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 :
    
    this method
    
    withDateFormat(java.text.DateFormat)
    
    registerCustomDateFormat(java.text.DateFormat)
    
    registerCustomDateFormat(String)
    
    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 :
    
    withDateFormat(String)
    
    withDateFormat(java.text.DateFormat)
    
    this method
    
    registerCustomDateFormat(String)
    
    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 :
    
    withDateFormat(String)
    
    withDateFormat(java.text.DateFormat)
    
    registerCustomDateFormat(java.text.DateFormat)
    
    this method
    
    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
  - parse
```
Date parse(String dateAsString)
```
    Thread safe utility method to parse a Date with userDateFormats first, then DEFAULT_DATE_FORMATS.
    Returns null if dateAsString parameter is null.
    
    Parameters:
    
    dateAsString - the string to parse as a Date with userDateFormats
    
    Returns:
    
    the corresponding Date, null if dateAsString parameter is null.
    
    Throws:
    
    AssertionError - if the string can't be parsed as a Date
  - parseDateWithDefaultDateFormats
```
private Date parseDateWithDefaultDateFormats(String dateAsString)
```
  - dateFormatsInOrderOfUsage
```
private List<DateFormat> dateFormatsInOrderOfUsage()
```
  - parseDateWith
```
private Date parseDateWith(String dateAsString,
                           Collection<DateFormat> dateFormats)
```
  - toDateArray
```
private static <T> Date[] toDateArray(T[] values,
                                      Function<T,Date> converter)
```
  - 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.

Class AbstractDateAssert<SELF extends AbstractDateAssert<SELF>>

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Methods inherited from interface org.assertj.core.api.Descriptable

Field Detail

DEFAULT_DATE_FORMATS

DATE_FORMAT_PATTERN_SHOULD_NOT_BE_NULL

DATE_FORMAT_SHOULD_NOT_BE_NULL

userDateFormats

dates

Constructor Detail

AbstractDateAssert

Method Detail

isEqualTo

isEqualTo

isEqualToIgnoringHours

isEqualToIgnoringHours

isEqualToIgnoringHours

isEqualToIgnoringMinutes

isEqualToIgnoringMinutes

isEqualToIgnoringMinutes

isEqualToIgnoringSeconds

isEqualToIgnoringSeconds

isEqualToIgnoringSeconds

isEqualToIgnoringMillis

isEqualToIgnoringMillis

isEqualToIgnoringMillis

isNotEqualTo

isNotEqualTo

isIn

isIn

isInWithStringDateCollection

isNotIn

isNotIn

isNotInWithStringDateCollection

isBefore

isBefore

isBefore

isBeforeOrEqualsTo

isBeforeOrEqualTo

isBeforeOrEqualTo

isBeforeOrEqualsTo

isBeforeOrEqualTo

isAfter

isAfter

isAfter

isAfterOrEqualsTo

isAfterOrEqualTo

isAfterOrEqualTo

isAfterOrEqualsTo

isAfterOrEqualTo

isBetween

isBetween

isBetween

isBetween

isBetween

isBetween

isNotBetween

isNotBetween

isNotBetween

isNotBetween

isNotBetween

isNotBetween

isInThePast

isToday

isInTheFuture

isBeforeYear

isAfterYear

hasYear

isWithinYear

hasMonth

isWithinMonth

hasDayOfMonth

isWithinDayOfMonth

hasDayOfWeek

isWithinDayOfWeek