org.exparity.hamcrest.date.LocalDateMatchers Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of hamcrest-date Show documentation
Show all versions of hamcrest-date Show documentation
Hamcrest Date matchers for Java
The newest version!
package org.exparity.hamcrest.date;
import static java.time.DayOfWeek.*;
import static java.time.Month.*;
import static org.exparity.hamcrest.date.core.TemporalConverters.*;
import static org.exparity.hamcrest.date.core.TemporalFunctions.LOCALDATE;
import static org.exparity.hamcrest.date.core.TemporalProviders.*;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.Period;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import org.exparity.hamcrest.date.core.TemporalMatcher;
import org.exparity.hamcrest.date.core.IsAfter;
import org.exparity.hamcrest.date.core.IsBefore;
import org.exparity.hamcrest.date.core.IsDayOfMonth;
import org.exparity.hamcrest.date.core.IsDayOfWeek;
import org.exparity.hamcrest.date.core.IsFirstDayOfMonth;
import org.exparity.hamcrest.date.core.IsLastDayOfMonth;
import org.exparity.hamcrest.date.core.IsLeapYear;
import org.exparity.hamcrest.date.core.IsMaximum;
import org.exparity.hamcrest.date.core.IsMinimum;
import org.exparity.hamcrest.date.core.IsMonth;
import org.exparity.hamcrest.date.core.IsSameDay;
import org.exparity.hamcrest.date.core.IsSameOrAfter;
import org.exparity.hamcrest.date.core.IsSameOrBefore;
import org.exparity.hamcrest.date.core.IsWithin;
import org.exparity.hamcrest.date.core.IsYear;
import org.exparity.hamcrest.date.core.TemporalConverters;
import org.exparity.hamcrest.date.core.TemporalProviders;
import org.exparity.hamcrest.date.core.types.Interval;
/**
* Static factory for creating {@link org.hamcrest.Matcher} instances for comparing {@link LocalDate} instances
*
* @author Stewart Bissett
*/
public abstract class LocalDateMatchers {
/**
* Creates a matcher that matches when the examined date is after the reference date
*
* For example:
*
*
* MatcherAssert.assertThat(myDate, LocalDateMatchers.after(LocalDate.now()));
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher after(final LocalDate date) {
return new IsAfter<>(LOCALDATE_AS_LOCALDATE, localDate(date), LOCALDATE);
}
/**
* Creates a matcher that matches when the examined date is after the end of the reference year
*
* For example:
*
*
* MatcherAssert.assertThat(myDate, LocalDateMatchers.after(2012, Month.MAY, 12));
*
*
* @param year the year against which the examined date is checked
* @param month the month against which the examined date is checked
* @param dayOfMonth the day of the month against which the examined date is checked
*/
public static TemporalMatcher after(final int year, final Month month, final int dayOfMonth) {
return after(LocalDate.of(year, month, dayOfMonth));
}
/**
* Creates a matcher that matches when the examined date is before the reference date
*
* For example:
*
*
* MatcherAssert.assertThat(myDate, LocalDateMatchers.before(LocalDate.now()));
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher before(final LocalDate date) {
return new IsBefore<>(LOCALDATE_AS_LOCALDATE, localDate(date), LOCALDATE);
}
/**
* Creates a matcher that matches when the examined date is before the end of the reference year
*
* For example:
*
*
* MatcherAssert.assertThat(myDate, LocalDateMatchers.before(2012, Month.MAY, 12));
*
*
* @param year the year against which the examined date is checked
* @param month the month against which the examined date is checked
* @param dayOfMonth the day of the month against which the examined date is checked
*/
public static TemporalMatcher before(final int year, final Month month, final int dayOfMonth) {
return before(LocalDate.of(year, month, dayOfMonth));
}
/**
* Creates a matcher that matches when the examined date is on the same day of the year as the reference date
*
* For example:
*
*
* assertThat(myDate, sameDay(LocalDate.now()));
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher sameDay(final LocalDate date) {
return new IsSameDay<>(LOCALDATE_AS_LOCALDATE, localDate(date));
}
/**
* Creates a matcher that matches when the examined date is on the same day of the year as the reference date
*
* For example:
*
*
* assertThat(myDate, isDay(2012, Month.JAN, 1))
*
*
* @param dayOfMonth the reference day of the month against which the examined date is checked
* @param month the reference month against which the examined date is checked
* @param year the reference year against which the examined date is checked
*/
public static TemporalMatcher isDay(final int year, final Month month, final int dayOfMonth) {
return sameDay(LocalDate.of(year, month, dayOfMonth));
}
/**
* Creates a matcher that matches when the examined date is at the same instant or before the reference date
*
* For example:
*
*
* assertThat(myDate, isSameOrBefore(new Date()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher sameOrBefore(final LocalDate date) {
return new IsSameOrBefore<>(LOCALDATE_AS_LOCALDATE, localDate(date), LOCALDATE);
}
/**
* Creates a matcher that matches when the examined date is on the same day or before the start of the reference
* date
*
* For example:
*
*
* assertThat(myDate, isSameOrBefore(2012, Months.MAY, 12));
*
*
* @param year the year against which the examined date is checked
* @param month the month against which the examined date is checked
* @param day the day of the month against which the examined date is checked
*/
public static TemporalMatcher sameOrBefore(final int year, final Month month, final int day) {
return sameOrBefore(LocalDate.of(year, month, day));
}
/**
* Creates a matcher that matches when the examined date is at the same instant or after the reference date
*
* For example:
*
*
* assertThat(myDate, isSameOrAfter(new Date()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher sameOrAfter(final LocalDate date) {
return new IsSameOrAfter<>(LOCALDATE_AS_LOCALDATE, localDate(date), LOCALDATE);
}
/**
* Creates a matcher that matches when the examined date is on the same day or after the start of the reference date
*
* For example:
*
*
* assertThat(myDate, isSameOrAfter(2012, Months.MAY, 12));
*
*
* @param year the year against which the examined date is checked
* @param month the month against which the examined date is checked
* @param day the day of the month against which the examined date is checked
*/
public static TemporalMatcher sameOrAfter(final int year, final Month month, final int day) {
return sameOrAfter(LocalDate.of(year, month, day));
}
/**
* Creates a matcher that matches when the examined date is on the same month as the reference date
*
* For example:
*
*
* assertThat(myDate, sameMonth(new Date()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher sameMonthOfYear(final LocalDate date) {
return isMonth(date.getMonth());
}
/**
* Creates a matcher that matches when the examined date is on the same day of the month as the reference date
*
* For example:
*
*
* assertThat(myDate, sameDayOfMonth(new Date()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher sameDayOfMonth(final LocalDate date) {
return new IsDayOfMonth<>(LOCALDATE_AS_DAYOFMONTH, dayOfMonth(date));
}
/**
* Creates a matcher that matches when the examined date is on the expected day of the month
*
* For example:
*
*
* assertThat(myDate, isDayOfMonth(4))
*
*
* @param dayOfMonth the expected day of the month
*/
public static TemporalMatcher isDayOfMonth(final int dayOfMonth) {
return new IsDayOfMonth<>(LOCALDATE_AS_DAYOFMONTH, dayOfMonth(dayOfMonth));
}
/**
* Creates a matcher that matches when the examined date is on the same year as the reference date
*
* For example:
*
*
* assertThat(myDate, sameYear(new Date()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher sameYear(final LocalDate date) {
return new IsYear<>(LOCALDATE_AS_YEAR, year(date));
}
/**
* Creates a matcher that matches when the examined date is on the same year as the reference year
*
* For example:
*
*
* assertThat(myDate, sameYear(2013))
*
*
* @param year the reference year against which the examined date is checked
*/
public static TemporalMatcher isYear(final int year) {
return new IsYear<>(TemporalConverters.LOCALDATE_AS_YEAR, TemporalProviders.year(year));
}
/**
* Creates a matcher that matches when the examined date is within a defined period the reference date
*
* For example:
*
*
* assertThat(myDate, within(10, TimeUnit.DAYS, Moments.today()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher within(final Period period , final LocalDate date) {
return new IsWithin<>(Interval.of(period), LOCALDATE_AS_LOCALDATE, localDate(date), LOCALDATE);
}
/**
* Creates a matcher that matches when the examined date is within a defined period the reference date
*
* For example:
*
*
* assertThat(myDate, within(10, TimeUnit.DAYS, Moments.today()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher within(final long period, final ChronoUnit unit, final LocalDate date) {
return new IsWithin<>(Interval.of(period, unit), LOCALDATE_AS_LOCALDATE, localDate(date), LOCALDATE);
}
/**
* Creates a matcher that matches when the examined date is within a given period of the reference date
*
* For example:
*
*
* assertThat(myDate, within(5, TimeUnit.DAYS, 2012, Months.MAY, 12));
*
*
* @param period the timeunit interval the examined date should be with
* @param unit the timeunit to define the length of the period
* @param year the year against which the examined date is checked
* @param month the month against which the examined date is checked
* @param dayofMonth the day of the month against which the examined date is checked
*/
public static TemporalMatcher within(final long period,
final ChronoUnit unit,
final int year,
final Month month,
final int dayofMonth) {
return within(period, unit, LocalDate.of(year, month, dayofMonth));
}
/**
* Creates a matcher that matches when the examined date is yesterday
*
* For example:
*
*
* assertThat(myDate, isToday());
*
*/
public static TemporalMatcher isYesterday() {
return sameDay(LocalDate.now().plusDays(-1));
}
/**
* Creates a matcher that matches when the examined date is today
*
* For example:
*
*
* assertThat(myDate, isToday());
*
*/
public static TemporalMatcher isToday() {
return sameDay(LocalDate.now());
}
/**
* Creates a matcher that matches when the examined date is tomorrow
*
* For example:
*
*
* assertThat(myDate, isTomorrow());
*
*/
public static TemporalMatcher isTomorrow() {
return sameDay(LocalDate.now().plusDays(1));
}
/**
* Creates a matcher that matches when the examined date is on the same day of the week as the reference date
*
* For example:
*
*
* assertThat(myDate, sameDayOfWeek(LocalDate.now()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static TemporalMatcher sameDayOfWeek(final LocalDate date) {
return isDayOfWeek(DayOfWeek.from(date));
}
/**
* Creates a matcher that matches when the examined date is on a monday
*
* For example:
*
*
* assertThat(myDate, isMonday());
*
*/
public static TemporalMatcher isDayOfWeek(final DayOfWeek dayOfWeek) {
return new IsDayOfWeek<>(LOCALDATE_AS_DAYOFWEEK, daysOfWeek(dayOfWeek));
}
/**
* Creates a matcher that matches when the examined date is on a monday
*
* For example:
*
*
* assertThat(myDate, isMonday());
*
*/
public static TemporalMatcher isDayOfWeek(final DayOfWeek... daysOfWeek) {
return new IsDayOfWeek<>(LOCALDATE_AS_DAYOFWEEK, daysOfWeek(daysOfWeek));
}
/**
* Creates a matcher that matches when the examined date is on a monday
*
* For example:
*
*
* assertThat(myDate, isMonday());
*
*/
public static TemporalMatcher isMonday() {
return isDayOfWeek(MONDAY);
}
/**
* Creates a matcher that matches when the examined date is on a tuesday
*
* For example:
*
*
* assertThat(myDate, isTuesday());
*
*/
public static TemporalMatcher isTuesday() {
return isDayOfWeek(TUESDAY);
}
/**
* Creates a matcher that matches when the examined date is on a wednesday
*
* For example:
*
*
* assertThat(myDate, isWednesday());
*
*/
public static TemporalMatcher isWednesday() {
return isDayOfWeek(WEDNESDAY);
}
/**
* Creates a matcher that matches when the examined date is on a thursday
*
* For example:
*
*
* assertThat(myDate, isThursday());
*
*/
public static TemporalMatcher isThursday() {
return isDayOfWeek(THURSDAY);
}
/**
* Creates a matcher that matches when the examined date is on a friday
*
* For example:
*
*
* assertThat(myDate, isFriday());
*
*/
public static TemporalMatcher isFriday() {
return isDayOfWeek(FRIDAY);
}
/**
* Creates a matcher that matches when the examined date is on a saturday
*
* For example:
*
*
* assertThat(myDate, isSaturday());
*
*/
public static TemporalMatcher isSaturday() {
return isDayOfWeek(SATURDAY);
}
/**
* Creates a matcher that matches when the examined date is on a sunday
*
* For example:
*
*
* assertThat(myDate, isSunday());
*
*/
public static TemporalMatcher isSunday() {
return isDayOfWeek(SUNDAY);
}
/**
* Creates a matcher that matches when the examined date is on a weekday
*
* For example:
*
*
* assertThat(myDate, isWeekday());
*
*/
public static TemporalMatcher isWeekday() {
return isDayOfWeek(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY);
}
/**
* Creates a matcher that matches when the examined date is on a weekend
*
* For example:
*
*
* assertThat(myDate, isWeekend());
*
*/
public static TemporalMatcher isWeekend() {
return isDayOfWeek(SATURDAY, SUNDAY);
}
/**
* Creates a matcher that matches when the examined date is on the first day of the month
*
* For example:
*
*
* assertThat(myDate, isFirstDayOfMonth());
*
*/
public static TemporalMatcher isFirstDayOfMonth() {
return new IsFirstDayOfMonth<>(LOCALDATE_AS_LOCALDATE);
}
/**
* Creates a matcher that matches when the examined date is on the maximum value of the given date part in its
* period
*
* For example:
*
*
* assertThat(myDate, isMaximumDayOfMonth(ChronoField.DAY_OF_MONTH));
*
*
* @param field the temporal field to check
*/
public static TemporalMatcher isMinimum(final ChronoField field) {
return new IsMinimum<>(LOCALDATE_AS_LOCALDATE, field);
}
/**
* Creates a matcher that matches when the examined date is on the first day of the month
*
* For example:
*
*
* assertThat(myDate, isFirstDayOfMonth());
*
*/
public static TemporalMatcher isLastDayOfMonth() {
return new IsLastDayOfMonth<>(LOCALDATE_AS_LOCALDATE);
}
/**
* Creates a matcher that matches when the examined date is on the maximum value of the given date part in its
* period
*
* For example:
*
*
* assertThat(myDate, isMaximum(ChronoField.DAY_OF_MONTH));
*
*
* @param field the temporal field to check
*/
public static TemporalMatcher isMaximum(final ChronoField field) {
return new IsMaximum<>(LOCALDATE_AS_LOCALDATE, field);
}
/**
* Creates a matcher that matches when the examined date is in the expected month
*
* For example:
*
*
* assertThat(myDate, isMonth(Month.AUGUST));
*
*/
public static TemporalMatcher isMonth(final Month month) {
return new IsMonth<>(LOCALDATE_AS_MONTH, month(month));
}
/**
* Creates a matcher that matches when the examined date is in January
*
* For example:
*
*
* assertThat(myDate, isJanuary());
*
*/
public static TemporalMatcher isJanuary() {
return isMonth(JANUARY);
}
/**
* Creates a matcher that matches when the examined date is in February
*
* For example:
*
*
* assertThat(myDate, isFebruary());
*
*/
public static TemporalMatcher isFebruary() {
return isMonth(FEBRUARY);
}
/**
* Creates a matcher that matches when the examined date is in March
*
* For example:
*
*
* assertThat(myDate, isMarch());
*
*/
public static TemporalMatcher isMarch() {
return isMonth(MARCH);
}
/**
* Creates a matcher that matches when the examined date is in April
*
* For example:
*
*
* assertThat(myDate, isApril());
*
*/
public static TemporalMatcher isApril() {
return isMonth(APRIL);
}
/**
* Creates a matcher that matches when the examined date is in May
*
* For example:
*
*
* assertThat(myDate, isMay());
*
*/
public static TemporalMatcher isMay() {
return isMonth(MAY);
}
/**
* Creates a matcher that matches when the examined date is in June
*
* For example:
*
*
* assertThat(myDate, isJune());
*
*/
public static TemporalMatcher isJune() {
return isMonth(JUNE);
}
/**
* Creates a matcher that matches when the examined date is in July
*
* For example:
*
*
* assertThat(myDate, isJuly());
*
*/
public static TemporalMatcher isJuly() {
return isMonth(JULY);
}
/**
* Creates a matcher that matches when the examined date is in August
*
* For example:
*
*
* assertThat(myDate, isAugust());
*
*/
public static TemporalMatcher isAugust() {
return isMonth(AUGUST);
}
/**
* Creates a matcher that matches when the examined date is in September
*
* For example:
*
*
* assertThat(myDate, isSeptember());
*
*/
public static TemporalMatcher isSeptember() {
return isMonth(SEPTEMBER);
}
/**
* Creates a matcher that matches when the examined date is in October
*
* For example:
*
*
* assertThat(myDate, isOctober());
*
*/
public static TemporalMatcher isOctober() {
return isMonth(OCTOBER);
}
/**
* Creates a matcher that matches when the examined date is in November
*
* For example:
*
*
* assertThat(myDate, isNovember());
*
*/
public static TemporalMatcher isNovember() {
return isMonth(NOVEMBER);
}
/**
* Creates a matcher that matches when the examined date is in December
*
* For example:
*
*
* assertThat(myDate, isDecember());
*
*/
public static TemporalMatcher isDecember() {
return isMonth(DECEMBER);
}
/**
* Creates a matcher that matches when the examined date is a leap year
*
* For example:
*
*
* assertThat(myDate, isLeapYear());
*
*/
public static TemporalMatcher isLeapYear() {
return new IsLeapYear<>(LOCALDATE_AS_YEAR);
}
}