コード例 #1
0
 /**
  * Verifies that the actual {@code Date} day of week is equal to the given day of week (see {@link
  * Calendar#DAY_OF_WEEK} for valid values).
  *
  * <p>Note that using a custom comparator has no effect on this assertion (see {@link
  * #usingComparator(Comparator)}.
  *
  * @param dayOfWeek the day of week to compare actual day of week to, see {@link
  *     Calendar#DAY_OF_WEEK} for valid values
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} week is not equal to the given day of week.
  */
 public DateAssert isWithinDayOfWeek(int dayOfWeek) {
   dates.assertIsWithinDayOfWeek(info, actual, dayOfWeek);
   return this;
 }
コード例 #2
0
 /**
  * Verifies that the actual {@code Date} hour od day is equal to the given hour of day (24-hour
  * clock).
  *
  * <p>Note that using a custom comparator has no effect on this assertion (see {@link
  * #usingComparator(Comparator)}.
  *
  * @param hourOfDay the hour of day to compare actual hour of day to (24-hour clock)
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} hour is not equal to the given hour.
  */
 public DateAssert isWithinHourOfDay(int hourOfDay) {
   dates.assertIsWithinHourOfDay(info, actual, hourOfDay);
   return this;
 }
コード例 #3
0
 /**
  * Verifies that the actual {@code Date} month is equal to the given month, <b>month value
  * starting at 1</b> (January=1, February=2, ...).
  *
  * <p>Note that using a custom comparator has no effect on this assertion (see {@link
  * #usingComparator(Comparator)}.
  *
  * @param month the month to compare actual month to, <b>month value starting at 1</b> (January=1,
  *     February=2, ...).
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} month is not equal to the given month.
  */
 public DateAssert isWithinMonth(int month) {
   dates.assertIsWithinMonth(info, actual, month);
   return this;
 }
コード例 #4
0
 /**
  * Verifies that the actual {@code Date} day of month is equal to the given day of month.
  *
  * <p>Note that using a custom comparator has no effect on this assertion (see {@link
  * #usingComparator(Comparator)}.
  *
  * @param dayOfMonth the day of month to compare actual day of month to
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} month is not equal to the given day of month.
  */
 public DateAssert isWithinDayOfMonth(int dayOfMonth) {
   dates.assertIsWithinDayOfMonth(info, actual, dayOfMonth);
   return this;
 }
コード例 #5
0
 /**
  * Verifies that the actual {@code Date} is close to the other date by less than delta (expressed
  * in milliseconds), if difference is equals to delta it's ok.
  *
  * <p>One can use handy {@link TimeUnit} to convert a duration in milliseconds, for example you
  * can express a delta of 5 seconds with <code>TimeUnit.SECONDS.toMillis(5)</code>.
  *
  * <p>Note that using a custom comparator has no effect on this assertion (see {@link
  * #usingComparator(Comparator)}.
  *
  * @param other the date to compare actual to
  * @param deltaInMilliseconds the delta used for date comparison, expressed in milliseconds
  * @return this assertion object.
  * @throws NullPointerException if {@code Date} parameter is {@code null}.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} week is not close to the given date by less
  *     than delta.
  */
 public DateAssert isCloseTo(Date other, long deltaInMilliseconds) {
   dates.assertIsCloseTo(info, actual, other, deltaInMilliseconds);
   return this;
 }
コード例 #6
0
 /**
  * Verifies that the actual {@code Date} is after or equals to the given one.
  *
  * @param other the given Date.
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws NullPointerException if other {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} is not after or equals to the given one.
  */
 public DateAssert isAfterOrEqualsTo(Date other) {
   dates.assertIsAfterOrEqualsTo(info, actual, other);
   return this;
 }
コード例 #7
0
 /**
  * Verifies that the actual {@code Date} is strictly in the future.
  *
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} is not in the future.
  */
 public DateAssert isInTheFuture() {
   dates.assertIsInTheFuture(info, actual);
   return this;
 }
コード例 #8
0
 /**
  * Verifies that the actual {@code Date} millisecond is equal to the given millisecond.
  *
  * <p>Note that using a custom comparator has no effect on this assertion (see {@link
  * #usingComparator(Comparator)}.
  *
  * @param millisecond the millisecond to compare actual millisecond to
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} millisecond is not equal to the given
  *     millisecond.
  */
 public DateAssert isWithinMillisecond(int millisecond) {
   dates.assertIsWithinMillisecond(info, actual, millisecond);
   return this;
 }
コード例 #9
0
 /**
  * Verifies that the actual {@code Date} is strictly in the past.
  *
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} is not in the past.
  */
 public DateAssert isInThePast() {
   dates.assertIsInThePast(info, actual);
   return this;
 }
コード例 #10
0
 /**
  * Verifies that the actual {@code Date} is today, that is matching current year, month and day
  * (no check on hour, minute, second, milliseconds).
  *
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} is not today.
  */
 public DateAssert isToday() {
   dates.assertIsToday(info, actual);
   return this;
 }
コード例 #11
0
 /**
  * Verifies that the actual {@code Date} is not in the given period defined by start and end
  * dates.<br>
  * To include start in the period set inclusiveStart parameter to <code>true</code>.<br>
  * To include end in the period set inclusiveEnd parameter to <code>true</code>.<br>
  *
  * @param start the period start (inclusive), expected not to be null.
  * @param end the period end (exclusive), expected not to be null.
  * @param inclusiveStart wether to include start date in period.
  * @param inclusiveEnd wether to include end date in period.
  * @return this assertion object.
  * @throws AssertionError if {@code actual} is {@code null}.
  * @throws NullPointerException if start {@code Date} is {@code null}.
  * @throws NullPointerException if end {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} is not in (start, end) period.
  */
 public DateAssert isNotBetween(
     Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd) {
   dates.assertIsNotBetween(info, actual, start, end, inclusiveStart, inclusiveEnd);
   return this;
 }
コード例 #12
0
 /**
  * Same assertion as {@link #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 {@link #withDateFormat(DateFormat)}).
  *
  * @param start the period start, expected not to be null.
  * @param end the period end, expected not to be null.
  * @param inclusiveStart wether to include start date in period.
  * @param inclusiveEnd wether to include end date in period.
  * @return this assertion object.
  * @throws AssertionError if {@code actual} is {@code null}.
  * @throws NullPointerException if start Date as String is {@code null}.
  * @throws NullPointerException if end Date as String is {@code null}.
  * @throws AssertionError if the actual {@code Date} is not in (start, end) period.
  * @throws AssertionError if one of the given date as String could not be converted to a Date.
  */
 public DateAssert isBetween(
     String start, String end, boolean inclusiveStart, boolean inclusiveEnd) {
   dates.assertIsBetween(info, actual, parse(start), parse(end), inclusiveStart, inclusiveEnd);
   return this;
 }
コード例 #13
0
/**
 * Assertions for {@code Date}s.
 *
 * <p>To create a new instance of this class invoke <code>{@link Assertions#assertThat(Date)}</code>
 * . Note that assertions with date parameter comes with two flavor, one is obviously a {@link Date}
 * and the other is a String representing a Date.<br>
 * For the latter, the default format follows ISO 8901 : "yyyy-MM-dd", user can override it with a
 * custom format by calling {@link #withDateFormat(DateFormat)}.<br>
 * 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.<br>
 * To turn back to default format, simply call {@link #withIsoDateFormat()}.
 *
 * @author Tomasz Nurkiewicz (thanks for giving assertions idea)
 * @author Joel Costigliola
 */
public class DateAssert extends AbstractAssert<DateAssert, Date> {

  @VisibleForTesting Dates dates = Dates.instance();

  /**
   * Used in String based Date assertions - like {@link #isAfter(String)} - to convert input date
   * represented as string to Date.<br>
   * The format used can be overriden by invoking {@link #withDateFormat(DateFormat)}
   */
  @VisibleForTesting static DateFormat dateFormat = ISO_DATE_FORMAT;

  /**
   * Creates a new </code>{@link DateAssert}</code>.
   *
   * @param actual the target to verify.
   */
  protected DateAssert(Date actual) {
    super(actual, DateAssert.class);
  }

  /**
   * Same assertion as {@link AbstractAssert#isEqualTo(Object) 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 {@link #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws AssertionError if actual and given Date represented as String are not equal.
   * @throws AssertionError if the given date as String could not be converted to a Date.
   */
  public DateAssert isEqualTo(String dateAsString) {
    return isEqualTo(parse(dateAsString));
  }

  /**
   * Same assertion as {@link AbstractAssert#isNotEqualTo(Object) 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 {@link #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws AssertionError if actual and given Date represented as String are equal.
   * @throws AssertionError if the given date as String could not be converted to a Date.
   */
  public DateAssert isNotEqualTo(String dateAsString) {
    return isNotEqualTo(parse(dateAsString));
  }

  /**
   * Same assertion as {@link 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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param datesAsString the given Dates represented as String in default or custom date format.
   * @return this assertion object.
   * @throws AssertionError if actual is not in given Dates represented as String.
   * @throws AssertionError if one of the given date as String could not be converted to a Date.
   */
  public DateAssert isIn(String... datesAsString) {
    Date[] dates = new Date[datesAsString.length];
    for (int i = 0; i < datesAsString.length; i++) {
      dates[i] = parse(datesAsString[i]);
    }
    return isIn(dates);
  }

  /**
   * Same assertion as {@link 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 {@link
   * #withDateFormat(DateFormat)}).<br>
   * Method signature could not be <code>isIn(Collection&lt;String&gt;)</code> because it would be
   * same signature as <code>isIn(Collection&lt;Date&gt;)</code> since java collection type are
   * erased at runtime.
   *
   * @param datesAsString the given Dates represented as String in default or custom date format.
   * @return this assertion object.
   * @throws AssertionError if actual is not in given Dates represented as String.
   * @throws AssertionError if one of the given date as String could not be converted to a Date.
   */
  public DateAssert isInWithStringDateCollection(Collection<String> datesAsString) {
    Collection<Date> dates = new ArrayList<Date>(datesAsString.size());
    for (String dateAsString : datesAsString) {
      dates.add(parse(dateAsString));
    }
    return isIn(dates);
  }

  /**
   * Same assertion as {@link 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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param datesAsString the given Dates represented as String in default or custom date format.
   * @return this assertion object.
   * @throws AssertionError if actual is in given Dates represented as String.
   * @throws AssertionError if one of the given date as String could not be converted to a Date.
   */
  public DateAssert isNotIn(String... datesAsString) {
    Date[] dates = new Date[datesAsString.length];
    for (int i = 0; i < datesAsString.length; i++) {
      dates[i] = parse(datesAsString[i]);
    }
    return isNotIn(dates);
  }

  /**
   * Same assertion as {@link 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 {@link
   * #withDateFormat(DateFormat)}).<br>
   * Method signature could not be <code>isNotIn(Collection&lt;String&gt;)</code> because it would
   * be same signature as <code>isNotIn(Collection&lt;Date&gt;)</code> since java collection type
   * are erased at runtime.
   *
   * @param datesAsString the given Dates represented as String in default or custom date format.
   * @return this assertion object.
   * @throws AssertionError if actual is in given Dates represented as String.
   * @throws AssertionError if one of the given date as String could not be converted to a Date.
   */
  public DateAssert isNotInWithStringDateCollection(Collection<String> datesAsString) {
    Collection<Date> dates = new ArrayList<Date>(datesAsString.size());
    for (String dateAsString : datesAsString) {
      dates.add(parse(dateAsString));
    }
    return isNotIn(dates);
  }

  /**
   * Verifies that the actual {@code Date} is <b>strictly</b> before the given one.
   *
   * @param other the given Date.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if other {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not strictly before the given one.
   */
  public DateAssert isBefore(Date other) {
    dates.assertIsBefore(info, actual, other);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if given date as String is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not strictly before the given Date
   *     represented as String.
   * @throws AssertionError if the given date as String could not be converted to a Date.
   */
  public DateAssert isBefore(String dateAsString) {
    return isBefore(parse(dateAsString));
  }

  /**
   * Verifies that the actual {@code Date} is before or equals to the given one.
   *
   * @param other the given Date.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if other {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not before or equals to the given one.
   */
  public DateAssert isBeforeOrEqualsTo(Date other) {
    dates.assertIsBeforeOrEqualsTo(info, actual, other);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if given date as String is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not before or equals to the given Date
   *     represented as String.
   * @throws AssertionError if the given date as String could not be converted to a Date.
   */
  public DateAssert isBeforeOrEqualsTo(String dateAsString) {
    return isBeforeOrEqualsTo(parse(dateAsString));
  }

  /**
   * Verifies that the actual {@code Date} is <b>strictly</b> after the given one.
   *
   * @param other the given Date.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if other {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not strictly after the given one.
   */
  public DateAssert isAfter(Date other) {
    dates.assertIsAfter(info, actual, other);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if given date as String is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not strictly after the given Date
   *     represented as String.
   * @throws AssertionError if the given date as String could not be converted to a Date.
   */
  public DateAssert isAfter(String dateAsString) {
    return isAfter(parse(dateAsString));
  }

  /**
   * Verifies that the actual {@code Date} is after or equals to the given one.
   *
   * @param other the given Date.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if other {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not after or equals to the given one.
   */
  public DateAssert isAfterOrEqualsTo(Date other) {
    dates.assertIsAfterOrEqualsTo(info, actual, other);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if given date as String is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not after or equals to the given Date
   *     represented as String.
   * @throws AssertionError if the given date as String could not be converted to a Date.
   */
  public DateAssert isAfterOrEqualsTo(String dateAsString) {
    return isAfterOrEqualsTo(parse(dateAsString));
  }

  /**
   * Verifies that the actual {@code Date} is in [start, end[ period (start included, end excluded).
   *
   * @param start the period start (inclusive), expected not to be null.
   * @param end the period end (exclusive), expected not to be null.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if start {@code Date} is {@code null}.
   * @throws NullPointerException if end {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not in [start, end[ period.
   */
  public DateAssert isBetween(Date start, Date end) {
    return isBetween(start, end, true, false);
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param start the period start (inclusive), expected not to be null.
   * @param end the period end (exclusive), expected not to be null.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if start Date as String is {@code null}.
   * @throws NullPointerException if end Date as String is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not in [start, end[ period.
   * @throws AssertionError if one of the given date as String could not be converted to a Date.
   */
  public DateAssert isBetween(String start, String end) {
    return isBetween(parse(start), parse(end));
  }

  /**
   * Verifies that the actual {@code Date} is in the given period defined by start and end dates.
   * <br>
   * To include start in the period set inclusiveStart parameter to <code>true</code>.<br>
   * To include end in the period set inclusiveEnd parameter to <code>true</code>.<br>
   *
   * @param start the period start, expected not to be null.
   * @param end the period end, expected not to be null.
   * @param inclusiveStart wether to include start date in period.
   * @param inclusiveEnd wether to include end date in period.
   * @return this assertion object.
   * @throws AssertionError if {@code actual} is {@code null}.
   * @throws NullPointerException if start {@code Date} is {@code null}.
   * @throws NullPointerException if end {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not in (start, end) period.
   */
  public DateAssert isBetween(Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd) {
    dates.assertIsBetween(info, actual, start, end, inclusiveStart, inclusiveEnd);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link #withDateFormat(DateFormat)}).
   *
   * @param start the period start, expected not to be null.
   * @param end the period end, expected not to be null.
   * @param inclusiveStart wether to include start date in period.
   * @param inclusiveEnd wether to include end date in period.
   * @return this assertion object.
   * @throws AssertionError if {@code actual} is {@code null}.
   * @throws NullPointerException if start Date as String is {@code null}.
   * @throws NullPointerException if end Date as String is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not in (start, end) period.
   * @throws AssertionError if one of the given date as String could not be converted to a Date.
   */
  public DateAssert isBetween(
      String start, String end, boolean inclusiveStart, boolean inclusiveEnd) {
    dates.assertIsBetween(info, actual, parse(start), parse(end), inclusiveStart, inclusiveEnd);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} is not in the given period defined by start and end
   * dates.<br>
   * To include start in the period set inclusiveStart parameter to <code>true</code>.<br>
   * To include end in the period set inclusiveEnd parameter to <code>true</code>.<br>
   *
   * @param start the period start (inclusive), expected not to be null.
   * @param end the period end (exclusive), expected not to be null.
   * @param inclusiveStart wether to include start date in period.
   * @param inclusiveEnd wether to include end date in period.
   * @return this assertion object.
   * @throws AssertionError if {@code actual} is {@code null}.
   * @throws NullPointerException if start {@code Date} is {@code null}.
   * @throws NullPointerException if end {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not in (start, end) period.
   */
  public DateAssert isNotBetween(
      Date start, Date end, boolean inclusiveStart, boolean inclusiveEnd) {
    dates.assertIsNotBetween(info, actual, start, end, inclusiveStart, inclusiveEnd);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link #withDateFormat(DateFormat)}).
   *
   * @param start the period start (inclusive), expected not to be null.
   * @param end the period end (exclusive), expected not to be null.
   * @param inclusiveStart wether to include start date in period.
   * @param inclusiveEnd wether to include end date in period.
   * @return this assertion object.
   * @throws AssertionError if {@code actual} is {@code null}.
   * @throws NullPointerException if start Date as String is {@code null}.
   * @throws NullPointerException if end Date as String is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not in (start, end) period.
   * @throws AssertionError if one of the given date as String could not be converted to a Date.
   */
  public DateAssert isNotBetween(
      String start, String end, boolean inclusiveStart, boolean inclusiveEnd) {
    return isNotBetween(parse(start), parse(end), inclusiveStart, inclusiveEnd);
  }

  /**
   * Verifies that the actual {@code Date} is not in [start, end[ period
   *
   * @param start the period start (inclusive), expected not to be null.
   * @param end the period end (exclusive), expected not to be null.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if start {@code Date} is {@code null}.
   * @throws NullPointerException if end {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is in [start, end[ period.
   * @throws AssertionError if one of the given date as String could not be converted to a Date.
   */
  public DateAssert isNotBetween(Date start, Date end) {
    return isNotBetween(start, end, true, false);
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param start the period start (inclusive), expected not to be null.
   * @param end the period end (exclusive), expected not to be null.
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws NullPointerException if start Date as String is {@code null}.
   * @throws NullPointerException if end Date as String is {@code null}.
   * @throws AssertionError if the actual {@code Date} is in [start, end[ period.
   * @throws AssertionError if one of the given date as String could not be converted to a Date.
   */
  public DateAssert isNotBetween(String start, String end) {
    return isNotBetween(parse(start), parse(end), true, false);
  }

  /**
   * Verifies that the actual {@code Date} is strictly in the past.
   *
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not in the past.
   */
  public DateAssert isInThePast() {
    dates.assertIsInThePast(info, actual);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} is today, that is matching current year, month and day
   * (no check on hour, minute, second, milliseconds).
   *
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not today.
   */
  public DateAssert isToday() {
    dates.assertIsToday(info, actual);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} is strictly in the future.
   *
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} is not in the future.
   */
  public DateAssert isInTheFuture() {
    dates.assertIsInTheFuture(info, actual);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} is <b>strictly</b> before the given year.
   *
   * @param year the year to compare actual year to
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} year is after or equals to the given year.
   */
  public DateAssert isBeforeYear(int year) {
    dates.assertIsBeforeYear(info, actual, year);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} is <b>strictly</b> after the given year.
   *
   * @param year the year to compare actual year to
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} year is before or equals to the given year.
   */
  public DateAssert isAfterYear(int year) {
    dates.assertIsAfterYear(info, actual, year);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} year is equal to the given year.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param year the year to compare actual year to
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} year is not equal to the given year.
   */
  public DateAssert isWithinYear(int year) {
    dates.assertIsWithinYear(info, actual, year);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} month is equal to the given month, <b>month value
   * starting at 1</b> (January=1, February=2, ...).
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param month the month to compare actual month to, <b>month value starting at 1</b> (January=1,
   *     February=2, ...).
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} month is not equal to the given month.
   */
  public DateAssert isWithinMonth(int month) {
    dates.assertIsWithinMonth(info, actual, month);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} day of month is equal to the given day of month.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param dayOfMonth the day of month to compare actual day of month to
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} month is not equal to the given day of month.
   */
  public DateAssert isWithinDayOfMonth(int dayOfMonth) {
    dates.assertIsWithinDayOfMonth(info, actual, dayOfMonth);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} day of week is equal to the given day of week (see {@link
   * Calendar#DAY_OF_WEEK} for valid values).
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param dayOfWeek the day of week to compare actual day of week to, see {@link
   *     Calendar#DAY_OF_WEEK} for valid values
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} week is not equal to the given day of week.
   */
  public DateAssert isWithinDayOfWeek(int dayOfWeek) {
    dates.assertIsWithinDayOfWeek(info, actual, dayOfWeek);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} hour od day is equal to the given hour of day (24-hour
   * clock).
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param hourOfDay the hour of day to compare actual hour of day to (24-hour clock)
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} hour is not equal to the given hour.
   */
  public DateAssert isWithinHourOfDay(int hourOfDay) {
    dates.assertIsWithinHourOfDay(info, actual, hourOfDay);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} minute is equal to the given minute.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param minute the minute to compare actual minute to
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} minute is not equal to the given minute.
   */
  public DateAssert isWithinMinute(int minute) {
    dates.assertIsWithinMinute(info, actual, minute);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} second is equal to the given second.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param second the second to compare actual second to
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} second is not equal to the given second.
   */
  public DateAssert isWithinSecond(int second) {
    dates.assertIsWithinSecond(info, actual, second);
    return this;
  }

  /**
   * Verifies that the actual {@code Date} millisecond is equal to the given millisecond.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param millisecond the millisecond to compare actual millisecond to
   * @return this assertion object.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} millisecond is not equal to the given
   *     millisecond.
   */
  public DateAssert isWithinMillisecond(int millisecond) {
    dates.assertIsWithinMillisecond(info, actual, millisecond);
    return this;
  }

  /**
   * Verifies that actual and given {@code Date} are in the same year.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param other the given {@code Date} to compare actual {@code Date} to.
   * @return this assertion object.
   * @throws NullPointerException if {@code Date} parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same year.
   */
  public DateAssert isInSameYearAs(Date other) {
    dates.assertIsInSameYearAs(info, actual, other);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws NullPointerException if dateAsString parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given Date represented as String are not in the same year.
   * @throws AssertionError if the given date as String could not be converted to a Date.
   */
  public DateAssert isInSameYearAs(String dateAsString) {
    return isInSameYearAs(parse(dateAsString));
  }

  /**
   * Verifies that actual and given {@code Date} are chronologically in the same month (and thus in
   * the same year).
   *
   * <p>If you want to compare month only (without year), use : <code>
   * assertThat(myDate).isWithinMonth(monthOf(otherDate))</code><br>
   * See {@link org.fest.util.Dates#monthOf(Date)} to get the month of a given Date.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param other the given {@code Date} to compare actual {@code Date} to.
   * @return this assertion object.
   * @throws NullPointerException if {@code Date} parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same month.
   */
  public DateAssert isInSameMonthAs(Date other) {
    dates.assertIsInSameMonthAs(info, actual, other);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws NullPointerException if dateAsString parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same month.
   */
  public DateAssert isInSameMonthAs(String dateAsString) {
    return isInSameMonthAs(parse(dateAsString));
  }

  /**
   * Verifies that actual and given {@code Date} are chronologically in the same day of month (and
   * thus in the same month and year).
   *
   * <p>If you want to compare day of month only (without month and year), you could write : <code>
   * assertThat(myDate).isWithinDayOfMonth(dayOfMonthOf(otherDate))</code><br>
   * see {@link org.fest.util.Dates#dayOfMonthOf(Date)} to get the day of month of a given Date.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param other the given {@code Date} to compare actual {@code Date} to.
   * @return this assertion object.
   * @throws NullPointerException if {@code Date} parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same day of month.
   */
  public DateAssert isInSameDayAs(Date other) {
    dates.assertIsInSameDayAs(info, actual, other);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws NullPointerException if dateAsString parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same day of month.
   */
  public DateAssert isInSameDayAs(String dateAsString) {
    return isInSameDayAs(parse(dateAsString));
  }

  /**
   * Verifies that actual and given {@code Date} are chronologically in the same hour (and thus in
   * the same day, month and year).
   *
   * <p>If you want to compare hour only (without day, month and year), you could write : <code>
   * assertThat(myDate).isWithinHour(hourOfDayOf(otherDate))</code><br>
   * see {@link org.fest.util.Dates#hourOfDay(Date)} to get the hour of a given Date.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param other the given {@code Date} to compare actual {@code Date} to.
   * @return this assertion object.
   * @throws NullPointerException if {@code Date} parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same hour.
   */
  public DateAssert isInSameHourAs(Date other) {
    dates.assertIsInSameHourAs(info, actual, other);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws NullPointerException if dateAsString parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same hour.
   */
  public DateAssert isInSameHourAs(String dateAsString) {
    return isInSameHourAs(parse(dateAsString));
  }

  /**
   * Verifies that actual and given {@code Date} are chronologically in the same minute (and thus in
   * the same hour, day, month and year).
   *
   * <p>If you want to compare minute only (without hour, day, month and year), you could write :
   * <code>assertThat(myDate).isWithinMinute(minuteOf(otherDate))</code><br>
   * see {@link org.fest.util.Dates#minuteOf(Date)} to get the minute of a given Date.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param other the given {@code Date} to compare actual {@code Date} to.
   * @return this assertion object.
   * @throws NullPointerException if {@code Date} parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same minute.
   */
  public DateAssert isInSameMinuteAs(Date other) {
    dates.assertIsInSameMinuteAs(info, actual, other);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws NullPointerException if dateAsString parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same minute.
   */
  public DateAssert isInSameMinuteAs(String dateAsString) {
    return isInSameMinuteAs(parse(dateAsString));
  }

  /**
   * Verifies that actual and given {@code Date} are chronologically in the same second (and thus in
   * the same minute, hour, day, month and year).
   *
   * <p>If you want to compare second only (without minute, hour, day, month and year), you could
   * write : <code>assertThat(myDate).isWithinSecond(secondOf(otherDate))</code><br>
   * see {@link org.fest.util.Dates#secondOf(Date)} to get the second of a given Date.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param other the given {@code Date} to compare actual {@code Date} to.
   * @return this assertion object.
   * @throws NullPointerException if {@code Date} parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same second.
   */
  public DateAssert isInSameSecondAs(Date other) {
    dates.assertIsInSameSecondAs(info, actual, other);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @return this assertion object.
   * @throws NullPointerException if dateAsString parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if actual and given {@code Date} are not in the same second.
   */
  public DateAssert isInSameSecondAs(String dateAsString) {
    return isInSameSecondAs(parse(dateAsString));
  }

  /**
   * Verifies that the actual {@code Date} is close to the other date by less than delta (expressed
   * in milliseconds), if difference is equals to delta it's ok.
   *
   * <p>One can use handy {@link TimeUnit} to convert a duration in milliseconds, for example you
   * can express a delta of 5 seconds with <code>TimeUnit.SECONDS.toMillis(5)</code>.
   *
   * <p>Note that using a custom comparator has no effect on this assertion (see {@link
   * #usingComparator(Comparator)}.
   *
   * @param other the date to compare actual to
   * @param deltaInMilliseconds the delta used for date comparison, expressed in milliseconds
   * @return this assertion object.
   * @throws NullPointerException if {@code Date} parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} week is not close to the given date by less
   *     than delta.
   */
  public DateAssert isCloseTo(Date other, long deltaInMilliseconds) {
    dates.assertIsCloseTo(info, actual, other, deltaInMilliseconds);
    return this;
  }

  /**
   * Same assertion as {@link #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 {@link
   * #withDateFormat(DateFormat)}).
   *
   * @param dateAsString the given Date represented as String in default or custom date format.
   * @param deltaInMilliseconds the delta used for date comparison, expressed in milliseconds
   * @return this assertion object.
   * @throws NullPointerException if dateAsString parameter is {@code null}.
   * @throws AssertionError if the actual {@code Date} is {@code null}.
   * @throws AssertionError if the actual {@code Date} week is not close to the given date by less
   *     than delta.
   */
  public DateAssert isCloseTo(String dateAsString, long deltaInMilliseconds) {
    return isCloseTo(parse(dateAsString), deltaInMilliseconds);
  }

  /**
   * For String based Date assertions like {@link #isBefore(String)}, given String is expected to
   * follow the default Date format, that is ISO 8601 format : "yyyy-MM-dd".
   *
   * <p>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.
   *
   * <p>To revert to default format simply call {@link #withIsoDateFormat()}.
   *
   * @param userCustomDateFormat the new Date format used for String based Date assertions.
   * @return this assertion object.
   */
  public DateAssert withDateFormat(DateFormat userCustomDateFormat) {
    useDateFormat(userCustomDateFormat);
    return this;
  }

  /**
   * For String based Date assertions like {@link #isBefore(String)}, given String is expected to
   * follow the default Date format, that is ISO 8601 format : "yyyy-MM-dd".
   *
   * <p>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.
   *
   * <p>To revert to default format simply call {@link #useIsoDateFormat()} (static method) or
   * {@link #withIsoDateFormat()}.
   *
   * @param userCustomDateFormat the new Date format used for String based Date assertions.
   */
  public static void useDateFormat(DateFormat userCustomDateFormat) {
    if (userCustomDateFormat == null)
      throw new NullPointerException("The given date format should not be null");
    dateFormat = userCustomDateFormat;
  }

  /**
   * Use ISO 8601 date format ("yyyy-MM-dd") for String based Date assertions.
   *
   * @return this assertion object.
   */
  public DateAssert withIsoDateFormat() {
    useIsoDateFormat();
    return this;
  }

  /** Use ISO 8601 date format ("yyyy-MM-dd") for String based Date assertions. */
  public static void useIsoDateFormat() {
    dateFormat = ISO_DATE_FORMAT;
  }

  /**
   * Utillity method to parse a Date with {@link #dateFormat}, note that it is thread safe.<br>
   * Returns <code>null</code> if dateAsString parameter is <code>null</code>.
   *
   * @param dateAsString the string to parse as a Date with {@link #dateFormat}
   * @return the corrresponding Date, null if dateAsString parameter is null.
   * @throws AssertionError if the string can't be parsed as a Date
   */
  private static Date parse(String dateAsString) {
    if (dateAsString == null) {
      return null;
    }
    try {
      // synchronized is used because SimpleDateFormat which is not thread safe (sigh).
      synchronized (dateFormat) {
        return dateFormat.parse(dateAsString);
      }
    } catch (ParseException e) {
      throw Failures.instance()
          .failure("Failed to parse " + dateAsString + " with date format " + dateFormat);
    }
  }

  @Override
  public DateAssert usingComparator(Comparator<?> customComparator) {
    super.usingComparator(customComparator);
    this.dates = new Dates(new ComparatorBasedComparisonStrategy(customComparator));
    return myself;
  }

  @Override
  public DateAssert usingDefaultComparator() {
    super.usingDefaultComparator();
    this.dates = Dates.instance();
    return myself;
  }
}
コード例 #14
0
 /**
  * Verifies that the actual {@code Date} minute is equal to the given minute.
  *
  * <p>Note that using a custom comparator has no effect on this assertion (see {@link
  * #usingComparator(Comparator)}.
  *
  * @param minute the minute to compare actual minute to
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} minute is not equal to the given minute.
  */
 public DateAssert isWithinMinute(int minute) {
   dates.assertIsWithinMinute(info, actual, minute);
   return this;
 }
コード例 #15
0
 /**
  * Verifies that the actual {@code Date} is <b>strictly</b> before the given year.
  *
  * @param year the year to compare actual year to
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} year is after or equals to the given year.
  */
 public DateAssert isBeforeYear(int year) {
   dates.assertIsBeforeYear(info, actual, year);
   return this;
 }
コード例 #16
0
 /**
  * Verifies that the actual {@code Date} second is equal to the given second.
  *
  * <p>Note that using a custom comparator has no effect on this assertion (see {@link
  * #usingComparator(Comparator)}.
  *
  * @param second the second to compare actual second to
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} second is not equal to the given second.
  */
 public DateAssert isWithinSecond(int second) {
   dates.assertIsWithinSecond(info, actual, second);
   return this;
 }
コード例 #17
0
 /**
  * Verifies that the actual {@code Date} is <b>strictly</b> after the given year.
  *
  * @param year the year to compare actual year to
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} year is before or equals to the given year.
  */
 public DateAssert isAfterYear(int year) {
   dates.assertIsAfterYear(info, actual, year);
   return this;
 }
コード例 #18
0
 /**
  * Verifies that actual and given {@code Date} are chronologically in the same second (and thus in
  * the same minute, hour, day, month and year).
  *
  * <p>If you want to compare second only (without minute, hour, day, month and year), you could
  * write : <code>assertThat(myDate).isWithinSecond(secondOf(otherDate))</code><br>
  * see {@link org.fest.util.Dates#secondOf(Date)} to get the second of a given Date.
  *
  * <p>Note that using a custom comparator has no effect on this assertion (see {@link
  * #usingComparator(Comparator)}.
  *
  * @param other the given {@code Date} to compare actual {@code Date} to.
  * @return this assertion object.
  * @throws NullPointerException if {@code Date} parameter is {@code null}.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if actual and given {@code Date} are not in the same second.
  */
 public DateAssert isInSameSecondAs(Date other) {
   dates.assertIsInSameSecondAs(info, actual, other);
   return this;
 }
コード例 #19
0
 /**
  * Verifies that the actual {@code Date} year is equal to the given year.
  *
  * <p>Note that using a custom comparator has no effect on this assertion (see {@link
  * #usingComparator(Comparator)}.
  *
  * @param year the year to compare actual year to
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} year is not equal to the given year.
  */
 public DateAssert isWithinYear(int year) {
   dates.assertIsWithinYear(info, actual, year);
   return this;
 }
コード例 #20
0
 @Override
 public DateAssert usingDefaultComparator() {
   super.usingDefaultComparator();
   this.dates = Dates.instance();
   return myself;
 }
コード例 #21
0
 /**
  * Verifies that the actual {@code Date} is <b>strictly</b> before the given one.
  *
  * @param other the given Date.
  * @return this assertion object.
  * @throws AssertionError if the actual {@code Date} is {@code null}.
  * @throws NullPointerException if other {@code Date} is {@code null}.
  * @throws AssertionError if the actual {@code Date} is not strictly before the given one.
  */
 public DateAssert isBefore(Date other) {
   dates.assertIsBefore(info, actual, other);
   return this;
 }