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
package org.exparity.hamcrest.date;
import static java.time.DayOfWeek.*;
import static java.time.Month.*;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
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.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.format.DatePartFormatter;
import org.exparity.hamcrest.date.core.format.LocalDateFormatter;
import org.exparity.hamcrest.date.core.wrapper.LocalDateWrapper;
import org.hamcrest.Factory;
import org.hamcrest.Matcher;
/**
* 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 Matcher after(final LocalDate date) {
return new IsAfter(new LocalDateWrapper(date), new LocalDateFormatter());
}
/**
* 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 Matcher 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 Matcher before(final LocalDate date) {
return new IsBefore(new LocalDateWrapper(date), new LocalDateFormatter());
}
/**
* 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 Matcher 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 Matcher sameDay(final LocalDate date) {
return new IsSameDay(new LocalDateWrapper(date), new LocalDateFormatter());
}
/**
* 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 Matcher 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 Matcher sameOrBefore(final LocalDate date) {
return new IsSameOrBefore(new LocalDateWrapper(date), new LocalDateFormatter());
}
/**
* 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
*/
@Factory
public static Matcher 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 Matcher sameOrAfter(final LocalDate date) {
return new IsSameOrAfter(new LocalDateWrapper(date), new LocalDateFormatter());
}
/**
* 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 Matcher 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 Matcher 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 Matcher sameDayOfMonth(final LocalDate date) {
return isDayOfMonth(date.getDayOfMonth());
}
/**
* Creates a matcher that matches when the examined date is on the expected day of the month
*
* For example:
*
*
* assertThat(myDate, isDayOfMonth(4))
*
*
* @param date the expected day of the month
*/
public static Matcher isDayOfMonth(final int dayOfMonth) {
return new IsDayOfMonth(dayOfMonth, t -> t);
}
/**
* 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 Matcher sameYear(final LocalDate date) {
return isYear(date.getYear());
}
/**
* 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 Matcher isYear(final int year) {
return new IsYear(year, t -> t);
}
/**
* 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 Matcher within(final long period, final ChronoUnit unit, final LocalDate date) {
return new IsWithin(period, unit, new LocalDateWrapper(date), new LocalDateFormatter());
}
/**
* 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 Matcher 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 Matcher 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 Matcher isToday() {
return sameDay(LocalDate.now());
}
/**
* Creates a matcher that matches when the examined date is tomorrow
*
* For example:
*
*
* assertThat(myDate, isTomorrow());
*
*/
public static Matcher 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 Matcher 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 Matcher isDayOfWeek(final DayOfWeek... dayOfWeek) {
return new IsDayOfWeek(Arrays.asList(dayOfWeek), t -> t);
}
/**
* Creates a matcher that matches when the examined date is on a monday
*
* For example:
*
*
* assertThat(myDate, isMonday());
*
*/
public static Matcher isMonday() {
return isDayOfWeek(MONDAY);
}
/**
* Creates a matcher that matches when the examined date is on a tuesday
*
* For example:
*
*
* assertThat(myDate, isTuesday());
*
*/
public static Matcher isTuesday() {
return isDayOfWeek(TUESDAY);
}
/**
* Creates a matcher that matches when the examined date is on a wednesday
*
* For example:
*
*
* assertThat(myDate, isWednesday());
*
*/
public static Matcher isWednesday() {
return isDayOfWeek(WEDNESDAY);
}
/**
* Creates a matcher that matches when the examined date is on a thursday
*
* For example:
*
*
* assertThat(myDate, isThursday());
*
*/
public static Matcher isThursday() {
return isDayOfWeek(THURSDAY);
}
/**
* Creates a matcher that matches when the examined date is on a friday
*
* For example:
*
*
* assertThat(myDate, isFriday());
*
*/
public static Matcher isFriday() {
return isDayOfWeek(FRIDAY);
}
/**
* Creates a matcher that matches when the examined date is on a saturday
*
* For example:
*
*
* assertThat(myDate, isSaturday());
*
*/
public static Matcher isSaturday() {
return isDayOfWeek(SATURDAY);
}
/**
* Creates a matcher that matches when the examined date is on a sunday
*
* For example:
*
*
* assertThat(myDate, isSunday());
*
*/
public static Matcher isSunday() {
return isDayOfWeek(SUNDAY);
}
/**
* Creates a matcher that matches when the examined date is on a weekday
*
* For example:
*
*
* assertThat(myDate, isWeekday());
*
*/
public static Matcher 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 Matcher 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 Matcher isFirstDayOfMonth() {
return new IsMinimum(ChronoField.DAY_OF_MONTH, t -> t,
new DatePartFormatter(),
() -> "the date is the first day of the month");
}
/**
* 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 Matcher isMinimum(final ChronoField field) {
return new IsMinimum(field, t -> t, new DatePartFormatter());
}
/**
* Creates a matcher that matches when the examined date is on the first day of the month
*
* For example:
*
*
* assertThat(myDate, isFirstDayOfMonth());
*
*/
public static Matcher isLastDayOfMonth() {
return new IsMaximum(ChronoField.DAY_OF_MONTH, t -> t,
new DatePartFormatter(),
() -> "the date is the last day of the month");
}
/**
* 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 Matcher isMaximum(final ChronoField field) {
return new IsMaximum(field, t -> t, new DatePartFormatter());
}
/**
* Creates a matcher that matches when the examined date is in the expected month
*
* For example:
*
*
* assertThat(myDate, isMonth(Month.AUGUST));
*
*/
public static Matcher isMonth(final Month month) {
return new IsMonth(month, t -> t);
}
/**
* Creates a matcher that matches when the examined date is in January
*
* For example:
*
*
* assertThat(myDate, isJanuary());
*
*/
public static Matcher isJanuary() {
return isMonth(JANUARY);
}
/**
* Creates a matcher that matches when the examined date is in February
*
* For example:
*
*
* assertThat(myDate, isFebruary());
*
*/
public static Matcher isFebruary() {
return isMonth(FEBRUARY);
}
/**
* Creates a matcher that matches when the examined date is in March
*
* For example:
*
*
* assertThat(myDate, isMarch());
*
*/
public static Matcher isMarch() {
return isMonth(MARCH);
}
/**
* Creates a matcher that matches when the examined date is in April
*
* For example:
*
*
* assertThat(myDate, isApril());
*
*/
public static Matcher isApril() {
return isMonth(APRIL);
}
/**
* Creates a matcher that matches when the examined date is in May
*
* For example:
*
*
* assertThat(myDate, isMay());
*
*/
public static Matcher isMay() {
return isMonth(MAY);
}
/**
* Creates a matcher that matches when the examined date is in June
*
* For example:
*
*
* assertThat(myDate, isJune());
*
*/
public static Matcher isJune() {
return isMonth(JUNE);
}
/**
* Creates a matcher that matches when the examined date is in July
*
* For example:
*
*
* assertThat(myDate, isJuly());
*
*/
public static Matcher isJuly() {
return isMonth(JULY);
}
/**
* Creates a matcher that matches when the examined date is in August
*
* For example:
*
*
* assertThat(myDate, isAugust());
*
*/
public static Matcher isAugust() {
return isMonth(AUGUST);
}
/**
* Creates a matcher that matches when the examined date is in September
*
* For example:
*
*
* assertThat(myDate, isSeptember());
*
*/
public static Matcher isSeptember() {
return isMonth(SEPTEMBER);
}
/**
* Creates a matcher that matches when the examined date is in October
*
* For example:
*
*
* assertThat(myDate, isOctober());
*
*/
public static Matcher isOctober() {
return isMonth(OCTOBER);
}
/**
* Creates a matcher that matches when the examined date is in November
*
* For example:
*
*
* assertThat(myDate, isNovember());
*
*/
public static Matcher isNovember() {
return isMonth(NOVEMBER);
}
/**
* Creates a matcher that matches when the examined date is in December
*
* For example:
*
*
* assertThat(myDate, isDecember());
*
*/
public static Matcher isDecember() {
return isMonth(DECEMBER);
}
/**
* Creates a matcher that matches when the examined date is a leap year
*
* For example:
*
*
* assertThat(myDate, isLeapYear());
*
*/
public static Matcher isLeapYear() {
return new IsLeapYear(t -> t, new LocalDateFormatter());
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy