org.exparity.hamcrest.date.ZonedDateTimeMatchers 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 static java.util.Arrays.asList;
import java.time.DayOfWeek;
import java.time.Month;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
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.IsHour;
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.IsMinute;
import org.exparity.hamcrest.date.core.IsMonth;
import org.exparity.hamcrest.date.core.IsSame;
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.IsSecond;
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.ZonedDateTimeFormatter;
import org.exparity.hamcrest.date.core.wrapper.ZonedDateTimeWrapper;
import org.hamcrest.Factory;
import org.hamcrest.Matcher;
/**
* Static factory for creating {@link org.hamcrest.Matcher} instances for comparing {@link ZonedDateTime} instances
*
* @author Stewart Bissett
*/
public abstract class ZonedDateTimeMatchers {
/**
* Creates a matcher that matches when the examined date is after the reference date
*
* For example:
*
*
* MatcherAssert.assertThat(myDate, after(ZonedDateTime.now()));
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher after(final ZonedDateTime date) {
return new IsAfter(new ZonedDateTimeWrapper(date), new ZonedDateTimeFormatter());
}
/**
* Creates a matcher that matches when the examined date is after the end of the reference year
*
* For example:
*
*
* MatcherAssert.assertThat(myDate, 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
* @param hour the hour of the day
* @param minute the minute of the hour
* @param second the second of the minute
* @param nanos the nanos of the second
*/
public static Matcher after(final int year,
final Month month,
final int dayOfMonth,
final int hour,
final int minute,
final int second,
final int nanos,
final ZoneId tz) {
return new IsAfter(
new ZonedDateTimeWrapper(year, month, dayOfMonth, hour, minute, second, nanos, tz),
new ZonedDateTimeFormatter());
}
/**
* Creates a matcher that matches when the examined date is before the reference date
*
* For example:
*
*
* MatcherAssert.assertThat(myDate, ZonedDateTimeMatchers.before(ZonedDateTime.now()));
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher before(final ZonedDateTime date) {
return new IsBefore(new ZonedDateTimeWrapper(date), new ZonedDateTimeFormatter());
}
/**
* Creates a matcher that matches when the examined date is before the end of the reference year
*
* For example:
*
*
* MatcherAssert.assertThat(myDate, ZonedDateTimeMatchers.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
* @param hour the hour of the day
* @param minute the minute of the hour
* @param second the second of the minute
* @param nanos the nanoseconds of the second
*/
public static Matcher before(final int year,
final Month month,
final int dayOfMonth,
final int hour,
final int minute,
final int second,
final int nanos,
final ZoneId tz) {
return new IsBefore(new ZonedDateTimeWrapper(year, month, dayOfMonth, hour, minute, second, tz),
new ZonedDateTimeFormatter());
}
/**
* 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(ZonedDateTime.now()));
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameDay(final ZonedDateTime date) {
return new IsSameDay(new ZonedDateTimeWrapper(date), new ZonedDateTimeFormatter());
}
/**
* 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(2012, Month.JAN, 1, ZoneId.systemDefault()))
*
*
* @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
* @param tz the reference time zone
*/
public static Matcher isDay(final int year,
final Month month,
final int dayOfMonth,
final ZoneId tz) {
return new IsSameDay(new ZonedDateTimeWrapper(year, month, dayOfMonth, tz),
new ZonedDateTimeFormatter());
}
/**
* Creates a matcher that matches when the examined date is at the same instant as the reference date
*
* For example:
*
*
* assertThat(myDate, sameInstant(ZonedDateTime.now()));
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameInstant(final ZonedDateTime date) {
return new IsSame(new ZonedDateTimeWrapper(date), new ZonedDateTimeFormatter());
}
/**
* Creates a matcher that matches when the examined date is at the same specified instance down to the second
*
* For example:
*
*
* assertThat(myDate, sameInstant(2012, Month.JAN, 1, 3, 15, 0))
*
*
* @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
* @param hour the hour of the day
* @param minute the minute of the hour
* @param second the second of the minute
* @param nanos the nanosecond of the second
* @param tz the timezone
*/
public static Matcher isInstant(final int year,
final Month month,
final int dayOfMonth,
final int hour,
final int minute,
final int second,
final int nanos,
final ZoneId tz) {
return new IsSame(
new ZonedDateTimeWrapper(year, month, dayOfMonth, hour, minute, second, nanos, tz),
new ZonedDateTimeFormatter());
}
/**
* Creates a matcher that matches when the examined date is at the same instant or before the reference date
*
* For example:
*
*
* assertThat(myDate, sameOrBefore(ZonedDateTime.now()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameOrBefore(final ZonedDateTime date) {
return new IsSameOrBefore(new ZonedDateTimeWrapper(date), new ZonedDateTimeFormatter());
}
/**
* 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, sameOrBefore(2012, Months.MAY, 12, 11, 59, 59, ZoneId.systemDefault()));
*
*
* @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
* @param hour the hour of the day
* @param minute the minute of the hour
* @param second the second of the minute
* @param nanos the nanosecond of the second
* @param tz the time zone of the date to check against
*/
@Factory
public static Matcher sameOrBefore(final int year,
final Month month,
final int day,
final int hour,
final int minute,
final int second,
final int nanos,
final ZoneId tz) {
return new IsSameOrBefore(
new ZonedDateTimeWrapper(year, month, day, hour, minute, second, nanos, tz),
new ZonedDateTimeFormatter());
}
/**
* Creates a matcher that matches when the examined date is at the same instant or after the reference date
*
* For example:
*
*
* assertThat(myDate, sameOrAfter(ZonedDateTime.now()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameOrAfter(final ZonedDateTime date) {
return new IsSameOrAfter(new ZonedDateTimeWrapper(date), new ZonedDateTimeFormatter());
}
/**
* 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, sameOrAfter(2012, Months.MAY, 12, 11, 59, 59, ZoneId.systemDefault()));
*
*
* @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
* @param hour the hour of the day
* @param minute the minute of the hour
* @param second the second of the minute
* @param nanos the nanosecond of the second
* @param tz the time zone of the date to check against
*/
@Factory
public static Matcher sameOrAfter(final int year,
final Month month,
final int day,
final int hour,
final int minute,
final int second,
final int nanos,
final ZoneId tz) {
return new IsSameOrAfter(
new ZonedDateTimeWrapper(year, month, day, hour, minute, second, nanos, tz),
new ZonedDateTimeFormatter());
}
/**
* Creates a matcher that matches when the examined date is on the same month as the reference date
*
* For example:
*
*
* assertThat(myDate, sameMonth(ZonedDateTime.now()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameMonthOfYear(final ZonedDateTime 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(ZonedDateTime.now()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameDayOfMonth(final ZonedDateTime 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(ZonedDateTime.now()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameYear(final ZonedDateTime 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 ZonedDateTime date) {
return new IsWithin(period, unit, new ZonedDateTimeWrapper(date), new ZonedDateTimeFormatter());
}
/**
* 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
* @param hour
* @param hour the hour of the day
* @param minute the minute of the hour
* @param second the second of the minute
* @param hour the hour of the day
* @param minute the minute of the hour
* @param second the second of the minute
* @param nanos the nanonseconds of the second
* @param tz the time zone of the reference date
*/
public static Matcher within(final long period,
final ChronoUnit unit,
final int year,
final Month month,
final int dayofMonth,
final int hour,
final int minute,
final int second,
final int nanos,
final ZoneId tz) {
return new IsWithin(period,
unit,
new ZonedDateTimeWrapper(year, month, dayofMonth, hour, minute, second, nanos, tz),
new ZonedDateTimeFormatter());
}
/**
* Creates a matcher that matches when the examined date is yesterday
*
* For example:
*
*
* assertThat(myDate, isToday());
*
*/
public static Matcher isYesterday() {
return sameDay(ZonedDateTime.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(ZonedDateTime.now());
}
/**
* Creates a matcher that matches when the examined date is tomorrow
*
* For example:
*
*
* assertThat(myDate, isTomorrow());
*
*/
public static Matcher isTomorrow() {
return sameDay(ZonedDateTime.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(LocalDateTime.now()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameDayOfWeek(final ZonedDateTime 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(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 ZonedDateTimeFormatter());
}
/**
* Creates a matcher that matches when the examined date is on the expected hour (0-23)
*
* For example:
*
*
* assertThat(myDate, isHour(12));
*
*
* @param hour the hour of the day (0-23)
*/
public static Matcher isHour(final int hour) {
return new IsHour(hour, t -> t);
}
/**
* Creates a matcher that matches when the examined date is on the same hour as the reference date
*
* For example:
*
*
* assertThat(myDate, sameHourOfDay(ZonedDateTime.now()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameHourOfDay(final ZonedDateTime date) {
return isHour(date.getHour());
}
/**
* Creates a matcher that matches when the examined date is on the expected minute (0-59)
*
* For example:
*
*
* assertThat(myDate, isMinute(12));
*
*
* @param Minute the minute of the day (0-59)
*/
public static Matcher isMinute(final int minute) {
return new IsMinute(minute, t -> t);
}
/**
* Creates a matcher that matches when the examined date is on the same minute as the reference date
*
* For example:
*
*
* assertThat(myDate, sameMinuteOfHour(ZonedDateTime.now()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameMinuteOfHour(final ZonedDateTime date) {
return isMinute(date.getMinute());
}
/**
* Creates a matcher that matches when the examined date is on the expected second (0-59)
*
* For example:
*
*
* assertThat(myDate, isSecond(12));
*
*
* @param Second the second of the day (0-59)
*/
public static Matcher isSecond(final int Second) {
return new IsSecond(Second, t -> t);
}
/**
* Creates a matcher that matches when the examined date is on the same second as the reference date
*
* For example:
*
*
* assertThat(myDate, sameSecondOfMinute(ZonedDateTime.now()))
*
*
* @param date the reference date against which the examined date is checked
*/
public static Matcher sameSecondOfMinute(final ZonedDateTime date) {
return isSecond(date.getSecond());
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy