Package org.exparity.hamcrest.date

Class LocalDateMatchers

  • public abstract class LocalDateMatchers
extends Object
    Static factory for creating Matcher instances for comparing LocalDate instances
    Author:
    Stewart Bissett

    • Constructor Detail

      • LocalDateMatchers

        public LocalDateMatchers()

    • Method Detail

      • after

        public static TemporalMatcher<LocalDate> after​(LocalDate date)
        Creates a matcher that matches when the examined date is after the reference date

        For example: 

         MatcherAssert.assertThat(myDate, LocalDateMatchers.after(LocalDate.now()));
        Parameters:
        date - the reference date against which the examined date is checked

      • after

        public static TemporalMatcher<LocalDate> after​(int year,
                                               Month month,
                                               int dayOfMonth)
        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));
        Parameters:
        year - the year against which the examined date is checked
        month - the month against which the examined date is checked
        dayOfMonth - the day of the month against which the examined date is checked

      • before

        public static TemporalMatcher<LocalDate> before​(LocalDate date)
        Creates a matcher that matches when the examined date is before the reference date

        For example: 

         MatcherAssert.assertThat(myDate, LocalDateMatchers.before(LocalDate.now()));
        Parameters:
        date - the reference date against which the examined date is checked

      • before

        public static TemporalMatcher<LocalDate> before​(int year,
                                                Month month,
                                                int dayOfMonth)
        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));
        Parameters:
        year - the year against which the examined date is checked
        month - the month against which the examined date is checked
        dayOfMonth - the day of the month against which the examined date is checked

      • sameDay

        public static TemporalMatcher<LocalDate> sameDay​(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, sameDay(LocalDate.now()));
        Parameters:
        date - the reference date against which the examined date is checked

      • isDay

        public static TemporalMatcher<LocalDate> isDay​(int year,
                                               Month month,
                                               int 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, isDay(2012, Month.JAN, 1))
        Parameters:
        dayOfMonth - the reference day of the month against which the examined date is checked
        month - the reference month against which the examined date is checked
        year - the reference year against which the examined date is checked

      • sameOrBefore

        public static TemporalMatcher<LocalDate> sameOrBefore​(LocalDate date)
        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()))
        Parameters:
        date - the reference date against which the examined date is checked

      • sameOrBefore

        public static TemporalMatcher<LocalDate> sameOrBefore​(int year,
                                                      Month month,
                                                      int day)
        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));
        Parameters:
        year - the year against which the examined date is checked
        month - the month against which the examined date is checked
        day - the day of the month against which the examined date is checked

      • sameOrAfter

        public static TemporalMatcher<LocalDate> sameOrAfter​(LocalDate date)
        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()))
        Parameters:
        date - the reference date against which the examined date is checked

      • sameOrAfter

        public static TemporalMatcher<LocalDate> sameOrAfter​(int year,
                                                     Month month,
                                                     int day)
        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));
        Parameters:
        year - the year against which the examined date is checked
        month - the month against which the examined date is checked
        day - the day of the month against which the examined date is checked

      • sameMonthOfYear

        public static TemporalMatcher<LocalDate> sameMonthOfYear​(LocalDate date)
        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()))
        Parameters:
        date - the reference date against which the examined date is checked

      • sameDayOfMonth

        public static TemporalMatcher<LocalDate> sameDayOfMonth​(LocalDate date)
        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()))
        Parameters:
        date - the reference date against which the examined date is checked

      • isDayOfMonth

        public static TemporalMatcher<LocalDate> isDayOfMonth​(int dayOfMonth)
        Creates a matcher that matches when the examined date is on the expected day of the month

        For example: 

         assertThat(myDate, isDayOfMonth(4))
        Parameters:
        dayOfMonth - the expected day of the month

      • sameYear

        public static TemporalMatcher<LocalDate> sameYear​(LocalDate date)
        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()))
        Parameters:
        date - the reference date against which the examined date is checked

      • isYear

        public static TemporalMatcher<LocalDate> isYear​(int year)
        Creates a matcher that matches when the examined date is on the same year as the reference year

        For example: 

         assertThat(myDate, sameYear(2013))
        Parameters:
        year - the reference year against which the examined date is checked

      • within

        public static TemporalMatcher<LocalDate> within​(Period period,
                                                LocalDate date)
        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()))
        Parameters:
        date - the reference date against which the examined date is checked

      • within

        public static TemporalMatcher<LocalDate> within​(long period,
                                                ChronoUnit unit,
                                                LocalDate date)
        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()))
        Parameters:
        date - the reference date against which the examined date is checked

      • within

        public static TemporalMatcher<LocalDate> within​(long period,
                                                ChronoUnit unit,
                                                int year,
                                                Month month,
                                                int dayofMonth)
        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));
        Parameters:
        period - the timeunit interval the examined date should be with
        unit - the timeunit to define the length of the period
        year - the year against which the examined date is checked
        month - the month against which the examined date is checked
        dayofMonth - the day of the month against which the examined date is checked

      • isYesterday

        public static TemporalMatcher<LocalDate> isYesterday()
        Creates a matcher that matches when the examined date is yesterday

        For example: 

         assertThat(myDate, isToday());

      • isToday

        public static TemporalMatcher<LocalDate> isToday()
        Creates a matcher that matches when the examined date is today

        For example: 

         assertThat(myDate, isToday());

      • isTomorrow

        public static TemporalMatcher<LocalDate> isTomorrow()
        Creates a matcher that matches when the examined date is tomorrow

        For example: 

         assertThat(myDate, isTomorrow());

      • sameDayOfWeek

        public static TemporalMatcher<LocalDate> sameDayOfWeek​(LocalDate date)
        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()))
        Parameters:
        date - the reference date against which the examined date is checked

      • isDayOfWeek

        public static TemporalMatcher<LocalDate> isDayOfWeek​(DayOfWeek dayOfWeek)
        Creates a matcher that matches when the examined date is on a monday

        For example: 

         assertThat(myDate, isMonday());

      • isDayOfWeek

        public static TemporalMatcher<LocalDate> isDayOfWeek​(DayOfWeek... daysOfWeek)
        Creates a matcher that matches when the examined date is on a monday

        For example: 

         assertThat(myDate, isMonday());

      • isMonday

        public static TemporalMatcher<LocalDate> isMonday()
        Creates a matcher that matches when the examined date is on a monday

        For example: 

         assertThat(myDate, isMonday());

      • isTuesday

        public static TemporalMatcher<LocalDate> isTuesday()
        Creates a matcher that matches when the examined date is on a tuesday

        For example: 

         assertThat(myDate, isTuesday());

      • isWednesday

        public static TemporalMatcher<LocalDate> isWednesday()
        Creates a matcher that matches when the examined date is on a wednesday

        For example: 

         assertThat(myDate, isWednesday());

      • isThursday

        public static TemporalMatcher<LocalDate> isThursday()
        Creates a matcher that matches when the examined date is on a thursday

        For example: 

         assertThat(myDate, isThursday());

      • isFriday

        public static TemporalMatcher<LocalDate> isFriday()
        Creates a matcher that matches when the examined date is on a friday

        For example: 

         assertThat(myDate, isFriday());

      • isSaturday

        public static TemporalMatcher<LocalDate> isSaturday()
        Creates a matcher that matches when the examined date is on a saturday

        For example: 

         assertThat(myDate, isSaturday());

      • isSunday

        public static TemporalMatcher<LocalDate> isSunday()
        Creates a matcher that matches when the examined date is on a sunday

        For example: 

         assertThat(myDate, isSunday());

      • isWeekday

        public static TemporalMatcher<LocalDate> isWeekday()
        Creates a matcher that matches when the examined date is on a weekday

        For example: 

         assertThat(myDate, isWeekday());

      • isWeekend

        public static TemporalMatcher<LocalDate> isWeekend()
        Creates a matcher that matches when the examined date is on a weekend

        For example: 

         assertThat(myDate, isWeekend());

      • isFirstDayOfMonth

        public static TemporalMatcher<LocalDate> isFirstDayOfMonth()
        Creates a matcher that matches when the examined date is on the first day of the month

        For example: 

         assertThat(myDate, isFirstDayOfMonth());

      • isMinimum

        public static TemporalMatcher<LocalDate> isMinimum​(ChronoField field)
        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));
        Parameters:
        field - the temporal field to check

      • isLastDayOfMonth

        public static TemporalMatcher<LocalDate> isLastDayOfMonth()
        Creates a matcher that matches when the examined date is on the first day of the month

        For example: 

         assertThat(myDate, isFirstDayOfMonth());

      • isMaximum

        public static TemporalMatcher<LocalDate> isMaximum​(ChronoField field)
        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));
        Parameters:
        field - the temporal field to check

      • isMonth

        public static TemporalMatcher<LocalDate> isMonth​(Month month)
        Creates a matcher that matches when the examined date is in the expected month

        For example: 

         assertThat(myDate, isMonth(Month.AUGUST));

      • isJanuary

        public static TemporalMatcher<LocalDate> isJanuary()
        Creates a matcher that matches when the examined date is in January

        For example: 

         assertThat(myDate, isJanuary());

      • isFebruary

        public static TemporalMatcher<LocalDate> isFebruary()
        Creates a matcher that matches when the examined date is in February

        For example: 

         assertThat(myDate, isFebruary());

      • isMarch

        public static TemporalMatcher<LocalDate> isMarch()
        Creates a matcher that matches when the examined date is in March

        For example: 

         assertThat(myDate, isMarch());

      • isApril

        public static TemporalMatcher<LocalDate> isApril()
        Creates a matcher that matches when the examined date is in April

        For example: 

         assertThat(myDate, isApril());

      • isMay

        public static TemporalMatcher<LocalDate> isMay()
        Creates a matcher that matches when the examined date is in May

        For example: 

         assertThat(myDate, isMay());

      • isJune

        public static TemporalMatcher<LocalDate> isJune()
        Creates a matcher that matches when the examined date is in June

        For example: 

         assertThat(myDate, isJune());

      • isJuly

        public static TemporalMatcher<LocalDate> isJuly()
        Creates a matcher that matches when the examined date is in July

        For example: 

         assertThat(myDate, isJuly());

      • isAugust

        public static TemporalMatcher<LocalDate> isAugust()
        Creates a matcher that matches when the examined date is in August

        For example: 

         assertThat(myDate, isAugust());

      • isSeptember

        public static TemporalMatcher<LocalDate> isSeptember()
        Creates a matcher that matches when the examined date is in September

        For example: 

         assertThat(myDate, isSeptember());

      • isOctober

        public static TemporalMatcher<LocalDate> isOctober()
        Creates a matcher that matches when the examined date is in October

        For example: 

         assertThat(myDate, isOctober());

      • isNovember

        public static TemporalMatcher<LocalDate> isNovember()
        Creates a matcher that matches when the examined date is in November

        For example: 

         assertThat(myDate, isNovember());

      • isDecember

        public static TemporalMatcher<LocalDate> isDecember()
        Creates a matcher that matches when the examined date is in December

        For example: 

         assertThat(myDate, isDecember());

      • isLeapYear

        public static TemporalMatcher<LocalDate> isLeapYear()
        Creates a matcher that matches when the examined date is a leap year

        For example: 

         assertThat(myDate, isLeapYear());