org.fest.assertions.api
Class DateAssert

java.lang.Object
  extended by org.fest.assertions.api.AbstractAssert<DateAssert,Date>
      extended by org.fest.assertions.api.DateAssert
All Implemented Interfaces:
Assert<DateAssert,Date>, Descriptable<DateAssert>, ExtensionPoints<DateAssert,Date>

public class DateAssert
extends AbstractAssert<DateAssert,Date>

Assertions for Dates.

To create a new instance of this class invoke Assertions.assertThat(Date).

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 withIsoDateFormat().

Author:
Tomasz Nurkiewicz (thanks for giving assertions idea), Joel Costigliola

Field Summary
 
Fields inherited from class org.fest.assertions.api.AbstractAssert
actual, myself
 
Constructor Summary
protected DateAssert(Date actual)
          Creates a new DateAssert.
 
Method Summary
 DateAssert isAfter(Date other)
          Verifies that the actual Date is strictly after the given one.
 DateAssert isAfter(String dateAsString)
          Same assertion as isAfter(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isAfterOrEqualsTo(Date other)
          Verifies that the actual Date is after or equals to the given one.
 DateAssert isAfterOrEqualsTo(String dateAsString)
          Same assertion as isAfterOrEqualsTo(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isAfterYear(int year)
          Verifies that the actual Date is strictly after the given year.
 DateAssert isBefore(Date other)
          Verifies that the actual Date is strictly before the given one.
 DateAssert isBefore(String dateAsString)
          Same assertion as isBefore(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isBeforeOrEqualsTo(Date other)
          Verifies that the actual Date is before or equals to the given one.
 DateAssert isBeforeOrEqualsTo(String dateAsString)
          Same assertion as isBeforeOrEqualsTo(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isBeforeYear(int year)
          Verifies that the actual Date is strictly before the given year.
 DateAssert isBetween(Date start, Date end)
          Verifies that the actual Date is in [start, end[ period (start included, end excluded).
 DateAssert 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.
 DateAssert isBetween(String start, String end)
          Same assertion as isBetween(Date, Date) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isBetween(String start, String end, boolean inclusiveStart, boolean inclusiveEnd)
          Same assertion as isBetween(Date, Date, boolean, boolean) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert 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 equals to delta it's ok.
 DateAssert isCloseTo(String dateAsString, long deltaInMilliseconds)
          Same assertion as isCloseTo(Date, long) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isEqualTo(String dateAsString)
          Same assertion as isEqualTo(Date date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isIn(String... datesAsString)
          Same assertion as Assert.isIn(Object...) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isInSameDayAs(Date other)
          Verifies that actual and given Date are chronologically in the same day of month (and thus in the same month and year).
 DateAssert isInSameDayAs(String dateAsString)
          Same assertion as isInSameDayAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isInSameHourAs(Date other)
          Verifies that actual and given Date are chronologically in the same hour (and thus in the same day, month and year).
 DateAssert isInSameHourAs(String dateAsString)
          Same assertion as isInSameHourAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isInSameMinuteAs(Date other)
          Verifies that actual and given Date are chronologically in the same minute (and thus in the same hour, day, month and year).
 DateAssert isInSameMinuteAs(String dateAsString)
          Same assertion as isInSameMinuteAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isInSameMonthAs(Date other)
          Verifies that actual and given Date are chronologically in the same month (and thus in the same year).
 DateAssert isInSameMonthAs(String dateAsString)
          Same assertion as isInSameMonthAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isInSameSecondAs(Date other)
          Verifies that actual and given Date are chronologically in the same second (and thus in the same minute, hour, day, month and year).
 DateAssert isInSameSecondAs(String dateAsString)
          Same assertion as isInSameSecondAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isInSameYearAs(Date other)
          Verifies that actual and given Date are in the same year.
 DateAssert isInSameYearAs(String dateAsString)
          Same assertion as isInSameYearAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isInTheFuture()
          Verifies that the actual Date is strictly in the future.
 DateAssert isInThePast()
          Verifies that the actual Date is strictly in the past.
 DateAssert isInWithStringDateCollection(Collection<String> datesAsString)
          Same assertion as Assert.isIn(Collection) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isNotBetween(Date start, Date end)
          Verifies that the actual Date is not in [start, end[ period
 DateAssert 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.
 DateAssert isNotBetween(String start, String end)
          Same assertion as isNotBetween(Date, Date) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isNotBetween(String start, String end, boolean inclusiveStart, boolean inclusiveEnd)
          Same assertion as isNotBetween(Date, Date, boolean, boolean) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isNotEqualTo(String dateAsString)
          Same assertion as isNotEqualTo(Date date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isNotIn(String... datesAsString)
          Same assertion as Assert.isNotIn(Object...) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isNotInWithStringDateCollection(Collection<String> datesAsString)
          Same assertion as Assert.isNotIn(Collection) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
 DateAssert isToday()
          Verifies that the actual Date is today, that is matching current year, month and day (no check on hour, minute, second, milliseconds).
 DateAssert isWithinDayOfMonth(int dayOfMonth)
          Verifies that the actual Date day of month is equal to the given day of month.
 DateAssert isWithinDayOfWeek(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).
 DateAssert isWithinHourOfDay(int hourOfDay)
          Verifies that the actual Date hour od day is equal to the given hour of day (24-hour clock).
 DateAssert isWithinMillisecond(int millisecond)
          Verifies that the actual Date millisecond is equal to the given millisecond.
 DateAssert isWithinMinute(int minute)
          Verifies that the actual Date minute is equal to the given minute.
 DateAssert isWithinMonth(int month)
          Verifies that the actual Date month is equal to the given month, month value starting at 1 (January=1, February=2, ...).
 DateAssert isWithinSecond(int second)
          Verifies that the actual Date second is equal to the given second.
 DateAssert isWithinYear(int year)
          Verifies that the actual Date year is equal to the given year.
static void useDateFormat(DateFormat userCustomDateFormat)
          For String based Date assertions like isBefore(String), given String is expected to follow the default Date format, that is ISO 8601 format : "yyyy-MM-dd".
static void useIsoDateFormat()
          Use ISO 8601 date format ("yyyy-MM-dd") for String based Date assertions.
 DateAssert usingComparator(Comparator<?> customComparator)
          Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
 DateAssert usingDefaultComparator()
          Revert to standard comparison for incoming assertion checks.
 DateAssert withDateFormat(DateFormat userCustomDateFormat)
          For String based Date assertions like isBefore(String), given String is expected to follow the default Date format, that is ISO 8601 format : "yyyy-MM-dd".
 DateAssert withIsoDateFormat()
          Use ISO 8601 date format ("yyyy-MM-dd") for String based Date assertions.
 
Methods inherited from class org.fest.assertions.api.AbstractAssert
as, as, describedAs, describedAs, descriptionText, doesNotHave, equals, has, hashCode, is, isEqualTo, isIn, isIn, isNot, isNotEqualTo, isNotIn, isNotIn, isNotNull, isNotSameAs, isNull, isSameAs
 
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

DateAssert

protected DateAssert(Date actual)
Creates a new DateAssert.

Parameters:
actual - the target to verify.
Method Detail

isEqualTo

public DateAssert isEqualTo(String dateAsString)
Same assertion as isEqualTo(Date date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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.

isNotEqualTo

public DateAssert isNotEqualTo(String dateAsString)
Same assertion as isNotEqualTo(Date date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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.

isIn

public DateAssert isIn(String... datesAsString)
Same assertion as Assert.isIn(Object...) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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.

isInWithStringDateCollection

public DateAssert isInWithStringDateCollection(Collection<String> datesAsString)
Same assertion as Assert.isIn(Collection) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
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 DateAssert isNotIn(String... datesAsString)
Same assertion as Assert.isNotIn(Object...) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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.

isNotInWithStringDateCollection

public DateAssert isNotInWithStringDateCollection(Collection<String> datesAsString)
Same assertion as Assert.isNotIn(Collection) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).
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 DateAssert isBefore(Date other)
Verifies that the actual Date is strictly before the given one.

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 DateAssert isBefore(String dateAsString)
Same assertion as isBefore(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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

public DateAssert isBeforeOrEqualsTo(Date other)
Verifies that the actual Date is before or equals to the given one.

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.

isBeforeOrEqualsTo

public DateAssert isBeforeOrEqualsTo(String dateAsString)
Same assertion as isBeforeOrEqualsTo(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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 DateAssert isAfter(Date other)
Verifies that the actual Date is strictly after the given one.

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 DateAssert isAfter(String dateAsString)
Same assertion as isAfter(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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

public DateAssert isAfterOrEqualsTo(Date other)
Verifies that the actual Date is after or equals to the given one.

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.

isAfterOrEqualsTo

public DateAssert isAfterOrEqualsTo(String dateAsString)
Same assertion as isAfterOrEqualsTo(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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 DateAssert isBetween(Date start,
                            Date end)
Verifies that the actual Date is in [start, end[ period (start included, end excluded).

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 DateAssert isBetween(String start,
                            String end)
Same assertion as isBetween(Date, Date) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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 DateAssert 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.

Parameters:
start - the period start, expected not to be null.
end - the period end, expected not to be null.
inclusiveStart - wether to include start date in period.
inclusiveEnd - wether 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 DateAssert isBetween(String start,
                            String end,
                            boolean inclusiveStart,
                            boolean inclusiveEnd)
Same assertion as isBetween(Date, Date, boolean, boolean) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

Parameters:
start - the period start, expected not to be null.
end - the period end, expected not to be null.
inclusiveStart - wether to include start date in period.
inclusiveEnd - wether 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 DateAssert 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.

Parameters:
start - the period start (inclusive), expected not to be null.
end - the period end (exclusive), expected not to be null.
inclusiveStart - wether to include start date in period.
inclusiveEnd - wether 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 DateAssert isNotBetween(String start,
                               String end,
                               boolean inclusiveStart,
                               boolean inclusiveEnd)
Same assertion as isNotBetween(Date, Date, boolean, boolean) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

Parameters:
start - the period start (inclusive), expected not to be null.
end - the period end (exclusive), expected not to be null.
inclusiveStart - wether to include start date in period.
inclusiveEnd - wether 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 DateAssert isNotBetween(Date start,
                               Date end)
Verifies that the actual Date is not in [start, end[ period

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.
AssertionError - if one of the given date as String could not be converted to a Date.

isNotBetween

public DateAssert isNotBetween(String start,
                               String end)
Same assertion as isNotBetween(Date, Date) but given Dates are represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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 DateAssert isInThePast()
Verifies that the actual Date is strictly in the past.

Returns:
this assertion object.
Throws:
AssertionError - if the actual Date is null.
AssertionError - if the actual Date is not in the past.

isToday

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

Returns:
this assertion object.
Throws:
AssertionError - if the actual Date is null.
AssertionError - if the actual Date is not today.

isInTheFuture

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

Returns:
this assertion object.
Throws:
AssertionError - if the actual Date is null.
AssertionError - if the actual Date is not in the future.

isBeforeYear

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

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 DateAssert isAfterYear(int year)
Verifies that the actual Date is strictly after the given year.

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.

isWithinYear

public DateAssert isWithinYear(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 (see usingComparator(Comparator).

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.

isWithinMonth

public DateAssert isWithinMonth(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 (see usingComparator(Comparator).

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.

isWithinDayOfMonth

public DateAssert isWithinDayOfMonth(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 (see usingComparator(Comparator).

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.

isWithinDayOfWeek

public DateAssert isWithinDayOfWeek(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 (see usingComparator(Comparator).

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.

isWithinHourOfDay

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

Note that using a custom comparator has no effect on this assertion (see usingComparator(Comparator).

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.

isWithinMinute

public DateAssert isWithinMinute(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 (see usingComparator(Comparator).

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.

isWithinSecond

public DateAssert isWithinSecond(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 (see usingComparator(Comparator).

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.

isWithinMillisecond

public DateAssert isWithinMillisecond(int millisecond)
Verifies that the actual Date millisecond is equal to the given millisecond.

Note that using a custom comparator has no effect on this assertion (see usingComparator(Comparator).

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.

isInSameYearAs

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

Note that using a custom comparator has no effect on this assertion (see usingComparator(Comparator).

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 DateAssert isInSameYearAs(String dateAsString)
Same assertion as isInSameYearAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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 DateAssert isInSameMonthAs(Date other)
Verifies that actual and given Date are chronologically in the same month (and thus in the same year).

If you want to compare month only (without year), use : assertThat(myDate).isWithinMonth(monthOf(otherDate))
See Dates.monthOf(Date) to get the month of a given Date.

Note that using a custom comparator has no effect on this assertion (see usingComparator(Comparator).

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.

isInSameMonthAs

public DateAssert isInSameMonthAs(String dateAsString)
Same assertion as isInSameMonthAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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 DateAssert isInSameDayAs(Date other)
Verifies that actual and given Date are chronologically in the same day of month (and thus in the same month and year).

If you want to compare day of month only (without month and year), you could write : assertThat(myDate).isWithinDayOfMonth(dayOfMonthOf(otherDate))
see Dates.dayOfMonthOf(Date) to get the day of month of a given Date.

Note that using a custom comparator has no effect on this assertion (see usingComparator(Comparator).

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 of month.

isInSameDayAs

public DateAssert isInSameDayAs(String dateAsString)
Same assertion as isInSameDayAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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 DateAssert isInSameHourAs(Date other)
Verifies that actual and given Date are chronologically in the same hour (and thus in the same day, month and year).

If you want to compare hour only (without day, month and year), you could write : assertThat(myDate).isWithinHour(hourOfDayOf(otherDate))
see Dates.hourOfDay(Date) to get the hour of a given Date.

Note that using a custom comparator has no effect on this assertion (see usingComparator(Comparator).

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.

isInSameHourAs

public DateAssert isInSameHourAs(String dateAsString)
Same assertion as isInSameHourAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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.

isInSameMinuteAs

public DateAssert isInSameMinuteAs(Date other)
Verifies that actual and given Date are chronologically in the same minute (and thus in the same hour, day, month and year).

If you want to compare minute only (without hour, day, month and year), you could write : assertThat(myDate).isWithinMinute(minuteOf(otherDate))
see Dates.minuteOf(Date) to get the minute of a given Date.

Note that using a custom comparator has no effect on this assertion (see usingComparator(Comparator).

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 DateAssert isInSameMinuteAs(String dateAsString)
Same assertion as isInSameMinuteAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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.

isInSameSecondAs

public DateAssert isInSameSecondAs(Date other)
Verifies that actual and given Date are chronologically in the same second (and thus in the same minute, hour, day, month and year).

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

Note that using a custom comparator has no effect on this assertion (see usingComparator(Comparator).

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 DateAssert isInSameSecondAs(String dateAsString)
Same assertion as isInSameSecondAs(Date) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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 second.

isCloseTo

public DateAssert 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 equals 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 (see usingComparator(Comparator).

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 week is not close to the given date by less than delta.

isCloseTo

public DateAssert isCloseTo(String dateAsString,
                            long deltaInMilliseconds)
Same assertion as isCloseTo(Date, long) but given Date is represented as String either with ISO date format (yyyy-MM-dd) or user custom date format (set with method withDateFormat(DateFormat)).

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 week is not close to the given date by less than delta.

withDateFormat

public DateAssert withDateFormat(DateFormat userCustomDateFormat)
For String based Date assertions like isBefore(String), given String is expected to follow the default Date format, that is ISO 8601 format : "yyyy-MM-dd".

With this method, user can specify its own date format, replacing the current date format for all future Date assertions in the test suite (i.e. not only the current assertions) since custom DateFormat is stored in a static field.

To revert to default format simply call withIsoDateFormat().

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

useDateFormat

public static void useDateFormat(DateFormat userCustomDateFormat)
For String based Date assertions like isBefore(String), given String is expected to follow the default Date format, that is ISO 8601 format : "yyyy-MM-dd".

With this method, user can specify its own date format, replacing the current date format for all future Date assertions in the test suite (i.e. not only the current assertions) since custom DateFormat is stored in a static field.

To revert to default format simply call useIsoDateFormat() (static method) or withIsoDateFormat().

Parameters:
userCustomDateFormat - the new Date format used for String based Date assertions.

withIsoDateFormat

public DateAssert withIsoDateFormat()
Use ISO 8601 date format ("yyyy-MM-dd") for String based Date assertions.

Returns:
this assertion object.

useIsoDateFormat

public static void useIsoDateFormat()
Use ISO 8601 date format ("yyyy-MM-dd") for String based Date assertions.


usingComparator

public DateAssert usingComparator(Comparator<?> customComparator)
Description copied from class: AbstractAssert
Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default comparison strategy.

Example :
 // compares invoices by payee 
 assertThat(invoiceList).usingComparator(invoicePayeeComparator).isEqualTo(expectedInvoiceList).
 
 // compares invoices by date, doesNotHaveDuplicates and contains both use the given invoice date comparator
 assertThat(invoiceList).usingComparator(invoiceDateComparator).doesNotHaveDuplicates().contains(may2010Invoice)
 
 // as assertThat(invoiceList) creates a new assertion, it uses standard comparison strategy (Invoice's equal method) to compare invoiceList elements to lowestInvoice.                                                      
 assertThat(invoiceList).contains(lowestInvoice).
 
Custom comparator is not parameterized with actual type A (ie. Comparator<A>) because if it was, we could not write the following code :
 // frodo and sam are instances of Character (a Character having a Race)
 // raceComparator implements Comparator<Character> 
 // assertThat(frodo) returns an ObjectAssert and not a custom CharacterAssert implementing Assert<CharacterAssert, Character>  
 assertThat(frodo).usingComparator(raceComparator).isEqualTo(sam); // won't compile !
 
 The code does not compile because assertThat(frodo) returns an ObjectAssert, thus usingComparator expects a Comparator<Object> 
 and Comparator<Character> is not a Comparator<Object> as generics are not reified.
 
 Note that, it would have worked if assertThat(frodo) returned a CharacterAssert implementing Assert<CharacterAssert, Character>. 
 

Specified by:
usingComparator in interface Assert<DateAssert,Date>
Overrides:
usingComparator in class AbstractAssert<DateAssert,Date>
Parameters:
customComparator - the comparator to use for incoming assertion checks.
Returns:
this assertion object.

usingDefaultComparator

public DateAssert usingDefaultComparator()
Description copied from class: AbstractAssert
Revert to standard comparison for incoming assertion checks.
This method should be used to disable a custom comparison strategy set by calling Assert.usingComparator(Comparator).

Specified by:
usingDefaultComparator in interface Assert<DateAssert,Date>
Overrides:
usingDefaultComparator in class AbstractAssert<DateAssert,Date>
Returns:
this assertion object.


Copyright © 2007-2012 FEST (Fixtures for Easy Software Testing). All Rights Reserved.