001 package org.fest.assertions.internal; 002 003 import static org.fest.assertions.error.ShouldBeAfter.shouldBeAfter; 004 import static org.fest.assertions.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo; 005 import static org.fest.assertions.error.ShouldBeBefore.shouldBeBefore; 006 import static org.fest.assertions.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo; 007 import static org.fest.assertions.error.ShouldBeBetween.shouldBeBetween; 008 import static org.fest.assertions.error.ShouldBeCloseTo.shouldBeCloseTo; 009 import static org.fest.assertions.error.ShouldBeInSameDay.shouldBeInSameDay; 010 import static org.fest.assertions.error.ShouldBeInSameHour.shouldBeInSameHour; 011 import static org.fest.assertions.error.ShouldBeInSameMinute.shouldBeInSameMinute; 012 import static org.fest.assertions.error.ShouldBeInSameMonth.shouldBeInSameMonth; 013 import static org.fest.assertions.error.ShouldBeInSameSecond.shouldBeInSameSecond; 014 import static org.fest.assertions.error.ShouldBeInSameYear.shouldBeInSameYear; 015 import static org.fest.assertions.error.ShouldBeInTheFuture.shouldBeInTheFuture; 016 import static org.fest.assertions.error.ShouldBeInThePast.shouldBeInThePast; 017 import static org.fest.assertions.error.ShouldBeToday.shouldBeToday; 018 import static org.fest.assertions.error.ShouldBeWithin.shouldBeWithin; 019 import static org.fest.assertions.error.ShouldNotBeBetween.shouldNotBeBetween; 020 import static org.fest.util.Dates.*; 021 022 import java.util.Calendar; 023 import java.util.Comparator; 024 import java.util.Date; 025 026 import org.fest.assertions.core.AssertionInfo; 027 import org.fest.util.ComparatorBasedComparisonStrategy; 028 import org.fest.util.ComparisonStrategy; 029 import org.fest.util.StandardComparisonStrategy; 030 import org.fest.util.VisibleForTesting; 031 032 /** 033 * Reusable assertions for <code>{@link Date}</code>s. 034 * 035 * @author Joel Costigliola 036 */ 037 public class Dates { 038 039 private static final Dates INSTANCE = new Dates(); 040 041 /** 042 * Returns the singleton instance of this class. 043 * @return the singleton instance of this class. 044 */ 045 public static Dates instance() { 046 return INSTANCE; 047 } 048 049 @VisibleForTesting 050 Failures failures = Failures.instance(); 051 052 @VisibleForTesting 053 Dates() { 054 this(StandardComparisonStrategy.instance()); 055 } 056 057 private ComparisonStrategy comparisonStrategy; 058 059 public Dates(ComparisonStrategy comparisonStrategy) { 060 this.comparisonStrategy = comparisonStrategy; 061 } 062 063 @VisibleForTesting 064 public Comparator<?> getComparator() { 065 if (comparisonStrategy instanceof ComparatorBasedComparisonStrategy) { 066 return ((ComparatorBasedComparisonStrategy)comparisonStrategy).getComparator(); 067 } 068 return null; 069 } 070 071 /** 072 * Verifies that the actual {@code Date} is strictly before the given one. 073 * @param info contains information about the assertion. 074 * @param actual the "actual" {@code Date}. 075 * @param other the other date to compare actual with. 076 * @throws AssertionError if {@code actual} is {@code null}. 077 * @throws NullPointerException if other {@code Date} is {@code null}. 078 * @throws AssertionError if the actual {@code Date} is not strictly before the given one. 079 */ 080 public void assertIsBefore(AssertionInfo info, Date actual, Date other) { 081 assertNotNull(info, actual); 082 dateParameterIsNotNull(other); 083 if (isBefore(actual, other)) return; 084 throw failures.failure(info, shouldBeBefore(actual, other, comparisonStrategy)); 085 } 086 087 /** 088 * Verifies that the actual {@code Date} is before or equal to the given one. 089 * @param info contains information about the assertion. 090 * @param actual the "actual" {@code Date}. 091 * @param other the other date to compare actual with. 092 * @throws AssertionError if {@code actual} is {@code null}. 093 * @throws NullPointerException if other {@code Date} is {@code null}. 094 * @throws AssertionError if the actual {@code Date} is not before or equal to the given one. 095 */ 096 public void assertIsBeforeOrEqualsTo(AssertionInfo info, Date actual, Date other) { 097 assertNotNull(info, actual); 098 dateParameterIsNotNull(other); 099 if (isBeforeOrEqualTo(actual, other)) return; 100 throw failures.failure(info, shouldBeBeforeOrEqualsTo(actual, other, comparisonStrategy)); 101 } 102 103 /** 104 * Verifies that the actual {@code Date} is strictly after the given one. 105 * @param info contains information about the assertion. 106 * @param actual the "actual" {@code Date}. 107 * @param other the given Date. 108 * @throws AssertionError if {@code actual} is {@code null}. 109 * @throws NullPointerException if other {@code Date} is {@code null}. 110 * @throws AssertionError if the actual {@code Date} is not strictly after the given one. 111 */ 112 public void assertIsAfter(AssertionInfo info, Date actual, Date other) { 113 assertNotNull(info, actual); 114 dateParameterIsNotNull(other); 115 if (isAfter(actual, other)) return; 116 throw failures.failure(info, shouldBeAfter(actual, other, comparisonStrategy)); 117 } 118 119 /** 120 * Verifies that the actual {@code Date} is after or equal to the given one. 121 * @param info contains information about the assertion. 122 * @param actual the "actual" {@code Date}. 123 * @param other the given Date. 124 * @throws AssertionError if {@code actual} is {@code null}. 125 * @throws NullPointerException if other {@code Date} is {@code null}. 126 * @throws AssertionError if the actual {@code Date} is not after or equal to the given one. 127 */ 128 public void assertIsAfterOrEqualsTo(AssertionInfo info, Date actual, Date other) { 129 assertNotNull(info, actual); 130 dateParameterIsNotNull(other); 131 if (isAfterOrEqualTo(actual, other)) return; 132 throw failures.failure(info, shouldBeAfterOrEqualsTo(actual, other, comparisonStrategy)); 133 } 134 135 /** 136 * Verifies that the actual {@code Date} is in <i>start:end</i> period.<br> 137 * start date belongs to the period if inclusiveStart is true.<br> 138 * end date belongs to the period if inclusiveEnd is true.<br> 139 * @param info contains information about the assertion. 140 * @param actual the "actual" {@code Date}. 141 * @param start the period start, expected not to be null. 142 * @param end the period end, expected not to be null. 143 * @param inclusiveStart wether to include start date in period. 144 * @param inclusiveEnd wether to include end date in period. 145 * @throws AssertionError if {@code actual} is {@code null}. 146 * @throws NullPointerException if start {@code Date} is {@code null}. 147 * @throws NullPointerException if end {@code Date} is {@code null}. 148 * @throws AssertionError if the actual {@code Date} is not in <i>start:end</i> period. 149 */ 150 public void assertIsBetween(AssertionInfo info, Date actual, Date start, Date end, boolean inclusiveStart, 151 boolean inclusiveEnd) { 152 assertNotNull(info, actual); 153 startDateParameterIsNotNull(start); 154 endDateParameterIsNotNull(end); 155 boolean checkLowerBoundaryPeriod = inclusiveStart ? isAfterOrEqualTo(actual, start) : isAfter(actual, start); 156 boolean checkUpperBoundaryPeriod = inclusiveEnd ? isBeforeOrEqualTo(actual, end) : isBefore(actual, end); 157 if (checkLowerBoundaryPeriod && checkUpperBoundaryPeriod) return; 158 throw failures.failure(info, shouldBeBetween(actual, start, end, inclusiveStart, inclusiveEnd, comparisonStrategy)); 159 } 160 161 /** 162 * Verifies that the actual {@code Date} is not in <i>start:end</i> period..<br> 163 * start date belongs to the period if inclusiveStart is true.<br> 164 * end date belongs to the period if inclusiveEnd is true.<br> 165 * @param info contains information about the assertion. 166 * @param actual the "actual" {@code Date}. 167 * @param start the period start, expected not to be null. 168 * @param end the period end, expected not to be null. 169 * @param inclusiveStart wether to include start date in period. 170 * @param inclusiveEnd wether to include end date in period. 171 * @throws AssertionError if {@code actual} is {@code null}. 172 * @throws NullPointerException if start {@code Date} is {@code null}. 173 * @throws NullPointerException if end {@code Date} is {@code null}. 174 * @throws AssertionError if the actual {@code Date} is in <i>start:end</i> period. 175 */ 176 public void assertIsNotBetween(AssertionInfo info, Date actual, Date start, Date end, boolean inclusiveStart, 177 boolean inclusiveEnd) { 178 assertNotNull(info, actual); 179 startDateParameterIsNotNull(start); 180 endDateParameterIsNotNull(end); 181 // check is in given period and use the negation of this result 182 boolean checkLowerBoundaryPeriod = inclusiveStart ? isAfterOrEqualTo(actual, start) : isAfter(actual, start); 183 boolean checkUpperBoundaryPeriod = inclusiveEnd ? isBeforeOrEqualTo(actual, end) : isBefore(actual, end); 184 boolean isBetweenGivenPeriod = checkLowerBoundaryPeriod && checkUpperBoundaryPeriod; 185 if (!isBetweenGivenPeriod) return; 186 throw failures.failure(info, shouldNotBeBetween(actual, start, end, inclusiveStart, inclusiveEnd, comparisonStrategy)); 187 } 188 189 /** 190 * Verifies that the actual {@code Date} is strictly in the past. 191 * @param info contains information about the assertion. 192 * @param actual the "actual" {@code Date}. 193 * @throws AssertionError if {@code actual} is {@code null}. 194 * @throws AssertionError if the actual {@code Date} is not in the past. 195 */ 196 public void assertIsInThePast(AssertionInfo info, Date actual) { 197 assertNotNull(info, actual); 198 if (isBefore(actual, today())) return; 199 throw failures.failure(info, shouldBeInThePast(actual, comparisonStrategy)); 200 } 201 202 /** 203 * Verifies that the actual {@code Date} is today, by comparing only year, month and day of actual to today (ie. we 204 * don't check hours). 205 * @param info contains information about the assertion. 206 * @param actual the "actual" {@code Date}. 207 * @throws AssertionError if {@code actual} is {@code null}. 208 * @throws AssertionError if the actual {@code Date} is not today. 209 */ 210 public void assertIsToday(AssertionInfo info, Date actual) { 211 assertNotNull(info, actual); 212 Date todayWithoutTime = truncateTime(today()); 213 Date actualWithoutTime = truncateTime(actual); 214 if (areEqual(actualWithoutTime, todayWithoutTime)) return; 215 throw failures.failure(info, shouldBeToday(actual, comparisonStrategy)); 216 } 217 218 /** 219 * Verifies that the actual {@code Date} is strictly in the future. 220 * @param info contains information about the assertion. 221 * @param actual the "actual" {@code Date}. 222 * @throws AssertionError if {@code actual} is {@code null}. 223 * @throws AssertionError if the actual {@code Date} is not in the future. 224 */ 225 public void assertIsInTheFuture(AssertionInfo info, Date actual) { 226 assertNotNull(info, actual); 227 if (isAfter(actual, today())) return; 228 throw failures.failure(info, shouldBeInTheFuture(actual, comparisonStrategy)); 229 } 230 231 /** 232 * Verifies that the actual {@code Date} is strictly before the given year. 233 * @param info contains information about the assertion. 234 * @param actual the "actual" {@code Date}. 235 * @param year the year to compare actual year to 236 * @throws AssertionError if {@code actual} is {@code null}. 237 * @throws AssertionError if the actual {@code Date} year is after or equal to the given year. 238 */ 239 public void assertIsBeforeYear(AssertionInfo info, Date actual, int year) { 240 assertNotNull(info, actual); 241 if (yearOf(actual) < year) return; 242 throw failures.failure(info, shouldBeBefore(actual, year)); 243 } 244 245 /** 246 * Verifies that the actual {@code Date} is strictly after the given year. 247 * @param info contains information about the assertion. 248 * @param actual the "actual" {@code Date}. 249 * @param year the year to compare actual year to 250 * @throws AssertionError if {@code actual} is {@code null}. 251 * @throws AssertionError if the actual {@code Date} year is before or equal to the given year. 252 */ 253 public void assertIsAfterYear(AssertionInfo info, Date actual, int year) { 254 assertNotNull(info, actual); 255 if (yearOf(actual) > year) return; 256 throw failures.failure(info, shouldBeAfter(actual, year)); 257 } 258 259 /** 260 * Verifies that the actual {@code Date} year is equal to the given year. 261 * @param year the year to compare actual year to 262 * @param info contains information about the assertion. 263 * @param actual the "actual" {@code Date}. 264 * @throws AssertionError if {@code actual} is {@code null}. 265 * @throws AssertionError if the actual {@code Date} year is not equal to the given year. 266 */ 267 public void assertIsWithinYear(AssertionInfo info, Date actual, int year) { 268 assertNotNull(info, actual); 269 if (yearOf(actual) == year) return; 270 throw failures.failure(info, shouldBeWithin(actual, "year", year)); 271 } 272 273 /** 274 * Verifies that the actual {@code Date} month is equal to the given month, <b>month value starting at 1</b> 275 * (January=1, February=2, ...). 276 * @param info contains information about the assertion. 277 * @param actual the "actual" {@code Date}. 278 * @param month the month to compare actual month to, see {@link Calendar#MONTH} for valid values 279 * @throws AssertionError if {@code actual} is {@code null}. 280 * @throws AssertionError if the actual {@code Date} month is not equal to the given month. 281 */ 282 public void assertIsWithinMonth(AssertionInfo info, Date actual, int month) { 283 assertNotNull(info, actual); 284 if (monthOf(actual) == month) return; 285 throw failures.failure(info, shouldBeWithin(actual, "month", month)); 286 } 287 288 /** 289 * Verifies that the actual {@code Date} day of month is equal to the given day of month. 290 * @param info contains information about the assertion. 291 * @param actual the "actual" {@code Date}. 292 * @param dayOfMonth the day of month to compare actual day of month to 293 * @throws AssertionError if {@code actual} is {@code null}. 294 * @throws AssertionError if the actual {@code Date} month is not equal to the given day of month. 295 */ 296 public void assertIsWithinDayOfMonth(AssertionInfo info, Date actual, int dayOfMonth) { 297 assertNotNull(info, actual); 298 if (dayOfMonthOf(actual) == dayOfMonth) return; 299 throw failures.failure(info, shouldBeWithin(actual, "day of month", dayOfMonth)); 300 } 301 302 /** 303 * Verifies that the actual {@code Date} day of week is equal to the given day of week. 304 * @param info contains information about the assertion. 305 * @param actual the "actual" {@code Date}. 306 * @param dayOfWeek the day of week to compare actual day of week to, see {@link Calendar#DAY_OF_WEEK} for valid 307 * values 308 * @throws AssertionError if {@code actual} is {@code null}. 309 * @throws AssertionError if the actual {@code Date} week is not equal to the given day of week. 310 */ 311 public void assertIsWithinDayOfWeek(AssertionInfo info, Date actual, int dayOfWeek) { 312 assertNotNull(info, actual); 313 if (dayOfWeekOf(actual) == dayOfWeek) return; 314 throw failures.failure(info, shouldBeWithin(actual, "day of week", dayOfWeek)); 315 } 316 317 /** 318 * Verifies that the actual {@code Date} hour od day is equal to the given hour of day (24-hour clock). 319 * @param info contains information about the assertion. 320 * @param actual the "actual" {@code Date}. 321 * @param hourOfDay the hour of day to compare actual hour of day to (24-hour clock) 322 * @throws AssertionError if {@code actual} is {@code null}. 323 * @throws AssertionError if the actual {@code Date} hour is not equal to the given hour. 324 */ 325 public void assertIsWithinHourOfDay(AssertionInfo info, Date actual, int hourOfDay) { 326 assertNotNull(info, actual); 327 if (hourOfDay(actual) == hourOfDay) return; 328 throw failures.failure(info, shouldBeWithin(actual, "hour", hourOfDay)); 329 } 330 331 /** 332 * Verifies that the actual {@code Date} minute is equal to the given minute. 333 * @param info contains information about the assertion. 334 * @param actual the "actual" {@code Date}. 335 * @param minute the minute to compare actual minute to 336 * @throws AssertionError if {@code actual} is {@code null}. 337 * @throws AssertionError if the actual {@code Date} minute is not equal to the given minute. 338 */ 339 public void assertIsWithinMinute(AssertionInfo info, Date actual, int minute) { 340 assertNotNull(info, actual); 341 if (minuteOf(actual) == minute) return; 342 throw failures.failure(info, shouldBeWithin(actual, "minute", minute)); 343 } 344 345 /** 346 * Verifies that the actual {@code Date} second is equal to the given second. 347 * @param info contains information about the assertion. 348 * @param actual the "actual" {@code Date}. 349 * @param second the second to compare actual second to 350 * @throws AssertionError if {@code actual} is {@code null}. 351 * @throws AssertionError if the actual {@code Date} second is not equal to the given second. 352 */ 353 public void assertIsWithinSecond(AssertionInfo info, Date actual, int second) { 354 assertNotNull(info, actual); 355 if (secondOf(actual) == second) return; 356 throw failures.failure(info, shouldBeWithin(actual, "second", second)); 357 } 358 359 /** 360 * Verifies that the actual {@code Date} millisecond is equal to the given millisecond. 361 * @param info contains information about the assertion. 362 * @param actual the "actual" {@code Date}. 363 * @param millisecond the millisecond to compare actual millisecond to 364 * @throws AssertionError if {@code actual} is {@code null}. 365 * @throws AssertionError if the actual {@code Date} millisecond is not equal to the given millisecond. 366 */ 367 public void assertIsWithinMillisecond(AssertionInfo info, Date actual, int millisecond) { 368 assertNotNull(info, actual); 369 if (millisecondOf(actual) == millisecond) return; 370 throw failures.failure(info, shouldBeWithin(actual, "millisecond", millisecond)); 371 } 372 373 /** 374 * Verifies that actual and given {@code Date} are in the same year. 375 * @param info contains information about the assertion. 376 * @param actual the "actual" {@code Date}. 377 * @param other the given {@code Date} to compare actual {@code Date} to. 378 * @throws AssertionError if {@code actual} is {@code null}. 379 * @throws NullPointerException if other {@code Date} is {@code null}. 380 * @throws AssertionError if actual and given {@code Date} are not in the same year. 381 */ 382 public void assertIsInSameYearAs(AssertionInfo info, Date actual, Date other) { 383 assertNotNull(info, actual); 384 dateParameterIsNotNull(other); 385 if (areInSameYear(actual, other)) return; 386 throw failures.failure(info, shouldBeInSameYear(actual, other)); 387 } 388 389 /** 390 * Returns true if both date are in the same year, false otherwise. 391 * @param actual the actual date. expected not be null 392 * @param other the other date. expected not be null 393 * @return true if both date are in the same year, false otherwise 394 */ 395 private static boolean areInSameYear(Date actual, Date other) { 396 return yearOf(actual) == yearOf(other); 397 } 398 399 /** 400 * Verifies that actual and given {@code Date} are chronologically in the same month (and thus in the same year). 401 * @param info contains information about the assertion. 402 * @param actual the "actual" {@code Date}. 403 * @param other the given {@code Date} to compare actual {@code Date} to. 404 * @throws AssertionError if {@code actual} is {@code null}. 405 * @throws NullPointerException if other {@code Date} is {@code null}. 406 * @throws AssertionError if actual and given {@code Date} are not chronologically speaking in the same month. 407 */ 408 public void assertIsInSameMonthAs(AssertionInfo info, Date actual, Date other) { 409 assertNotNull(info, actual); 410 dateParameterIsNotNull(other); 411 if (areInSameMonth(actual, other)) return; 412 throw failures.failure(info, shouldBeInSameMonth(actual, other)); 413 } 414 415 /** 416 * Returns true if both date are in the same year and month, false otherwise. 417 * @param actual the actual date. expected not be null 418 * @param other the other date. expected not be null 419 * @return true if both date are in the same year and month, false otherwise 420 */ 421 private static boolean areInSameMonth(Date actual, Date other) { 422 return areInSameYear(actual, other) && monthOf(actual) == monthOf(other); 423 } 424 425 /** 426 * Verifies that actual and given {@code Date} are chronologically in the same day of month (and thus in the same 427 * month and year). 428 * @param info contains information about the assertion. 429 * @param actual the "actual" {@code Date}. 430 * @param other the given {@code Date} to compare actual {@code Date} to. 431 * @throws AssertionError if {@code actual} is {@code null}. 432 * @throws NullPointerException if other {@code Date} is {@code null}. 433 * @throws AssertionError if actual and given {@code Date} are not chronologically speaking in the same day of month. 434 */ 435 public void assertIsInSameDayAs(AssertionInfo info, Date actual, Date other) { 436 assertNotNull(info, actual); 437 dateParameterIsNotNull(other); 438 if (areInSameDayOfMonth(actual, other)) return; 439 throw failures.failure(info, shouldBeInSameDay(actual, other)); 440 } 441 442 /** 443 * Returns true if both date are in the same year, month and day of month, false otherwise. 444 * @param actual the actual date. expected not be null 445 * @param other the other date. expected not be null 446 * @return true if both date are in the same year, month and day of month, false otherwise 447 */ 448 private static boolean areInSameDayOfMonth(Date actual, Date other) { 449 return areInSameMonth(actual, other) && dayOfMonthOf(actual) == dayOfMonthOf(other); 450 } 451 452 /** 453 * Verifies that actual and given {@code Date} are chronologically in the same hour (and thus in the same day of 454 * month, month and year). 455 * @param info contains information about the assertion. 456 * @param actual the "actual" {@code Date}. 457 * @param other the given {@code Date} to compare actual {@code Date} to. 458 * @throws AssertionError if {@code actual} is {@code null}. 459 * @throws NullPointerException if other {@code Date} is {@code null}. 460 * @throws AssertionError if actual and given {@code Date} are not chronologically speaking in the same hour. 461 */ 462 public void assertIsInSameHourAs(AssertionInfo info, Date actual, Date other) { 463 assertNotNull(info, actual); 464 dateParameterIsNotNull(other); 465 if (areInSameHour(actual, other)) return; 466 throw failures.failure(info, shouldBeInSameHour(actual, other)); 467 } 468 469 /** 470 * Returns true if both date are in the same year, month, day of month and hour, false otherwise. 471 * @param actual the actual date. expected not be null 472 * @param other the other date. expected not be null 473 * @return true if both date are in the same year, month, day of month and hour, false otherwise. 474 */ 475 private static boolean areInSameHour(Date actual, Date other) { 476 return areInSameDayOfMonth(actual, other) && hourOfDay(actual) == hourOfDay(other); 477 } 478 479 /** 480 * Verifies that actual and given {@code Date} are chronologically in the same minute (and thus in the same hour, day 481 * of month, month and year). 482 * @param info contains information about the assertion. 483 * @param actual the "actual" {@code Date}. 484 * @param other the given {@code Date} to compare actual {@code Date} to. 485 * @throws AssertionError if {@code actual} is {@code null}. 486 * @throws NullPointerException if other {@code Date} is {@code null}. 487 * @throws AssertionError if actual and given {@code Date} are not chronologically speaking in the same minute. 488 */ 489 public void assertIsInSameMinuteAs(AssertionInfo info, Date actual, Date other) { 490 assertNotNull(info, actual); 491 dateParameterIsNotNull(other); 492 if (areInSameMinute(actual, other)) return; 493 throw failures.failure(info, shouldBeInSameMinute(actual, other)); 494 } 495 496 /** 497 * Returns true if both date are in the same year, month, day of month, hour and minute, false otherwise. 498 * @param actual the actual date. expected not be null 499 * @param other the other date. expected not be null 500 * @return true if both date are in the same year, month, day of month, hour and minute, false otherwise. 501 */ 502 private static boolean areInSameMinute(Date actual, Date other) { 503 return areInSameHour(actual, other) && minuteOf(actual) == minuteOf(other); 504 } 505 506 /** 507 * Verifies that actual and given {@code Date} are chronologically in the same second (and thus in the same minute, 508 * hour, day of month, month and year). 509 * @param info contains information about the assertion. 510 * @param actual the "actual" {@code Date}. 511 * @param other the given {@code Date} to compare actual {@code Date} to. 512 * @throws AssertionError if {@code actual} is {@code null}. 513 * @throws NullPointerException if other {@code Date} is {@code null}. 514 * @throws AssertionError if actual and given {@code Date} are not chronologically speaking in the same second. 515 */ 516 public void assertIsInSameSecondAs(AssertionInfo info, Date actual, Date other) { 517 assertNotNull(info, actual); 518 dateParameterIsNotNull(other); 519 if (areInSameSecond(actual, other)) return; 520 throw failures.failure(info, shouldBeInSameSecond(actual, other)); 521 } 522 523 /** 524 * Returns true if both date are in the same year, month and day of month, hour, minute and second, false otherwise. 525 * @param actual the actual date. expected not be null 526 * @param other the other date. expected not be null 527 * @return true if both date are in the same year, month and day of month, hour, minute and second, false otherwise. 528 */ 529 private static boolean areInSameSecond(Date actual, Date other) { 530 return areInSameMinute(actual, other) && secondOf(actual) == secondOf(other); 531 } 532 533 /** 534 * Verifies that the actual {@code Date} is close to the other date by less than delta, if difference is equals to 535 * delta it is ok.<br> 536 * Note that delta expressed in milliseconds.<br> 537 * Use handy TimeUnit to convert a duration in milliseconds, for example you can express a delta of 5 seconds with 538 * <code>TimeUnit.SECONDS.toMillis(5)</code>. 539 * @param info contains information about the assertion. 540 * @param actual the "actual" {@code Date}. 541 * @param other the given {@code Date} to compare actual {@code Date} to. 542 * @param deltaInMilliseconds the delta used for date comparison, expressed in milliseconds 543 * @throws AssertionError if {@code actual} is {@code null}. 544 * @throws NullPointerException if other {@code Date} is {@code null}. 545 * @throws AssertionError if the actual {@code Date} week is not close to the given date by less than delta. 546 */ 547 public void assertIsCloseTo(AssertionInfo info, Date actual, Date other, long deltaInMilliseconds) { 548 assertNotNull(info, actual); 549 dateParameterIsNotNull(other); 550 long difference = Math.abs(actual.getTime() - other.getTime()); 551 if (difference <= deltaInMilliseconds) return; 552 throw failures.failure(info, shouldBeCloseTo(actual, other, deltaInMilliseconds, difference)); 553 } 554 555 /** 556 * used to check that the date to compare actual date to is not null, in that case throws a 557 * {@link NullPointerException} with an explicit message 558 * @param date the date to check 559 * @throws a {@link NullPointerException} with an explicit message if the given date is null 560 */ 561 private static void dateParameterIsNotNull(Date date) { 562 if (date == null) throw new NullPointerException("The date to compare actual with should not be null"); 563 } 564 565 /** 566 * used to check that the start of period date to compare actual date to is not null, in that case throws a 567 * {@link NullPointerException} with an explicit message 568 * @param start the start date to check 569 * @throws a {@link NullPointerException} with an explicit message if the given start date is null 570 */ 571 private static void startDateParameterIsNotNull(Date start) { 572 if (start == null) 573 throw new NullPointerException("The start date of period to compare actual with should not be null"); 574 } 575 576 /** 577 * used to check that the end of perdio date to compare actual date to is not null, in that case throws a 578 * {@link NullPointerException} with an explicit message 579 * @param end the end date to check 580 * @throws a {@link NullPointerException} with an explicit message if the given end date is null 581 */ 582 private static void endDateParameterIsNotNull(Date end) { 583 if (end == null) 584 throw new NullPointerException("The end date of period to compare actual with should not be null"); 585 } 586 587 private void assertNotNull(AssertionInfo info, Date actual) { 588 Objects.instance().assertNotNull(info, actual); 589 } 590 591 /** 592 * Returns <code>true</code> if the actual {@code Date} is before or equal to the given one according to underlying 593 * {@link #comparisonStrategy}, false otherwise. 594 * @param actual the actual date - must not be null. 595 * @param other the given Date. 596 * @return <code>true</code> if the actual {@code Date} is before or equal to the given one according to underlying 597 * {@link #comparisonStrategy}, false otherwise. 598 * @throws NullPointerException if {@code actual} is {@code null}. 599 */ 600 private boolean isBeforeOrEqualTo(Date actual, Date other) { 601 return comparisonStrategy.isLessThanOrEqualTo(actual, other); 602 } 603 604 /** 605 * Returns true if the actual {@code Date} is equal to the given one according to underlying 606 * {@link #comparisonStrategy}, false otherwise. 607 * @param actual the actual date - must not be null. 608 * @param other the given Date. 609 * @return <code>true</code> if the actual {@code Date} is equal to the given one according to underlying 610 * {@link #comparisonStrategy}, false otherwise. 611 */ 612 private boolean areEqual(Date actual, Date other) { 613 return comparisonStrategy.areEqual(other, actual); 614 } 615 616 /** 617 * Returns <code>true</code> if the actual {@code Date} is after or equal to the given one according to underlying 618 * {@link #comparisonStrategy}, false otherwise. 619 * @param actual the actual date - must not be null. 620 * @param other the given Date. 621 * @return <code>true</code> if the actual {@code Date} is after or equal to the given one according to underlying 622 * {@link #comparisonStrategy}, false otherwise. 623 * @throws NullPointerException if {@code actual} is {@code null}. 624 */ 625 private boolean isAfterOrEqualTo(Date actual, Date other) { 626 return comparisonStrategy.isGreaterThanOrEqualTo(actual, other); 627 } 628 629 /** 630 * Returns true if actual is before other according to underlying {@link #comparisonStrategy}, false otherwise. 631 * @param actual the {@link Date} to compare to other 632 * @param other the {@link Date} to compare to actual 633 * @return true if actual is before other according to underlying {@link #comparisonStrategy}, false otherwise. 634 */ 635 private boolean isBefore(Date actual, Date other) { 636 return comparisonStrategy.isLessThan(actual, other); 637 } 638 639 /** 640 * Returns true if actual is after other according to underlying {@link #comparisonStrategy}, false otherwise. 641 * @param actual the {@link Date} to compare to other 642 * @param other the {@link Date} to compare to actual 643 * @return true if actual is after other according to underlying {@link #comparisonStrategy}, false otherwise. 644 */ 645 private boolean isAfter(Date actual, Date other) { 646 return comparisonStrategy.isGreaterThan(actual, other); 647 } 648 649 }