org.exparity.hamcrest.date

Class ZonedDateTimeMatchers

java.lang.Object

org.exparity.hamcrest.date.ZonedDateTimeMatchers

public abstract class ZonedDateTimeMatchers
extends Object

Static factory for creating Matcher instances for comparing ZonedDateTime instances

Author:

Stewart Bissett

Constructor Summary

Constructors

Constructor and Description
ZonedDateTimeMatchers()

Method Summary

Modifier and Type	Method and Description
static DateMatcher<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:
static DateMatcher<ZonedDateTime>	after(ZonedDateTime date) Creates a matcher that matches when the examined date is after the reference date For example:
static DateMatcher<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:
static DateMatcher<ZonedDateTime>	before(ZonedDateTime date) Creates a matcher that matches when the examined date is before the reference date For example:
static DateMatcher<ZonedDateTime>	isApril() Creates a matcher that matches when the examined date is in April For example:
static DateMatcher<ZonedDateTime>	isAugust() Creates a matcher that matches when the examined date is in August For example:
static DateMatcher<ZonedDateTime>	isDay(int year, Month month, int dayOfMonth, ZoneId tz) Creates a matcher that matches when the examined date is on the same day of the year as the reference date For example:
static DateMatcher<ZonedDateTime>	isDayOfMonth(int dayOfMonth) Creates a matcher that matches when the examined date is on the expected day of the month For example:
static DateMatcher<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:
static DateMatcher<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:
static DateMatcher<ZonedDateTime>	isDecember() Creates a matcher that matches when the examined date is in December For example:
static DateMatcher<ZonedDateTime>	isFebruary() Creates a matcher that matches when the examined date is in February For example:
static DateMatcher<ZonedDateTime>	isFirstDayOfMonth() Creates a matcher that matches when the examined date is on the first day of the month For example:
static DateMatcher<ZonedDateTime>	isFriday() Creates a matcher that matches when the examined date is on a friday For example:
static DateMatcher<ZonedDateTime>	isHour(int hour) Creates a matcher that matches when the examined date is on the expected hour (0-23) For example:
static DateMatcher<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:
static DateMatcher<ZonedDateTime>	isJanuary() Creates a matcher that matches when the examined date is in January For example:
static DateMatcher<ZonedDateTime>	isJuly() Creates a matcher that matches when the examined date is in July For example:
static DateMatcher<ZonedDateTime>	isJune() Creates a matcher that matches when the examined date is in June For example:
static DateMatcher<ZonedDateTime>	isLastDayOfMonth() Creates a matcher that matches when the examined date is on the first day of the month For example:
static DateMatcher<ZonedDateTime>	isLeapYear() Creates a matcher that matches when the examined date is a leap year For example:
static DateMatcher<ZonedDateTime>	isMarch() Creates a matcher that matches when the examined date is in March For example:
static DateMatcher<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:
static DateMatcher<ZonedDateTime>	isMay() Creates a matcher that matches when the examined date is in May For example:
static DateMatcher<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:
static DateMatcher<ZonedDateTime>	isMinute(int minute) Creates a matcher that matches when the examined date is on the expected minute (0-59) For example:
static DateMatcher<ZonedDateTime>	isMonday() Creates a matcher that matches when the examined date is on a monday For example:
static DateMatcher<ZonedDateTime>	isMonth(Month month) Creates a matcher that matches when the examined date is in the expected month For example:
static DateMatcher<ZonedDateTime>	isNovember() Creates a matcher that matches when the examined date is in November For example:
static DateMatcher<ZonedDateTime>	isOctober() Creates a matcher that matches when the examined date is in October For example:
static DateMatcher<ZonedDateTime>	isSaturday() Creates a matcher that matches when the examined date is on a saturday For example:
static DateMatcher<ZonedDateTime>	isSecond(int second) Creates a matcher that matches when the examined date is on the expected second (0-59) For example:
static DateMatcher<ZonedDateTime>	isSeptember() Creates a matcher that matches when the examined date is in September For example:
static DateMatcher<ZonedDateTime>	isSunday() Creates a matcher that matches when the examined date is on a sunday For example:
static DateMatcher<ZonedDateTime>	isThursday() Creates a matcher that matches when the examined date is on a thursday For example:
static DateMatcher<ZonedDateTime>	isToday() Creates a matcher that matches when the examined date is today For example:
static DateMatcher<ZonedDateTime>	isTomorrow() Creates a matcher that matches when the examined date is tomorrow For example:
static DateMatcher<ZonedDateTime>	isTuesday() Creates a matcher that matches when the examined date is on a tuesday For example:
static DateMatcher<ZonedDateTime>	isWednesday() Creates a matcher that matches when the examined date is on a wednesday For example:
static DateMatcher<ZonedDateTime>	isWeekday() Creates a matcher that matches when the examined date is on a weekday For example:
static DateMatcher<ZonedDateTime>	isWeekend() Creates a matcher that matches when the examined date is on a weekend For example:
static DateMatcher<ZonedDateTime>	isYear(int year) Creates a matcher that matches when the examined date is on the same year as the reference year For example:
static DateMatcher<ZonedDateTime>	isYesterday() Creates a matcher that matches when the examined date is yesterday For example:
static DateMatcher<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:
static DateMatcher<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:
static DateMatcher<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:
static DateMatcher<ZonedDateTime>	sameHourOfDay(ZonedDateTime date) Creates a matcher that matches when the examined date is on the same hour as the reference date For example:
static DateMatcher<ZonedDateTime>	sameInstant(ZonedDateTime date) Creates a matcher that matches when the examined date is at the same instant as the reference date For example:
static DateMatcher<ZonedDateTime>	sameMinuteOfHour(ZonedDateTime date) Creates a matcher that matches when the examined date is on the same minute as the reference date For example:
static DateMatcher<ZonedDateTime>	sameMonthOfYear(ZonedDateTime date) Creates a matcher that matches when the examined date is on the same month as the reference date For example:
static DateMatcher<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:
static DateMatcher<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:
static DateMatcher<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:
static DateMatcher<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:
static DateMatcher<ZonedDateTime>	sameSecondOfMinute(ZonedDateTime date) Creates a matcher that matches when the examined date is on the same second as the reference date For example:
static DateMatcher<ZonedDateTime>	sameYear(ZonedDateTime date) Creates a matcher that matches when the examined date is on the same year as the reference date For example:
static DateMatcher<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:
static DateMatcher<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:

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ZonedDateTimeMatchers

public ZonedDateTimeMatchers()

Method Detail

after

public static DateMatcher<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 DateMatcher<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 DateMatcher<ZonedDateTime> before(ZonedDateTime date)

Creates a matcher that matches when the examined date is before the reference date

For example:

 MatcherAssert.assertThat(myDate, ZonedDateTimeMatchers.before(ZonedDateTime.now()));
 

Parameters:

date - the reference date against which the examined date is checked

before

public static DateMatcher<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, ZonedDateTimeMatchers.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 nanoseconds of the second

sameDay

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

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()))
 

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

tz - the reference time zone

sameInstant

public static DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<ZonedDateTime> isYesterday()

Creates a matcher that matches when the examined date is yesterday

For example:

 assertThat(myDate, isToday());
 

isToday

public static DateMatcher<ZonedDateTime> isToday()

Creates a matcher that matches when the examined date is today

For example:

 assertThat(myDate, isToday());
 

isTomorrow

public static DateMatcher<ZonedDateTime> isTomorrow()

Creates a matcher that matches when the examined date is tomorrow

For example:

 assertThat(myDate, isTomorrow());
 

sameDayOfWeek

public static DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<ZonedDateTime> isMonday()

Creates a matcher that matches when the examined date is on a monday

For example:

 assertThat(myDate, isMonday());
 

isTuesday

public static DateMatcher<ZonedDateTime> isTuesday()

Creates a matcher that matches when the examined date is on a tuesday

For example:

 assertThat(myDate, isTuesday());
 

isWednesday

public static DateMatcher<ZonedDateTime> isWednesday()

Creates a matcher that matches when the examined date is on a wednesday

For example:

 assertThat(myDate, isWednesday());
 

isThursday

public static DateMatcher<ZonedDateTime> isThursday()

Creates a matcher that matches when the examined date is on a thursday

For example:

 assertThat(myDate, isThursday());
 

isFriday

public static DateMatcher<ZonedDateTime> isFriday()

Creates a matcher that matches when the examined date is on a friday

For example:

 assertThat(myDate, isFriday());
 

isSaturday

public static DateMatcher<ZonedDateTime> isSaturday()

Creates a matcher that matches when the examined date is on a saturday

For example:

 assertThat(myDate, isSaturday());
 

isSunday

public static DateMatcher<ZonedDateTime> isSunday()

Creates a matcher that matches when the examined date is on a sunday

For example:

 assertThat(myDate, isSunday());
 

isWeekday

public static DateMatcher<ZonedDateTime> isWeekday()

Creates a matcher that matches when the examined date is on a weekday

For example:

 assertThat(myDate, isWeekday());
 

isWeekend

public static DateMatcher<ZonedDateTime> isWeekend()

Creates a matcher that matches when the examined date is on a weekend

For example:

 assertThat(myDate, isWeekend());
 

isFirstDayOfMonth

public static DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<ZonedDateTime> isJanuary()

Creates a matcher that matches when the examined date is in January

For example:

 assertThat(myDate, isJanuary());
 

isFebruary

public static DateMatcher<ZonedDateTime> isFebruary()

Creates a matcher that matches when the examined date is in February

For example:

 assertThat(myDate, isFebruary());
 

isMarch

public static DateMatcher<ZonedDateTime> isMarch()

Creates a matcher that matches when the examined date is in March

For example:

 assertThat(myDate, isMarch());
 

isApril

public static DateMatcher<ZonedDateTime> isApril()

Creates a matcher that matches when the examined date is in April

For example:

 assertThat(myDate, isApril());
 

isMay

public static DateMatcher<ZonedDateTime> isMay()

Creates a matcher that matches when the examined date is in May

For example:

 assertThat(myDate, isMay());
 

isJune

public static DateMatcher<ZonedDateTime> isJune()

Creates a matcher that matches when the examined date is in June

For example:

 assertThat(myDate, isJune());
 

isJuly

public static DateMatcher<ZonedDateTime> isJuly()

Creates a matcher that matches when the examined date is in July

For example:

 assertThat(myDate, isJuly());
 

isAugust

public static DateMatcher<ZonedDateTime> isAugust()

Creates a matcher that matches when the examined date is in August

For example:

 assertThat(myDate, isAugust());
 

isSeptember

public static DateMatcher<ZonedDateTime> isSeptember()

Creates a matcher that matches when the examined date is in September

For example:

 assertThat(myDate, isSeptember());
 

isOctober

public static DateMatcher<ZonedDateTime> isOctober()

Creates a matcher that matches when the examined date is in October

For example:

 assertThat(myDate, isOctober());
 

isNovember

public static DateMatcher<ZonedDateTime> isNovember()

Creates a matcher that matches when the examined date is in November

For example:

 assertThat(myDate, isNovember());
 

isDecember

public static DateMatcher<ZonedDateTime> isDecember()

Creates a matcher that matches when the examined date is in December

For example:

 assertThat(myDate, isDecember());
 

isLeapYear

public static DateMatcher<ZonedDateTime> isLeapYear()

Creates a matcher that matches when the examined date is a leap year

For example:

 assertThat(myDate, isLeapYear());
 

isHour

public static DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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 DateMatcher<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