LocalDateMatchers (Hamcrest Date 2.0.1 API)

java.lang.Object
- org.exparity.hamcrest.date.LocalDateMatchers

```
public abstract class LocalDateMatchers
extends Object
```
Static factory for creating Matcher instances for comparing LocalDate instances

Author:

Stewart Bissett

Constructor Summary

Constructors
Constructor and Description

LocalDateMatchers()

Constructors
Constructor and Description
`LocalDateMatchers()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<LocalDate>`	`after(LocalDate date)` Creates a matcher that matches when the examined date is after the reference date For example:
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<LocalDate>`	`before(LocalDate date)` Creates a matcher that matches when the examined date is before the reference date For example:
`static org.hamcrest.Matcher<LocalDate>`	`isApril()` Creates a matcher that matches when the examined date is in April For example:
`static org.hamcrest.Matcher<LocalDate>`	`isAugust()` Creates a matcher that matches when the examined date is in August For example:
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<LocalDate>`	`isDayOfMonth(int dayOfMonth)` Creates a matcher that matches when the examined date is on the expected day of the month For example:
`static org.hamcrest.Matcher<LocalDate>`	`isDayOfWeek(DayOfWeek... dayOfWeek)` Creates a matcher that matches when the examined date is on a monday For example:
`static org.hamcrest.Matcher<LocalDate>`	`isDecember()` Creates a matcher that matches when the examined date is in December For example:
`static org.hamcrest.Matcher<LocalDate>`	`isFebruary()` Creates a matcher that matches when the examined date is in February For example:
`static org.hamcrest.Matcher<LocalDate>`	`isFirstDayOfMonth()` Creates a matcher that matches when the examined date is on the first day of the month For example:
`static org.hamcrest.Matcher<LocalDate>`	`isFriday()` Creates a matcher that matches when the examined date is on a friday For example:
`static org.hamcrest.Matcher<LocalDate>`	`isJanuary()` Creates a matcher that matches when the examined date is in January For example:
`static org.hamcrest.Matcher<LocalDate>`	`isJuly()` Creates a matcher that matches when the examined date is in July For example:
`static org.hamcrest.Matcher<LocalDate>`	`isJune()` Creates a matcher that matches when the examined date is in June For example:
`static org.hamcrest.Matcher<LocalDate>`	`isLastDayOfMonth()` Creates a matcher that matches when the examined date is on the first day of the month For example:
`static org.hamcrest.Matcher<LocalDate>`	`isLeapYear()` Creates a matcher that matches when the examined date is a leap year For example:
`static org.hamcrest.Matcher<LocalDate>`	`isMarch()` Creates a matcher that matches when the examined date is in March For example:
`static org.hamcrest.Matcher<LocalDate>`	`isMaximum(TemporalField 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 org.hamcrest.Matcher<LocalDate>`	`isMay()` Creates a matcher that matches when the examined date is in May For example:
`static org.hamcrest.Matcher<LocalDate>`	`isMinimum(TemporalField 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 org.hamcrest.Matcher<LocalDate>`	`isMonday()` Creates a matcher that matches when the examined date is on a monday For example:
`static org.hamcrest.Matcher<LocalDate>`	`isMonth(Month month)` Creates a matcher that matches when the examined date is in the expected month For example:
`static org.hamcrest.Matcher<LocalDate>`	`isNovember()` Creates a matcher that matches when the examined date is in November For example:
`static org.hamcrest.Matcher<LocalDate>`	`isOctober()` Creates a matcher that matches when the examined date is in October For example:
`static org.hamcrest.Matcher<LocalDate>`	`isSaturday()` Creates a matcher that matches when the examined date is on a saturday For example:
`static org.hamcrest.Matcher<LocalDate>`	`isSeptember()` Creates a matcher that matches when the examined date is in September For example:
`static org.hamcrest.Matcher<LocalDate>`	`isSunday()` Creates a matcher that matches when the examined date is on a sunday For example:
`static org.hamcrest.Matcher<LocalDate>`	`isThursday()` Creates a matcher that matches when the examined date is on a thursday For example:
`static org.hamcrest.Matcher<LocalDate>`	`isToday()` Creates a matcher that matches when the examined date is today For example:
`static org.hamcrest.Matcher<LocalDate>`	`isTomorrow()` Creates a matcher that matches when the examined date is tomorrow For example:
`static org.hamcrest.Matcher<LocalDate>`	`isTuesday()` Creates a matcher that matches when the examined date is on a tuesday For example:
`static org.hamcrest.Matcher<LocalDate>`	`isWednesday()` Creates a matcher that matches when the examined date is on a wednesday For example:
`static org.hamcrest.Matcher<LocalDate>`	`isWeekday()` Creates a matcher that matches when the examined date is on a weekday For example:
`static org.hamcrest.Matcher<LocalDate>`	`isWeekend()` Creates a matcher that matches when the examined date is on a weekend For example:
`static org.hamcrest.Matcher<LocalDate>`	`isYear(int year)` Creates a matcher that matches when the examined date is on the same year as the reference year For example:
`static org.hamcrest.Matcher<LocalDate>`	`isYesterday()` Creates a matcher that matches when the examined date is yesterday For example:
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<LocalDate>`	`sameMonthOfYear(LocalDate date)` Creates a matcher that matches when the examined date is on the same month as the reference date For example:
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<LocalDate>`	`sameYear(LocalDate date)` Creates a matcher that matches when the examined date is on the same year as the reference date For example:
`static org.hamcrest.Matcher<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:
`static org.hamcrest.Matcher<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:

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - LocalDateMatchers
```
public LocalDateMatchers()
```
- Method Detail
  - after
```
public static org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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:
    
    date - the expected day of the month
  - sameYear
```
public static org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<LocalDate> isYesterday()
```
    Creates a matcher that matches when the examined date is yesterday
    For example:
```
 assertThat(myDate, isToday());
 
```
  - isToday
```
public static org.hamcrest.Matcher<LocalDate> isToday()
```
    Creates a matcher that matches when the examined date is today
    For example:
```
 assertThat(myDate, isToday());
 
```
  - isTomorrow
```
public static org.hamcrest.Matcher<LocalDate> isTomorrow()
```
    Creates a matcher that matches when the examined date is tomorrow
    For example:
```
 assertThat(myDate, isTomorrow());
 
```
  - sameDayOfWeek
```
public static org.hamcrest.Matcher<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 org.hamcrest.Matcher<LocalDate> isDayOfWeek(DayOfWeek... dayOfWeek)
```
    Creates a matcher that matches when the examined date is on a monday
    For example:
```
 assertThat(myDate, isMonday());
 
```
  - isMonday
```
public static org.hamcrest.Matcher<LocalDate> isMonday()
```
    Creates a matcher that matches when the examined date is on a monday
    For example:
```
 assertThat(myDate, isMonday());
 
```
  - isTuesday
```
public static org.hamcrest.Matcher<LocalDate> isTuesday()
```
    Creates a matcher that matches when the examined date is on a tuesday
    For example:
```
 assertThat(myDate, isTuesday());
 
```
  - isWednesday
```
public static org.hamcrest.Matcher<LocalDate> isWednesday()
```
    Creates a matcher that matches when the examined date is on a wednesday
    For example:
```
 assertThat(myDate, isWednesday());
 
```
  - isThursday
```
public static org.hamcrest.Matcher<LocalDate> isThursday()
```
    Creates a matcher that matches when the examined date is on a thursday
    For example:
```
 assertThat(myDate, isThursday());
 
```
  - isFriday
```
public static org.hamcrest.Matcher<LocalDate> isFriday()
```
    Creates a matcher that matches when the examined date is on a friday
    For example:
```
 assertThat(myDate, isFriday());
 
```
  - isSaturday
```
public static org.hamcrest.Matcher<LocalDate> isSaturday()
```
    Creates a matcher that matches when the examined date is on a saturday
    For example:
```
 assertThat(myDate, isSaturday());
 
```
  - isSunday
```
public static org.hamcrest.Matcher<LocalDate> isSunday()
```
    Creates a matcher that matches when the examined date is on a sunday
    For example:
```
 assertThat(myDate, isSunday());
 
```
  - isWeekday
```
public static org.hamcrest.Matcher<LocalDate> isWeekday()
```
    Creates a matcher that matches when the examined date is on a weekday
    For example:
```
 assertThat(myDate, isWeekday());
 
```
  - isWeekend
```
public static org.hamcrest.Matcher<LocalDate> isWeekend()
```
    Creates a matcher that matches when the examined date is on a weekend
    For example:
```
 assertThat(myDate, isWeekend());
 
```
  - isFirstDayOfMonth
```
public static org.hamcrest.Matcher<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 org.hamcrest.Matcher<LocalDate> isMinimum(TemporalField 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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<LocalDate> isMaximum(TemporalField 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 org.hamcrest.Matcher<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 org.hamcrest.Matcher<LocalDate> isJanuary()
```
    Creates a matcher that matches when the examined date is in January
    For example:
```
 assertThat(myDate, isJanuary());
 
```
  - isFebruary
```
public static org.hamcrest.Matcher<LocalDate> isFebruary()
```
    Creates a matcher that matches when the examined date is in February
    For example:
```
 assertThat(myDate, isFebruary());
 
```
  - isMarch
```
public static org.hamcrest.Matcher<LocalDate> isMarch()
```
    Creates a matcher that matches when the examined date is in March
    For example:
```
 assertThat(myDate, isMarch());
 
```
  - isApril
```
public static org.hamcrest.Matcher<LocalDate> isApril()
```
    Creates a matcher that matches when the examined date is in April
    For example:
```
 assertThat(myDate, isApril());
 
```
  - isMay
```
public static org.hamcrest.Matcher<LocalDate> isMay()
```
    Creates a matcher that matches when the examined date is in May
    For example:
```
 assertThat(myDate, isMay());
 
```
  - isJune
```
public static org.hamcrest.Matcher<LocalDate> isJune()
```
    Creates a matcher that matches when the examined date is in June
    For example:
```
 assertThat(myDate, isJune());
 
```
  - isJuly
```
public static org.hamcrest.Matcher<LocalDate> isJuly()
```
    Creates a matcher that matches when the examined date is in July
    For example:
```
 assertThat(myDate, isJuly());
 
```
  - isAugust
```
public static org.hamcrest.Matcher<LocalDate> isAugust()
```
    Creates a matcher that matches when the examined date is in August
    For example:
```
 assertThat(myDate, isAugust());
 
```
  - isSeptember
```
public static org.hamcrest.Matcher<LocalDate> isSeptember()
```
    Creates a matcher that matches when the examined date is in September
    For example:
```
 assertThat(myDate, isSeptember());
 
```
  - isOctober
```
public static org.hamcrest.Matcher<LocalDate> isOctober()
```
    Creates a matcher that matches when the examined date is in October
    For example:
```
 assertThat(myDate, isOctober());
 
```
  - isNovember
```
public static org.hamcrest.Matcher<LocalDate> isNovember()
```
    Creates a matcher that matches when the examined date is in November
    For example:
```
 assertThat(myDate, isNovember());
 
```
  - isDecember
```
public static org.hamcrest.Matcher<LocalDate> isDecember()
```
    Creates a matcher that matches when the examined date is in December
    For example:
```
 assertThat(myDate, isDecember());
 
```
  - isLeapYear
```
public static org.hamcrest.Matcher<LocalDate> isLeapYear()
```
    Creates a matcher that matches when the examined date is a leap year
    For example:
```
 assertThat(myDate, isLeapYear());
 
```

Class LocalDateMatchers

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LocalDateMatchers

Method Detail

after

after

before

before

sameDay

isDay

sameOrBefore

sameOrBefore

sameOrAfter

sameOrAfter

sameMonthOfYear

sameDayOfMonth

isDayOfMonth

sameYear

isYear

within

within

isYesterday

isToday

isTomorrow

sameDayOfWeek

isDayOfWeek

isMonday

isTuesday

isWednesday

isThursday

isFriday

isSaturday

isSunday

isWeekday

isWeekend

isFirstDayOfMonth

isMinimum

isLastDayOfMonth

isMaximum

isMonth

isJanuary

isFebruary

isMarch

isApril

isMay

isJune

isJuly

isAugust

isSeptember

isOctober

isNovember

isDecember

isLeapYear