Package org.assertj.core.internal

Class Dates

  • public class Dates
extends Object
    Reusable assertions for Dates.
    Author:
    Joel Costigliola, William Delanoue

    • Method Detail

      • instance

        public static Dates instance()
        Returns the singleton instance of this class.
        Returns:
        the singleton instance of this class.

      • getComparator

        public Comparator<?> getComparator()

      • assertIsBefore

        public void assertIsBefore​(AssertionInfo info,
                           Date actual,
                           Date other)
        Verifies that the actual Date is strictly before the given one.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the other date to compare actual with.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if the actual Date is not strictly before the given one.

      • assertIsBeforeOrEqualTo

        public void assertIsBeforeOrEqualTo​(AssertionInfo info,
                                    Date actual,
                                    Date other)
        Verifies that the actual Date is before or equal to the given one.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the other date to compare actual with.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if the actual Date is not before or equal to the given one.

      • assertIsAfter

        public void assertIsAfter​(AssertionInfo info,
                          Date actual,
                          Date other)
        Verifies that the actual Date is strictly after the given one.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if the actual Date is not strictly after the given one.

      • assertIsAfterOrEqualTo

        public void assertIsAfterOrEqualTo​(AssertionInfo info,
                                   Date actual,
                                   Date other)
        Verifies that the actual Date is after or equal to the given one.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if the actual Date is not after or equal to the given one.

      • assertIsEqualWithPrecision

        public void assertIsEqualWithPrecision​(AssertionInfo info,
                                       Date actual,
                                       Date other,
                                       TimeUnit precision)
        Verifies that the actual Date is equal to the given one with precision.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date.
        precision - maximum precision for the comparison.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if the actual Date is not equal to the given one.

      • assertIsBetween

        public void assertIsBetween​(AssertionInfo info,
                            Date actual,
                            Date start,
                            Date end,
                            boolean inclusiveStart,
                            boolean inclusiveEnd)
        Verifies that the actual Date is in start:end period.
        start date belongs to the period if inclusiveStart is true.
        end date belongs to the period if inclusiveEnd is true.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        start - the period start, expected not to be null.
        end - the period end, expected not to be null.
        inclusiveStart - whether to include start date in period.
        inclusiveEnd - whether to include end date in period.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if start Date is null.
        NullPointerException - if end Date is null.
        AssertionError - if the actual Date is not in start:end period.

      • actualIsBetweenGivenPeriod

        private boolean actualIsBetweenGivenPeriod​(AssertionInfo info,
                                           Date actual,
                                           Date start,
                                           Date end,
                                           boolean inclusiveStart,
                                           boolean inclusiveEnd)

      • assertIsNotBetween

        public void assertIsNotBetween​(AssertionInfo info,
                               Date actual,
                               Date start,
                               Date end,
                               boolean inclusiveStart,
                               boolean inclusiveEnd)
        Verifies that the actual Date is not in start:end period..
        start date belongs to the period if inclusiveStart is true.
        end date belongs to the period if inclusiveEnd is true.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        start - the period start, expected not to be null.
        end - the period end, expected not to be null.
        inclusiveStart - whether to include start date in period.
        inclusiveEnd - whether to include end date in period.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if start Date is null.
        NullPointerException - if end Date is null.
        AssertionError - if the actual Date is in start:end period.

      • assertIsInThePast

        public void assertIsInThePast​(AssertionInfo info,
                              Date actual)
        Verifies that the actual Date is strictly in the past.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date is not in the past.

      • assertIsToday

        public void assertIsToday​(AssertionInfo info,
                          Date actual)
        Verifies that the actual Date is today, by comparing only year, month and day of actual to today (ie. we don't check hours).
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date is not today.

      • assertIsInTheFuture

        public void assertIsInTheFuture​(AssertionInfo info,
                                Date actual)
        Verifies that the actual Date is strictly in the future.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date is not in the future.

      • assertIsBeforeYear

        public void assertIsBeforeYear​(AssertionInfo info,
                               Date actual,
                               int year)
        Verifies that the actual Date is strictly before the given year.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        year - the year to compare actual year to
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date year is after or equal to the given year.

      • assertIsAfterYear

        public void assertIsAfterYear​(AssertionInfo info,
                              Date actual,
                              int year)
        Verifies that the actual Date is strictly after the given year.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        year - the year to compare actual year to
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date year is before or equal to the given year.

      • assertHasYear

        public void assertHasYear​(AssertionInfo info,
                          Date actual,
                          int year)
        Verifies that the actual Date year is equal to the given year.
        Parameters:
        year - the year to compare actual year to
        info - contains information about the assertion.
        actual - the "actual" Date.
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date year is not equal to the given year.

      • assertHasMonth

        public void assertHasMonth​(AssertionInfo info,
                           Date actual,
                           int month)
        Verifies that the actual Date month is equal to the given month, month value starting at 1 (January=1, February=2, ...).
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        month - the month to compare actual month to, see Calendar.MONTH for valid values
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date month is not equal to the given month.

      • assertHasDayOfMonth

        public void assertHasDayOfMonth​(AssertionInfo info,
                                Date actual,
                                int dayOfMonth)
        Verifies that the actual Date day of month is equal to the given day of month.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        dayOfMonth - the day of month to compare actual day of month to
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date month is not equal to the given day of month.

      • assertHasDayOfWeek

        public void assertHasDayOfWeek​(AssertionInfo info,
                               Date actual,
                               int dayOfWeek)
        Verifies that the actual Date day of week is equal to the given day of week.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        dayOfWeek - the day of week to compare actual day of week to, see Calendar.DAY_OF_WEEK for valid values
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date week is not equal to the given day of week.

      • assertHasHourOfDay

        public void assertHasHourOfDay​(AssertionInfo info,
                               Date actual,
                               int hourOfDay)
        Verifies that the actual Date hour od day is equal to the given hour of day (24-hour clock).
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        hourOfDay - the hour of day to compare actual hour of day to (24-hour clock)
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date hour is not equal to the given hour.

      • assertHasMinute

        public void assertHasMinute​(AssertionInfo info,
                            Date actual,
                            int minute)
        Verifies that the actual Date minute is equal to the given minute.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        minute - the minute to compare actual minute to
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date minute is not equal to the given minute.

      • assertHasSecond

        public void assertHasSecond​(AssertionInfo info,
                            Date actual,
                            int second)
        Verifies that the actual Date second is equal to the given second.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        second - the second to compare actual second to
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date second is not equal to the given second.

      • assertHasMillisecond

        public void assertHasMillisecond​(AssertionInfo info,
                                 Date actual,
                                 int millisecond)
        Verifies that the actual Date millisecond is equal to the given millisecond.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        millisecond - the millisecond to compare actual millisecond to
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date millisecond is not equal to the given millisecond.

      • assertIsInSameYearAs

        public void assertIsInSameYearAs​(AssertionInfo info,
                                 Date actual,
                                 Date other)
        Verifies that actual and given Date are in the same year.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date to compare actual Date to.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if actual and given Date are not in the same year.

      • areInSameYear

        private static boolean areInSameYear​(Date actual,
                                     Date other)
        Returns true if both date are in the same year, false otherwise.
        Parameters:
        actual - the actual date. expected not be null
        other - the other date. expected not be null
        Returns:
        true if both date are in the same year, false otherwise

      • assertIsInSameMonthAs

        public void assertIsInSameMonthAs​(AssertionInfo info,
                                  Date actual,
                                  Date other)
        Verifies that actual and given Date are chronologically in the same month (and thus in the same year).
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date to compare actual Date to.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if actual and given Date are not chronologically speaking in the same month.

      • areInSameMonth

        private static boolean areInSameMonth​(Date actual,
                                      Date other)
        Returns true if both date are in the same year and month, false otherwise.
        Parameters:
        actual - the actual date. expected not be null
        other - the other date. expected not be null
        Returns:
        true if both date are in the same year and month, false otherwise

      • assertIsInSameDayAs

        public void assertIsInSameDayAs​(AssertionInfo info,
                                Date actual,
                                Date other)
        Verifies that actual and given Date are chronologically in the same day of month (and thus in the same month and year).
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date to compare actual Date to.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if actual and given Date are not chronologically speaking in the same day of month.

      • areInSameDayOfMonth

        private static boolean areInSameDayOfMonth​(Date actual,
                                           Date other)
        Returns true if both date are in the same year, month and day of month, false otherwise.
        Parameters:
        actual - the actual date. expected not be null
        other - the other date. expected not be null
        Returns:
        true if both date are in the same year, month and day of month, false otherwise

      • assertIsInSameHourAs

        public void assertIsInSameHourAs​(AssertionInfo info,
                                 Date actual,
                                 Date other)
        Verifies that actual and given Date are in the same hour (and thus in the same day of month, month and year).
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date to compare actual Date to.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if actual and given Date are not chronologically speaking in the same hour.

      • assertIsInSameHourWindowAs

        public void assertIsInSameHourWindowAs​(AssertionInfo info,
                                       Date actual,
                                       Date other)
        Verifies that actual and given Date are chronologically in the same hour, day of month, month and year.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date to compare actual Date to.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if actual and given Date are not chronologically speaking in the same hour.

      • areInSameHourWindow

        private static boolean areInSameHourWindow​(Date actual,
                                           Date other)
        Returns true if both date are in the same year, month and day of month, hour, minute and second, false otherwise.
        Parameters:
        actual - the actual date. expected not be null
        other - the other date. expected not be null
        Returns:
        true if both date are in the same year, month and day of month, hour, minute and second, false otherwise.

      • areInSameHour

        private static boolean areInSameHour​(Date actual,
                                     Date other)
        Returns true if both date are in the same year, month, day of month and hour, false otherwise.
        Parameters:
        actual - the actual date. expected not be null
        other - the other date. expected not be null
        Returns:
        true if both date are in the same year, month, day of month and hour, false otherwise.

      • assertIsInSameMinuteAs

        public void assertIsInSameMinuteAs​(AssertionInfo info,
                                   Date actual,
                                   Date other)
        Verifies that actual and given Date are in the same minute, hour, day of month, month and year.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date to compare actual Date to.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if actual and given Date are not chronologically speaking in the same minute.

      • assertIsInSameMinuteWindowAs

        public void assertIsInSameMinuteWindowAs​(AssertionInfo info,
                                         Date actual,
                                         Date other)
        Verifies that actual and given Date are chronologically in the same minute.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date to compare actual Date to.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if actual and given Date are not chronologically speaking in the same minute.

      • areInSameMinute

        private static boolean areInSameMinute​(Date actual,
                                       Date other)
        Returns true if both date are in the same year, month, day of month, hour and minute, false otherwise.
        Parameters:
        actual - the actual date. expected not be null
        other - the other date. expected not be null
        Returns:
        true if both date are in the same year, month, day of month, hour and minute, false otherwise.

      • areInSameMinuteWindow

        private static boolean areInSameMinuteWindow​(Date actual,
                                             Date other)

      • assertIsInSameSecondAs

        public void assertIsInSameSecondAs​(AssertionInfo info,
                                   Date actual,
                                   Date other)
        Verifies that actual and given Date are in the same second, minute, hour, day of month, month and year.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date to compare actual Date to.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if actual and given Date are not chronologically speaking in the same second.

      • assertIsInSameSecondWindowAs

        public void assertIsInSameSecondWindowAs​(AssertionInfo info,
                                         Date actual,
                                         Date other)
        Verifies that actual and given Date are chronologically in the same second.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date to compare actual Date to.
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if actual and given Date are not chronologically speaking in the same second.

      • areInSameSecondWindow

        private static boolean areInSameSecondWindow​(Date actual,
                                             Date other)
        Returns true if both date are in the same year, month and day of month, hour, minute and second, false otherwise.
        Parameters:
        actual - the actual date. expected not be null
        other - the other date. expected not be null
        Returns:
        true if both date are in the same year, month and day of month, hour, minute and second, false otherwise.

      • areInSameSecond

        private static boolean areInSameSecond​(Date actual,
                                       Date other)
        Returns true if both date are in the same year, month and day of month, hour, minute and second, false otherwise.
        Parameters:
        actual - the actual date. expected not be null
        other - the other date. expected not be null
        Returns:
        true if both date are in the same year, month and day of month, hour, minute and second, false otherwise.

      • assertIsCloseTo

        public void assertIsCloseTo​(AssertionInfo info,
                            Date actual,
                            Date other,
                            long deltaInMilliseconds)
        Verifies that the actual Date is close to the other date by less than delta, if difference is equals to delta it is ok.
        Note that delta expressed in milliseconds.
        Use handy TimeUnit to convert a duration in milliseconds, for example you can express a delta of 5 seconds with TimeUnit.SECONDS.toMillis(5).
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        other - the given Date to compare actual Date to.
        deltaInMilliseconds - the delta used for date comparison, expressed in milliseconds
        Throws:
        AssertionError - if actual is null.
        NullPointerException - if other Date is null.
        AssertionError - if the actual Date week is not close to the given date by less than delta.

      • assertHasTime

        public void assertHasTime​(AssertionInfo info,
                          Date actual,
                          long timestamp)
        Verifies that the actual Date time is equal to the given timestamp.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        timestamp - the timestamp to compare actual time to
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date time is not equal to the given timestamp.

      • assertHasSameTime

        public void assertHasSameTime​(AssertionInfo info,
                              Date actual,
                              Date expected)
        Verifies that the actual Date has same time as the given Date.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        expected - the "expected" Date to compare actual time to
        Throws:
        AssertionError - if actual is null.
        AssertionError - if expected is null.
        AssertionError - if the actual Date time is not equal to the given Date.

      • hasSameTimeAs

        public void hasSameTimeAs​(AssertionInfo info,
                          Date actual,
                          Date date)
        Verifies that the actual Date is equal to the given date by comparing their time.
        Parameters:
        info - contains information about the assertion.
        actual - the "actual" Date.
        date - the date to compare actual time to
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual Date time is not equal to the given date time.
        NullPointerException - if other Date is null.

      • dateParameterIsNotNull

        private static void dateParameterIsNotNull​(Date date)
        used to check that the date to compare actual date to is not null, in that case throws a NullPointerException with an explicit message
        Parameters:
        date - the date to check
        Throws:
        NullPointerException - with an explicit message if the given date is null

      • startDateParameterIsNotNull

        private static void startDateParameterIsNotNull​(Date start)
        used to check that the start of period date to compare actual date to is not null, in that case throws a NullPointerException with an explicit message
        Parameters:
        start - the start date to check
        Throws:
        NullPointerException - with an explicit message if the given start date is null

      • endDateParameterIsNotNull

        private static void endDateParameterIsNotNull​(Date end)
        used to check that the end of period date to compare actual date to is not null, in that case throws a NullPointerException with an explicit message
        Parameters:
        end - the end date to check
        Throws:
        NullPointerException - with an explicit message if the given end date is null

      • isBeforeOrEqualTo

        private boolean isBeforeOrEqualTo​(Date actual,
                                  Date other)
        Returns true if the actual Date is before or equal to the given one according to underlying comparisonStrategy, false otherwise.
        Parameters:
        actual - the actual date - must not be null.
        other - the given Date.
        Returns:
        true if the actual Date is before or equal to the given one according to underlying comparisonStrategy, false otherwise.
        Throws:
        NullPointerException - if actual is null.

      • areEqual

        private boolean areEqual​(Date actual,
                         Date other)
        Returns true if the actual Date is equal to the given one according to underlying comparisonStrategy, false otherwise.
        Parameters:
        actual - the actual date - must not be null.
        other - the given Date.
        Returns:
        true if the actual Date is equal to the given one according to underlying comparisonStrategy, false otherwise.

      • isAfterOrEqualTo

        private boolean isAfterOrEqualTo​(Date actual,
                                 Date other)
        Returns true if the actual Date is after or equal to the given one according to underlying comparisonStrategy, false otherwise.
        Parameters:
        actual - the actual date - must not be null.
        other - the given Date.
        Returns:
        true if the actual Date is after or equal to the given one according to underlying comparisonStrategy, false otherwise.
        Throws:
        NullPointerException - if actual is null.

      • isBefore

        private boolean isBefore​(Date actual,
                         Date other)
        Returns true if actual is before other according to underlying comparisonStrategy, false otherwise.
        Parameters:
        actual - the Date to compare to other
        other - the Date to compare to actual
        Returns:
        true if actual is before other according to underlying comparisonStrategy, false otherwise.

      • isAfter

        private boolean isAfter​(Date actual,
                        Date other)
        Returns true if actual is after other according to underlying comparisonStrategy, false otherwise.
        Parameters:
        actual - the Date to compare to other
        other - the Date to compare to actual
        Returns:
        true if actual is after other according to underlying comparisonStrategy, false otherwise.