Package org.exparity.hamcrest.date

Class ZonedDateTimeMatchers

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

    • Constructor Detail

      • ZonedDateTimeMatchers

        public ZonedDateTimeMatchers()

    • Method Detail

      • after

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

        For example: 

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

      • after

        public static TemporalMatcher<ZonedDateTime> after​(int year,
                                                   Month month,
                                                   int dayOfMonth,
                                                   int hour,
                                                   int minute,
                                                   int second,
                                                   int nanos,
                                                   ZoneId tz)
        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));
        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
        hour - the hour of the day
        minute - the minute of the hour
        second - the second of the minute
        nanos - the nanos of the second

      • before

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

        For example: 

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

      • before

        public static TemporalMatcher<ZonedDateTime> before​(int year,
                                                    Month month,
                                                    int dayOfMonth,
                                                    int hour,
                                                    int minute,
                                                    int second,
                                                    int nanos,
                                                    ZoneId tz)
        Creates a matcher that matches when the examined date is before the end of the reference year

        For example: 

         MatcherAssert.assertThat(myDate, 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
        hour - the hour of the day
        minute - the minute of the hour
        second - the second of the minute
        nanos - the nanos of the second

      • sameDay

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

      • isDay

        public static TemporalMatcher<ZonedDateTime> isDay​(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<ZonedDateTime> 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, sameDay(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

      • isDay

        public static TemporalMatcher<ZonedDateTime> isDay​(int year,
                                                   Month month,
                                                   int dayOfMonth,
                                                   ZoneId zone)
        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))
        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

      • sameInstant

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

      • isInstant

        public static TemporalMatcher<ZonedDateTime> isInstant​(int year,
                                                       Month month,
                                                       int dayOfMonth,
                                                       int hour,
                                                       int minute,
                                                       int second,
                                                       int nanos,
                                                       ZoneId tz)
        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))
        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
        hour - the hour of the day
        minute - the minute of the hour
        second - the second of the minute
        nanos - the nanosecond of the second
        tz - the timezone

      • sameOrBefore

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

      • sameOrBefore

        public static TemporalMatcher<ZonedDateTime> sameOrBefore​(int year,
                                                          Month month,
                                                          int day,
                                                          int hour,
                                                          int minute,
                                                          int second,
                                                          int nanos,
                                                          ZoneId tz)
        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()));
        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
        hour - the hour of the day
        minute - the minute of the hour
        second - the second of the minute
        nanos - the nanosecond of the second
        tz - the time zone of the date to check against

      • sameOrAfter

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

      • sameOrAfter

        public static TemporalMatcher<ZonedDateTime> sameOrAfter​(int year,
                                                         Month month,
                                                         int day,
                                                         int hour,
                                                         int minute,
                                                         int second,
                                                         int nanos,
                                                         ZoneId tz)
        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()));
        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
        hour - the hour of the day
        minute - the minute of the hour
        second - the second of the minute
        nanos - the nanosecond of the second
        tz - the time zone of the date to check against

      • sameMonthOfYear

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

      • sameDayOfMonth

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

      • isDayOfMonth

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

      • isYear

        public static TemporalMatcher<ZonedDateTime> 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<ZonedDateTime> within​(long period,
                                                    ChronoUnit unit,
                                                    ZonedDateTime 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<ZonedDateTime> within​(long period,
                                                    ChronoUnit unit,
                                                    int year,
                                                    Month month,
                                                    int dayofMonth,
                                                    int hour,
                                                    int minute,
                                                    int second,
                                                    int nanos,
                                                    ZoneId tz)
        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
        hour - the hour of the day
        minute - the minute of the hour
        second - the second of the minute
        nanos - the nanoseconds of the second
        tz - the time zone of the reference date

      • isYesterday

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

        For example: 

         assertThat(myDate, isToday());

      • isToday

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

        For example: 

         assertThat(myDate, isToday());

      • isTomorrow

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

        For example: 

         assertThat(myDate, isTomorrow());

      • sameDayOfWeek

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

      • isDayOfWeek

        public static TemporalMatcher<ZonedDateTime> isDayOfWeek​(DayOfWeek dayOfWeek)
        Creates a matcher that matches when the examined date is on the same day of the week as the supplied day

        For example: 

         assertThat(myDate, isMonday());

      • isDayOfWeek

        public static TemporalMatcher<ZonedDateTime> isDayOfWeek​(DayOfWeek... daysOfWeek)
        Creates a matcher that matches when the examined date is on the same day of the week as any of the supplied days

        For example: 

         assertThat(myDate, isMonday());

      • isMonday

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

        For example: 

         assertThat(myDate, isMonday());

      • isTuesday

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

        For example: 

         assertThat(myDate, isTuesday());

      • isWednesday

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

        For example: 

         assertThat(myDate, isWednesday());

      • isThursday

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

        For example: 

         assertThat(myDate, isThursday());

      • isFriday

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

        For example: 

         assertThat(myDate, isFriday());

      • isSaturday

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

        For example: 

         assertThat(myDate, isSaturday());

      • isSunday

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

        For example: 

         assertThat(myDate, isSunday());

      • isWeekday

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

        For example: 

         assertThat(myDate, isWeekday());

      • isWeekend

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

        For example: 

         assertThat(myDate, isWeekend());

      • isFirstDayOfMonth

        public static TemporalMatcher<ZonedDateTime> 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<ZonedDateTime> 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<ZonedDateTime> 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<ZonedDateTime> 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<ZonedDateTime> 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<ZonedDateTime> isJanuary()
        Creates a matcher that matches when the examined date is in January

        For example: 

         assertThat(myDate, isJanuary());

      • isFebruary

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

        For example: 

         assertThat(myDate, isFebruary());

      • isMarch

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

        For example: 

         assertThat(myDate, isMarch());

      • isApril

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

        For example: 

         assertThat(myDate, isApril());

      • isMay

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

        For example: 

         assertThat(myDate, isMay());

      • isJune

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

        For example: 

         assertThat(myDate, isJune());

      • isJuly

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

        For example: 

         assertThat(myDate, isJuly());

      • isAugust

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

        For example: 

         assertThat(myDate, isAugust());

      • isSeptember

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

        For example: 

         assertThat(myDate, isSeptember());

      • isOctober

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

        For example: 

         assertThat(myDate, isOctober());

      • isNovember

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

        For example: 

         assertThat(myDate, isNovember());

      • isDecember

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

        For example: 

         assertThat(myDate, isDecember());

      • isLeapYear

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

        For example: 

         assertThat(myDate, isLeapYear());

      • isHour

        public static TemporalMatcher<ZonedDateTime> isHour​(int hour)
        Creates a matcher that matches when the examined date is on the expected hour (0-23)

        For example: 

         assertThat(myDate, isHour(12));
        Parameters:
        hour - the hour of the day (0-23)

      • sameHourOfDay

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

      • isMinute

        public static TemporalMatcher<ZonedDateTime> isMinute​(int minute)
        Creates a matcher that matches when the examined date is on the expected minute (0-59)

        For example: 

         assertThat(myDate, isMinute(12));
        Parameters:
        minute - the minute of the day (0-59)

      • sameMinuteOfHour

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

      • isSecond

        public static TemporalMatcher<ZonedDateTime> isSecond​(int second)
        Creates a matcher that matches when the examined date is on the expected second (0-59)

        For example: 

         assertThat(myDate, isSecond(12));
        Parameters:
        second - the second of the day (0-59)

      • sameSecondOfMinute

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