org.exparity.hamcrest.date

Class InstantMatchers

java.lang.Object

org.exparity.hamcrest.date.InstantMatchers

public abstract class InstantMatchers
extends Object

Static factory for creating Matcher instances for comparing ZonedDateTime instances

Author:

Stewart Bissett

Constructor Summary

Constructors

Constructor and Description
InstantMatchers()

Method Summary

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

Methods inherited from class java.lang.Object

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

Constructor Detail

InstantMatchers

public InstantMatchers()

Method Detail

after

public static TemporalMatcher<Instant> after(Instant date)

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

For example:

 MatcherAssert.assertThat(myDate, after(Instant.now()));
 

Parameters:

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

after

public static TemporalMatcher<Instant> 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<Instant> before(Instant date)

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

For example:

 MatcherAssert.assertThat(myDate, before(Instant.now()));
 

Parameters:

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

before

public static TemporalMatcher<Instant> 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<Instant> sameDay(Instant 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(Instant.now()));
 

Parameters:

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

isDay

public static TemporalMatcher<Instant> 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<Instant> 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<Instant> 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<Instant> sameInstant(Instant date)

Creates a matcher that matches when the examined date is at the same instant as the reference date

For example:

 assertThat(myDate, sameInstant(Instant.now()));
 

Parameters:

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

isInstant

public static TemporalMatcher<Instant> 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<Instant> sameOrBefore(Instant 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(Instant.now()))
 

Parameters:

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

sameOrBefore

public static TemporalMatcher<Instant> 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<Instant> sameOrAfter(Instant 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(Instant.now()))
 

Parameters:

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

sameOrAfter

public static TemporalMatcher<Instant> 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<Instant> sameMonthOfYear(Instant date)

Creates a matcher that matches when the examined date is on the same month as the reference date

For example:

 assertThat(myDate, sameMonth(Instant.now()))
 

Parameters:

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

sameDayOfMonth

public static TemporalMatcher<Instant> sameDayOfMonth(Instant 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(Instant.now()))
 

Parameters:

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

isDayOfMonth

public static TemporalMatcher<Instant> 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<Instant> sameYear(Instant date)

Creates a matcher that matches when the examined date is on the same year as the reference date

For example:

 assertThat(myDate, sameYear(Instant.now()))
 

Parameters:

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

isYear

public static TemporalMatcher<Instant> 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<Instant> within(long period,
                                              ChronoUnit unit,
                                              Instant 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<Instant> 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<Instant> isYesterday()

Creates a matcher that matches when the examined date is yesterday

For example:

 assertThat(myDate, isToday());
 

isToday

public static TemporalMatcher<Instant> isToday()

Creates a matcher that matches when the examined date is today

For example:

 assertThat(myDate, isToday());
 

isTomorrow

public static TemporalMatcher<Instant> isTomorrow()

Creates a matcher that matches when the examined date is tomorrow

For example:

 assertThat(myDate, isTomorrow());
 

sameDayOfWeek

public static TemporalMatcher<Instant> sameDayOfWeek(Instant 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<Instant> 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<Instant> 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<Instant> isMonday()

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

For example:

 assertThat(myDate, isMonday());
 

isTuesday

public static TemporalMatcher<Instant> isTuesday()

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

For example:

 assertThat(myDate, isTuesday());
 

isWednesday

public static TemporalMatcher<Instant> isWednesday()

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

For example:

 assertThat(myDate, isWednesday());
 

isThursday

public static TemporalMatcher<Instant> isThursday()

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

For example:

 assertThat(myDate, isThursday());
 

isFriday

public static TemporalMatcher<Instant> isFriday()

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

For example:

 assertThat(myDate, isFriday());
 

isSaturday

public static TemporalMatcher<Instant> isSaturday()

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

For example:

 assertThat(myDate, isSaturday());
 

isSunday

public static TemporalMatcher<Instant> isSunday()

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

For example:

 assertThat(myDate, isSunday());
 

isWeekday

public static TemporalMatcher<Instant> isWeekday()

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

For example:

 assertThat(myDate, isWeekday());
 

isWeekend

public static TemporalMatcher<Instant> isWeekend()

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

For example:

 assertThat(myDate, isWeekend());
 

isFirstDayOfMonth

public static TemporalMatcher<Instant> 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<Instant> 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<Instant> 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<Instant> 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<Instant> 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<Instant> isJanuary()

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

For example:

 assertThat(myDate, isJanuary());
 

isFebruary

public static TemporalMatcher<Instant> isFebruary()

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

For example:

 assertThat(myDate, isFebruary());
 

isMarch

public static TemporalMatcher<Instant> isMarch()

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

For example:

 assertThat(myDate, isMarch());
 

isApril

public static TemporalMatcher<Instant> isApril()

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

For example:

 assertThat(myDate, isApril());
 

isMay

public static TemporalMatcher<Instant> isMay()

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

For example:

 assertThat(myDate, isMay());
 

isJune

public static TemporalMatcher<Instant> isJune()

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

For example:

 assertThat(myDate, isJune());
 

isJuly

public static TemporalMatcher<Instant> isJuly()

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

For example:

 assertThat(myDate, isJuly());
 

isAugust

public static TemporalMatcher<Instant> isAugust()

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

For example:

 assertThat(myDate, isAugust());
 

isSeptember

public static TemporalMatcher<Instant> isSeptember()

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

For example:

 assertThat(myDate, isSeptember());
 

isOctober

public static TemporalMatcher<Instant> isOctober()

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

For example:

 assertThat(myDate, isOctober());
 

isNovember

public static TemporalMatcher<Instant> isNovember()

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

For example:

 assertThat(myDate, isNovember());
 

isDecember

public static TemporalMatcher<Instant> isDecember()

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

For example:

 assertThat(myDate, isDecember());
 

isLeapYear

public static TemporalMatcher<Instant> isLeapYear()

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

For example:

 assertThat(myDate, isLeapYear());
 

isHour

public static TemporalMatcher<Instant> 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<Instant> sameHourOfDay(Instant date)

Creates a matcher that matches when the examined date is on the same hour as the reference date

For example:

 assertThat(myDate, sameHourOfDay(Instant.now()))
 

Parameters:

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

isMinute

public static TemporalMatcher<Instant> 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<Instant> sameMinuteOfHour(Instant date)

Creates a matcher that matches when the examined date is on the same minute as the reference date

For example:

 assertThat(myDate, sameMinuteOfHour(Instant.now()))
 

Parameters:

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

isSecond

public static TemporalMatcher<Instant> 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<Instant> sameSecondOfMinute(Instant date)

Creates a matcher that matches when the examined date is on the same second as the reference date

For example:

 assertThat(myDate, sameSecondOfMinute(Instant.now()))
 

Parameters:

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