diff --git a/src/main/java/org/assertj/core/api/AbstractDateAssert.java b/src/main/java/org/assertj/core/api/AbstractDateAssert.java
--- a/src/main/java/org/assertj/core/api/AbstractDateAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractDateAssert.java
@@ -711,7 +711,7 @@ public SELF isBeforeOrEqualsTo(Date other) {
   }
 
   /**
-   * Verifies that the actual {@code Date} is before or equals to the given one.
+   * Verifies that the actual {@code Date} is before or equal to the given one.
    * <p>
    * Example:
    * <pre><code class='java'> SimpleDateFormat dateFormat = new SimpleDateFormat(&quot;yyyy-MM-dd&quot;);
@@ -914,7 +914,7 @@ public SELF isAfterOrEqualsTo(Date other) {
   }
 
   /**
-   * Verifies that the actual {@code Date} is after or equals to the given one.
+   * Verifies that the actual {@code Date} is after or equal to the given one.
    * <p>
    * Example:
    * <pre><code class='java'> SimpleDateFormat dateFormat = new SimpleDateFormat(&quot;yyyy-MM-dd&quot;);
diff --git a/src/main/java/org/assertj/core/api/AbstractInstantAssert.java b/src/main/java/org/assertj/core/api/AbstractInstantAssert.java
--- a/src/main/java/org/assertj/core/api/AbstractInstantAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractInstantAssert.java
@@ -13,9 +13,9 @@
 package org.assertj.core.api;
 
 import static org.assertj.core.error.ShouldBeAfter.shouldBeAfter;
-import static org.assertj.core.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.error.ShouldBeBefore.shouldBeBefore;
-import static org.assertj.core.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.util.Preconditions.checkArgument;
 
 import java.time.Instant;
@@ -108,7 +108,7 @@ public SELF isBeforeOrEqualTo(Instant other) {
     assertNotNull(info, actual);
     assertInstantParameterIsNotNull(other);
     if (actual.isAfter(other)) {
-      throw Failures.instance().failure(info, shouldBeBeforeOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeBeforeOrEqualTo(actual, other));
     }
     return myself;
   }
@@ -156,7 +156,7 @@ public SELF isAfterOrEqualTo(Instant other) {
     assertNotNull(info, actual);
     assertInstantParameterIsNotNull(other);
     if (actual.isBefore(other)) {
-      throw Failures.instance().failure(info, shouldBeAfterOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeAfterOrEqualTo(actual, other));
     }
     return myself;
   }
diff --git a/src/main/java/org/assertj/core/api/AbstractLocalDateAssert.java b/src/main/java/org/assertj/core/api/AbstractLocalDateAssert.java
--- a/src/main/java/org/assertj/core/api/AbstractLocalDateAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractLocalDateAssert.java
@@ -13,9 +13,9 @@
 package org.assertj.core.api;
 
 import static org.assertj.core.error.ShouldBeAfter.shouldBeAfter;
-import static org.assertj.core.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.error.ShouldBeBefore.shouldBeBefore;
-import static org.assertj.core.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.error.ShouldBeToday.shouldBeToday;
 import static org.assertj.core.util.Preconditions.checkArgument;
 
@@ -104,7 +104,7 @@ public SELF isBeforeOrEqualTo(LocalDate other) {
     Objects.instance().assertNotNull(info, actual);
     assertLocalDateParameterIsNotNull(other);
     if (actual.isAfter(other)) {
-      throw Failures.instance().failure(info, shouldBeBeforeOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeBeforeOrEqualTo(actual, other));
     }
     return myself;
   }
@@ -149,7 +149,7 @@ public SELF isAfterOrEqualTo(LocalDate other) {
     Objects.instance().assertNotNull(info, actual);
     assertLocalDateParameterIsNotNull(other);
     if (actual.isBefore(other)) {
-      throw Failures.instance().failure(info, shouldBeAfterOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeAfterOrEqualTo(actual, other));
     }
     return myself;
   }
diff --git a/src/main/java/org/assertj/core/api/AbstractLocalDateTimeAssert.java b/src/main/java/org/assertj/core/api/AbstractLocalDateTimeAssert.java
--- a/src/main/java/org/assertj/core/api/AbstractLocalDateTimeAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractLocalDateTimeAssert.java
@@ -13,9 +13,9 @@
 package org.assertj.core.api;
 
 import static org.assertj.core.error.ShouldBeAfter.shouldBeAfter;
-import static org.assertj.core.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.error.ShouldBeBefore.shouldBeBefore;
-import static org.assertj.core.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.error.ShouldBeEqualIgnoringHours.shouldBeEqualIgnoringHours;
 import static org.assertj.core.error.ShouldBeEqualIgnoringMinutes.shouldBeEqualIgnoringMinutes;
 import static org.assertj.core.error.ShouldBeEqualIgnoringNanos.shouldBeEqualIgnoringNanos;
@@ -113,7 +113,7 @@ public SELF isBeforeOrEqualTo(LocalDateTime other) {
     Objects.instance().assertNotNull(info, actual);
     assertLocalDateTimeParameterIsNotNull(other);
     if (actual.isAfter(other)) {
-      throw Failures.instance().failure(info, shouldBeBeforeOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeBeforeOrEqualTo(actual, other));
     }
     return myself;
   }
@@ -158,7 +158,7 @@ public SELF isAfterOrEqualTo(LocalDateTime other) {
     Objects.instance().assertNotNull(info, actual);
     assertLocalDateTimeParameterIsNotNull(other);
     if (actual.isBefore(other)) {
-      throw Failures.instance().failure(info, shouldBeAfterOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeAfterOrEqualTo(actual, other));
     }
     return myself;
   }
diff --git a/src/main/java/org/assertj/core/api/AbstractLocalTimeAssert.java b/src/main/java/org/assertj/core/api/AbstractLocalTimeAssert.java
--- a/src/main/java/org/assertj/core/api/AbstractLocalTimeAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractLocalTimeAssert.java
@@ -13,9 +13,9 @@
 package org.assertj.core.api;
 
 import static org.assertj.core.error.ShouldBeAfter.shouldBeAfter;
-import static org.assertj.core.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.error.ShouldBeBefore.shouldBeBefore;
-import static org.assertj.core.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.error.ShouldBeEqualIgnoringNanos.shouldBeEqualIgnoringNanos;
 import static org.assertj.core.error.ShouldBeEqualIgnoringSeconds.shouldBeEqualIgnoringSeconds;
 import static org.assertj.core.error.ShouldHaveSameHourAs.shouldHaveSameHourAs;
@@ -106,7 +106,7 @@ public SELF isBeforeOrEqualTo(LocalTime other) {
     Objects.instance().assertNotNull(info, actual);
     assertLocalTimeParameterIsNotNull(other);
     if (actual.isAfter(other)) {
-      throw Failures.instance().failure(info, shouldBeBeforeOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeBeforeOrEqualTo(actual, other));
     }
     return myself;
   }
@@ -151,7 +151,7 @@ public SELF isAfterOrEqualTo(LocalTime other) {
     Objects.instance().assertNotNull(info, actual);
     assertLocalTimeParameterIsNotNull(other);
     if (actual.isBefore(other)) {
-      throw Failures.instance().failure(info, shouldBeAfterOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeAfterOrEqualTo(actual, other));
     }
     return myself;
   }
diff --git a/src/main/java/org/assertj/core/api/AbstractOffsetDateTimeAssert.java b/src/main/java/org/assertj/core/api/AbstractOffsetDateTimeAssert.java
--- a/src/main/java/org/assertj/core/api/AbstractOffsetDateTimeAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractOffsetDateTimeAssert.java
@@ -13,9 +13,9 @@
 package org.assertj.core.api;
 
 import static org.assertj.core.error.ShouldBeAfter.shouldBeAfter;
-import static org.assertj.core.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.error.ShouldBeBefore.shouldBeBefore;
-import static org.assertj.core.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.error.ShouldBeEqualIgnoringHours.shouldBeEqualIgnoringHours;
 import static org.assertj.core.error.ShouldBeEqualIgnoringMinutes.shouldBeEqualIgnoringMinutes;
 import static org.assertj.core.error.ShouldBeEqualIgnoringNanos.shouldBeEqualIgnoringNanos;
@@ -116,7 +116,7 @@ public SELF isBeforeOrEqualTo(OffsetDateTime other) {
     Objects.instance().assertNotNull(info, actual);
     assertOffsetDateTimeParameterIsNotNull(other);
     if (actual.isAfter(other)) {
-      throw Failures.instance().failure(info, shouldBeBeforeOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeBeforeOrEqualTo(actual, other));
     }
     return myself;
   }
@@ -163,7 +163,7 @@ public SELF isAfterOrEqualTo(OffsetDateTime other) {
     Objects.instance().assertNotNull(info, actual);
     assertOffsetDateTimeParameterIsNotNull(other);
     if (actual.isBefore(other)) {
-      throw Failures.instance().failure(info, shouldBeAfterOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeAfterOrEqualTo(actual, other));
     }
     return myself;
   }
diff --git a/src/main/java/org/assertj/core/api/AbstractOffsetTimeAssert.java b/src/main/java/org/assertj/core/api/AbstractOffsetTimeAssert.java
--- a/src/main/java/org/assertj/core/api/AbstractOffsetTimeAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractOffsetTimeAssert.java
@@ -13,9 +13,9 @@
 package org.assertj.core.api;
 
 import static org.assertj.core.error.ShouldBeAfter.shouldBeAfter;
-import static org.assertj.core.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.error.ShouldBeBefore.shouldBeBefore;
-import static org.assertj.core.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.error.ShouldBeEqualIgnoringNanos.shouldBeEqualIgnoringNanos;
 import static org.assertj.core.error.ShouldBeEqualIgnoringSeconds.shouldBeEqualIgnoringSeconds;
 import static org.assertj.core.error.ShouldBeEqualIgnoringTimezone.shouldBeEqualIgnoringTimezone;
@@ -110,7 +110,7 @@ public SELF isBeforeOrEqualTo(OffsetTime other) {
     Objects.instance().assertNotNull(info, actual);
     assertOffsetTimeParameterIsNotNull(other);
     if (actual.isAfter(other)) {
-      throw Failures.instance().failure(info, shouldBeBeforeOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeBeforeOrEqualTo(actual, other));
     }
     return myself;
   }
@@ -156,7 +156,7 @@ public SELF isAfterOrEqualTo(OffsetTime other) {
     Objects.instance().assertNotNull(info, actual);
     assertOffsetTimeParameterIsNotNull(other);
     if (actual.isBefore(other)) {
-      throw Failures.instance().failure(info, shouldBeAfterOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeAfterOrEqualTo(actual, other));
     }
     return myself;
   }
diff --git a/src/main/java/org/assertj/core/api/AbstractZonedDateTimeAssert.java b/src/main/java/org/assertj/core/api/AbstractZonedDateTimeAssert.java
--- a/src/main/java/org/assertj/core/api/AbstractZonedDateTimeAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractZonedDateTimeAssert.java
@@ -13,9 +13,9 @@
 package org.assertj.core.api;
 
 import static org.assertj.core.error.ShouldBeAfter.shouldBeAfter;
-import static org.assertj.core.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.error.ShouldBeBefore.shouldBeBefore;
-import static org.assertj.core.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.error.ShouldBeEqualIgnoringHours.shouldBeEqualIgnoringHours;
 import static org.assertj.core.error.ShouldBeEqualIgnoringMinutes.shouldBeEqualIgnoringMinutes;
 import static org.assertj.core.error.ShouldBeEqualIgnoringNanos.shouldBeEqualIgnoringNanos;
@@ -112,7 +112,7 @@ public SELF isBeforeOrEqualTo(ZonedDateTime other) {
     Objects.instance().assertNotNull(info, actual);
     assertDateTimeParameterIsNotNull(other);
     if (actual.isAfter(other)) {
-      throw Failures.instance().failure(info, shouldBeBeforeOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeBeforeOrEqualTo(actual, other));
     }
     return myself;
   }
@@ -162,7 +162,7 @@ public SELF isAfterOrEqualTo(ZonedDateTime other) {
     Objects.instance().assertNotNull(info, actual);
     assertDateTimeParameterIsNotNull(other);
     if (actual.isBefore(other)) {
-      throw Failures.instance().failure(info, shouldBeAfterOrEqualsTo(actual, other));
+      throw Failures.instance().failure(info, shouldBeAfterOrEqualTo(actual, other));
     }
     return myself;
   }
diff --git a/src/main/java/org/assertj/core/error/ShouldBeBeforeOrEqualsTo.java b/src/main/java/org/assertj/core/error/ShouldBeAfterOrEqualTo.java
similarity index 61%
rename from src/main/java/org/assertj/core/error/ShouldBeBeforeOrEqualsTo.java
rename to src/main/java/org/assertj/core/error/ShouldBeAfterOrEqualTo.java
--- a/src/main/java/org/assertj/core/error/ShouldBeBeforeOrEqualsTo.java
+++ b/src/main/java/org/assertj/core/error/ShouldBeAfterOrEqualTo.java
@@ -15,37 +15,38 @@
 import org.assertj.core.internal.ComparisonStrategy;
 import org.assertj.core.internal.StandardComparisonStrategy;
 
-
 /**
- * Creates an error message indicating that an assertion that verifies that a {@link Object} is before or equals to another one
+ * Creates an error message indicating that an assertion that verifies that an {@link Object} is after or equal to another one
  * failed.
  * 
  * @author Joel Costigliola
  */
-public class ShouldBeBeforeOrEqualsTo extends BasicErrorMessageFactory {
+public class ShouldBeAfterOrEqualTo extends BasicErrorMessageFactory {
 
   /**
-   * Creates a new <code>{@link ShouldBeBeforeOrEqualsTo}</code>.
+   * Creates a new <code>{@link ShouldBeAfterOrEqualTo}</code>.
+   * 
    * @param actual the actual value in the failed assertion.
    * @param other the value used in the failed assertion to compare the actual value to.
    * @param comparisonStrategy the {@link ComparisonStrategy} used to evaluate assertion.
    * @return the created {@code ErrorMessageFactory}.
    */
-  public static ErrorMessageFactory shouldBeBeforeOrEqualsTo(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
-    return new ShouldBeBeforeOrEqualsTo(actual, other, comparisonStrategy);
+  public static ErrorMessageFactory shouldBeAfterOrEqualTo(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
+    return new ShouldBeAfterOrEqualTo(actual, other, comparisonStrategy);
   }
 
   /**
-   * Creates a new <code>{@link ShouldBeBeforeOrEqualsTo}</code>.
+   * Creates a new <code>{@link ShouldBeAfterOrEqualTo}</code>.
+   * 
    * @param actual the actual value in the failed assertion.
    * @param other the value used in the failed assertion to compare the actual value to.
    * @return the created {@code ErrorMessageFactory}.
    */
-  public static ErrorMessageFactory shouldBeBeforeOrEqualsTo(Object actual, Object other) {
-    return new ShouldBeBeforeOrEqualsTo(actual, other, StandardComparisonStrategy.instance());
+  public static ErrorMessageFactory shouldBeAfterOrEqualTo(Object actual, Object other) {
+    return new ShouldBeAfterOrEqualTo(actual, other, StandardComparisonStrategy.instance());
   }
 
-  private ShouldBeBeforeOrEqualsTo(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
-    super("%nExpecting:%n  <%s>%nto be before or equals to:%n  <%s>%s", actual, other, comparisonStrategy);
+  private ShouldBeAfterOrEqualTo(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
+    super("%nExpecting:%n  <%s>%nto be after or equal to:%n  <%s>%s", actual, other, comparisonStrategy);
   }
 }
diff --git a/src/main/java/org/assertj/core/error/ShouldBeAfterOrEqualsTo.java b/src/main/java/org/assertj/core/error/ShouldBeBeforeOrEqualTo.java
similarity index 62%
rename from src/main/java/org/assertj/core/error/ShouldBeAfterOrEqualsTo.java
rename to src/main/java/org/assertj/core/error/ShouldBeBeforeOrEqualTo.java
--- a/src/main/java/org/assertj/core/error/ShouldBeAfterOrEqualsTo.java
+++ b/src/main/java/org/assertj/core/error/ShouldBeBeforeOrEqualTo.java
@@ -12,44 +12,41 @@
  */
 package org.assertj.core.error;
 
-import java.util.Date;
-
-import org.assertj.core.internal.*;
+import org.assertj.core.internal.ComparisonStrategy;
+import org.assertj.core.internal.StandardComparisonStrategy;
 
 /**
- * Creates an error message indicating that an assertion that verifies that a {@link Date} is after or equals to another
- * one
+ * Creates an error message indicating that an assertion that verifies that an {@link Object} is before or equal to another one
  * failed.
  * 
  * @author Joel Costigliola
  */
-public class ShouldBeAfterOrEqualsTo extends BasicErrorMessageFactory {
+public class ShouldBeBeforeOrEqualTo extends BasicErrorMessageFactory {
 
   /**
-   * Creates a new <code>{@link ShouldBeAfterOrEqualsTo}</code>.
+   * Creates a new <code>{@link ShouldBeBeforeOrEqualTo}</code>.
    * 
    * @param actual the actual value in the failed assertion.
    * @param other the value used in the failed assertion to compare the actual value to.
    * @param comparisonStrategy the {@link ComparisonStrategy} used to evaluate assertion.
    * @return the created {@code ErrorMessageFactory}.
    */
-  public static ErrorMessageFactory shouldBeAfterOrEqualsTo(Object actual, Object other,
-	                                                        ComparisonStrategy comparisonStrategy) {
-	return new ShouldBeAfterOrEqualsTo(actual, other, comparisonStrategy);
+  public static ErrorMessageFactory shouldBeBeforeOrEqualTo(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
+    return new ShouldBeBeforeOrEqualTo(actual, other, comparisonStrategy);
   }
 
   /**
-   * Creates a new <code>{@link ShouldBeAfterOrEqualsTo}</code>.
+   * Creates a new <code>{@link ShouldBeBeforeOrEqualTo}</code>.
    * 
    * @param actual the actual value in the failed assertion.
    * @param other the value used in the failed assertion to compare the actual value to.
    * @return the created {@code ErrorMessageFactory}.
    */
-  public static ErrorMessageFactory shouldBeAfterOrEqualsTo(Object actual, Object other) {
-	return new ShouldBeAfterOrEqualsTo(actual, other, StandardComparisonStrategy.instance());
+  public static ErrorMessageFactory shouldBeBeforeOrEqualTo(Object actual, Object other) {
+    return new ShouldBeBeforeOrEqualTo(actual, other, StandardComparisonStrategy.instance());
   }
 
-  private ShouldBeAfterOrEqualsTo(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
-    super("%nExpecting:%n  <%s>%nto be after or equals to:%n  <%s>%s", actual, other, comparisonStrategy);
+  private ShouldBeBeforeOrEqualTo(Object actual, Object other, ComparisonStrategy comparisonStrategy) {
+    super("%nExpecting:%n  <%s>%nto be before or equal to:%n  <%s>%s", actual, other, comparisonStrategy);
   }
 }
diff --git a/src/main/java/org/assertj/core/internal/Dates.java b/src/main/java/org/assertj/core/internal/Dates.java
--- a/src/main/java/org/assertj/core/internal/Dates.java
+++ b/src/main/java/org/assertj/core/internal/Dates.java
@@ -13,10 +13,10 @@
 package org.assertj.core.internal;
 
 import static org.assertj.core.error.ShouldBeAfter.shouldBeAfter;
-import static org.assertj.core.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.error.ShouldBeAfterYear.shouldBeAfterYear;
 import static org.assertj.core.error.ShouldBeBefore.shouldBeBefore;
-import static org.assertj.core.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.error.ShouldBeBeforeYear.shouldBeBeforeYear;
 import static org.assertj.core.error.ShouldBeBetween.shouldBeBetween;
 import static org.assertj.core.error.ShouldBeCloseTo.shouldBeCloseTo;
@@ -128,7 +128,7 @@ public void assertIsBeforeOrEqualTo(AssertionInfo info, Date actual, Date other)
     assertNotNull(info, actual);
     dateParameterIsNotNull(other);
     if (!isBeforeOrEqualTo(actual, other))
-      throw failures.failure(info, shouldBeBeforeOrEqualsTo(actual, other, comparisonStrategy));
+      throw failures.failure(info, shouldBeBeforeOrEqualTo(actual, other, comparisonStrategy));
   }
 
   /**
@@ -160,7 +160,7 @@ public void assertIsAfterOrEqualTo(AssertionInfo info, Date actual, Date other)
     assertNotNull(info, actual);
     dateParameterIsNotNull(other);
     if (!isAfterOrEqualTo(actual, other))
-      throw failures.failure(info, shouldBeAfterOrEqualsTo(actual, other, comparisonStrategy));
+      throw failures.failure(info, shouldBeAfterOrEqualTo(actual, other, comparisonStrategy));
   }
 
   /**

diff --git a/src/test/java/org/assertj/core/api/date/DateAssert_isAfterOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/date/DateAssert_isAfterOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/date/DateAssert_isAfterOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/date/DateAssert_isAfterOrEqualTo_Test.java
@@ -18,7 +18,6 @@
 
 import org.assertj.core.api.DateAssert;
 
-
 /**
  * Tests for <code>{@link DateAssert#isAfterOrEqualTo(Date)}</code>.
  * 
diff --git a/src/test/java/org/assertj/core/api/instant/InstantAssert_IsBeforeOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/instant/InstantAssert_IsBeforeOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/instant/InstantAssert_IsBeforeOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/instant/InstantAssert_IsBeforeOrEqualTo_Test.java
@@ -12,11 +12,11 @@
  */
 package org.assertj.core.api.instant;
 
-import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.Instant;
@@ -36,10 +36,8 @@ public void test_isBeforeOrEqual_assertion() {
 
   @Test
   public void test_isBeforeOrEqual_assertion_error_message() {
-    Instant instantReference = Instant.parse("2007-12-03T10:15:30.00Z");
-    Instant instantAfter = Instant.parse("2007-12-03T10:15:35.00Z");
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(instantAfter).isBeforeOrEqualTo(instantReference))
-                                                   .withMessage(format("%nExpecting:%n  <2007-12-03T10:15:35Z>%nto be before or equals to:%n  <2007-12-03T10:15:30Z>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isBeforeOrEqualTo(BEFORE))
+                                                   .withMessage(shouldBeBeforeOrEqualTo(REFERENCE, BEFORE).create());
   }
 
   @Test
@@ -69,4 +67,3 @@ private static void verify_that_isBeforeOrEqual_assertion_fails_and_throws_Asser
   }
 
 }
-
diff --git a/src/test/java/org/assertj/core/api/instant/InstantAssert_isAfterOrEqual_Test.java b/src/test/java/org/assertj/core/api/instant/InstantAssert_isAfterOrEqual_Test.java
--- a/src/test/java/org/assertj/core/api/instant/InstantAssert_isAfterOrEqual_Test.java
+++ b/src/test/java/org/assertj/core/api/instant/InstantAssert_isAfterOrEqual_Test.java
@@ -12,12 +12,11 @@
  */
 package org.assertj.core.api.instant;
 
-
-import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.Instant;
@@ -40,11 +39,7 @@ public void test_isAfterOrEqual_assertion_error_message() {
     Instant instantReference = Instant.parse("2007-12-03T10:15:30.00Z");
     Instant instantAfter = Instant.parse("2007-12-03T10:15:35.00Z");
     assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(instantReference).isAfterOrEqualTo(instantAfter))
-                                                   .withMessage(format("%n" +
-                                                                       "Expecting:%n" +
-                                                                       "  <2007-12-03T10:15:30Z>%n" +
-                                                                       "to be after or equals to:%n" +
-                                                                       "  <2007-12-03T10:15:35Z>"));
+                                                   .withMessage(shouldBeAfterOrEqualTo(instantReference, instantAfter).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/localdate/LocalDateAssert_isAfterOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/localdate/LocalDateAssert_isAfterOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/localdate/LocalDateAssert_isAfterOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/localdate/LocalDateAssert_isAfterOrEqualTo_Test.java
@@ -12,11 +12,11 @@
  */
 package org.assertj.core.api.localdate;
 
-import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.LocalDate;
@@ -32,23 +32,17 @@ public class LocalDateAssert_isAfterOrEqualTo_Test extends LocalDateAssertBaseTe
 
   @Test
   public void test_isAfterOrEqual_assertion() {
-	// WHEN
-	assertThat(AFTER).isAfterOrEqualTo(REFERENCE);
-	assertThat(REFERENCE).isAfterOrEqualTo(REFERENCE);
-	// THEN
-	verify_that_isAfterOrEqual_assertion_fails_and_throws_AssertionError(BEFORE, REFERENCE);
+    // WHEN
+    assertThat(AFTER).isAfterOrEqualTo(REFERENCE);
+    assertThat(REFERENCE).isAfterOrEqualTo(REFERENCE);
+    // THEN
+    verify_that_isAfterOrEqual_assertion_fails_and_throws_AssertionError(BEFORE, REFERENCE);
   }
 
   @Test
   public void test_isAfterOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> 
-    assertThat(LocalDate.of(2000, 1, 5)).isAfterOrEqualTo(LocalDate.of(2012, 1, 1))).withMessage(format("%n" +
-                                                                                                        "Expecting:%n" +
-                                                                                                        "  <2000-01-05>%n"
-                                                                                                        +
-                                                                                                        "to be after or equals to:%n"
-                                                                                                        +
-                                                                                                        "  <2012-01-01>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isAfterOrEqualTo(AFTER))
+                                                   .withMessage(shouldBeAfterOrEqualTo(REFERENCE, AFTER).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/localdate/LocalDateAssert_isBeforeOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/localdate/LocalDateAssert_isBeforeOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/localdate/LocalDateAssert_isBeforeOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/localdate/LocalDateAssert_isBeforeOrEqualTo_Test.java
@@ -12,11 +12,11 @@
  */
 package org.assertj.core.api.localdate;
 
-import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.LocalDate;
@@ -41,8 +41,8 @@ public void test_isBeforeOrEqual_assertion() {
 
   @Test
   public void test_isBeforeOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(LocalDate.of(2000, 1, 5)).isBeforeOrEqualTo(LocalDate.of(1998, 1, 1)))
-                                                   .withMessage(format("%nExpecting:%n  <2000-01-05>%nto be before or equals to:%n  <1998-01-01>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isBeforeOrEqualTo(BEFORE))
+                                                   .withMessage(shouldBeBeforeOrEqualTo(REFERENCE, BEFORE).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/localdatetime/LocalDateTimeAssert_isAfterOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/localdatetime/LocalDateTimeAssert_isAfterOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/localdatetime/LocalDateTimeAssert_isAfterOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/localdatetime/LocalDateTimeAssert_isAfterOrEqualTo_Test.java
@@ -12,11 +12,11 @@
  */
 package org.assertj.core.api.localdatetime;
 
-import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.LocalDateTime;
@@ -32,27 +32,17 @@ public class LocalDateTimeAssert_isAfterOrEqualTo_Test extends LocalDateTimeAsse
 
   @Test
   public void test_isAfterOrEqual_assertion() {
-	// WHEN
-	assertThat(AFTER).isAfterOrEqualTo(REFERENCE);
-	assertThat(REFERENCE).isAfterOrEqualTo(REFERENCE);
-	// THEN
-	verify_that_isAfterOrEqual_assertion_fails_and_throws_AssertionError(BEFORE, REFERENCE);
+    // WHEN
+    assertThat(AFTER).isAfterOrEqualTo(REFERENCE);
+    assertThat(REFERENCE).isAfterOrEqualTo(REFERENCE);
+    // THEN
+    verify_that_isAfterOrEqual_assertion_fails_and_throws_AssertionError(BEFORE, REFERENCE);
   }
 
   @Test
   public void test_isAfterOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(LocalDateTime.of(2000, 1, 5, 3, 0,
-                                                                                                 5)).isAfterOrEqualTo(LocalDateTime.of(2012,
-                                                                                                                                       1,
-                                                                                                                                       1,
-                                                                                                                                       3,
-                                                                                                                                       3,
-                                                                                                                                       3)))
-                                                   .withMessage(format("%n" +
-                                                                       "Expecting:%n" +
-                                                                       "  <2000-01-05T03:00:05>%n" +
-                                                                       "to be after or equals to:%n" +
-                                                                       "  <2012-01-01T03:03:03>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isAfterOrEqualTo(AFTER))
+                                                   .withMessage(shouldBeAfterOrEqualTo(REFERENCE, AFTER).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/localdatetime/LocalDateTimeAssert_isBeforeOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/localdatetime/LocalDateTimeAssert_isBeforeOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/localdatetime/LocalDateTimeAssert_isBeforeOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/localdatetime/LocalDateTimeAssert_isBeforeOrEqualTo_Test.java
@@ -12,11 +12,11 @@
  */
 package org.assertj.core.api.localdatetime;
 
-import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.LocalDateTime;
@@ -41,8 +41,8 @@ public void test_isBeforeOrEqual_assertion() {
 
   @Test
   public void test_isBeforeOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(LocalDateTime.of(2000, 1, 5, 3, 0, 5)).isBeforeOrEqualTo(LocalDateTime.of(1998, 1, 1, 3, 3, 3)))
-                                                   .withMessage(format("%nExpecting:%n  <2000-01-05T03:00:05>%nto be before or equals to:%n  <1998-01-01T03:03:03>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isBeforeOrEqualTo(BEFORE))
+                                                   .withMessage(shouldBeBeforeOrEqualTo(REFERENCE, BEFORE).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/localtime/LocalTimeAssert_isAfterOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/localtime/LocalTimeAssert_isAfterOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/localtime/LocalTimeAssert_isAfterOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/localtime/LocalTimeAssert_isAfterOrEqualTo_Test.java
@@ -12,11 +12,11 @@
  */
 package org.assertj.core.api.localtime;
 
-import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.LocalTime;
@@ -32,24 +32,17 @@ public class LocalTimeAssert_isAfterOrEqualTo_Test extends LocalTimeAssertBaseTe
 
   @Test
   public void test_isAfterOrEqual_assertion() {
-	// WHEN
-	assertThat(AFTER).isAfterOrEqualTo(REFERENCE);
-	assertThat(REFERENCE).isAfterOrEqualTo(REFERENCE);
-	// THEN
-	verify_that_isAfterOrEqual_assertion_fails_and_throws_AssertionError(BEFORE, REFERENCE);
+    // WHEN
+    assertThat(AFTER).isAfterOrEqualTo(REFERENCE);
+    assertThat(REFERENCE).isAfterOrEqualTo(REFERENCE);
+    // THEN
+    verify_that_isAfterOrEqual_assertion_fails_and_throws_AssertionError(BEFORE, REFERENCE);
   }
 
   @Test
   public void test_isAfterOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(LocalTime.of(3, 0,
-                                                                                             5)).isAfterOrEqualTo(LocalTime.of(3,
-                                                                                                                               3,
-                                                                                                                               3)))
-                                                   .withMessage(format("%n" +
-                                                                       "Expecting:%n" +
-                                                                       "  <03:00:05>%n" +
-                                                                       "to be after or equals to:%n" +
-                                                                       "  <03:03:03>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isAfterOrEqualTo(AFTER))
+                                                   .withMessage(shouldBeAfterOrEqualTo(REFERENCE, AFTER).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/localtime/LocalTimeAssert_isBeforeOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/localtime/LocalTimeAssert_isBeforeOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/localtime/LocalTimeAssert_isBeforeOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/localtime/LocalTimeAssert_isBeforeOrEqualTo_Test.java
@@ -12,11 +12,11 @@
  */
 package org.assertj.core.api.localtime;
 
-import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.LocalTime;
@@ -32,24 +32,17 @@ public class LocalTimeAssert_isBeforeOrEqualTo_Test extends LocalTimeAssertBaseT
 
   @Test
   public void test_isBeforeOrEqual_assertion() {
-	// WHEN
-	assertThat(BEFORE).isBeforeOrEqualTo(REFERENCE);
-	assertThat(REFERENCE).isBeforeOrEqualTo(REFERENCE);
-	// THEN
-	verify_that_isBeforeOrEqual_assertion_fails_and_throws_AssertionError(AFTER, REFERENCE);
+    // WHEN
+    assertThat(BEFORE).isBeforeOrEqualTo(REFERENCE);
+    assertThat(REFERENCE).isBeforeOrEqualTo(REFERENCE);
+    // THEN
+    verify_that_isBeforeOrEqual_assertion_fails_and_throws_AssertionError(AFTER, REFERENCE);
   }
 
   @Test
   public void test_isBeforeOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(LocalTime.of(3, 0,
-                                                                                             5)).isBeforeOrEqualTo(LocalTime.of(3,
-                                                                                                                                0,
-                                                                                                                                4)))
-                                                   .withMessage(format("%n" +
-                                                                       "Expecting:%n" +
-                                                                       "  <03:00:05>%n" +
-                                                                       "to be before or equals to:%n" +
-                                                                       "  <03:00:04>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isBeforeOrEqualTo(BEFORE))
+                                                   .withMessage(shouldBeBeforeOrEqualTo(REFERENCE, BEFORE).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isAfterOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isAfterOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isAfterOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isAfterOrEqualTo_Test.java
@@ -12,13 +12,11 @@
  */
 package org.assertj.core.api.offsetdatetime;
 
-import static java.lang.String.format;
-import static java.time.OffsetDateTime.of;
-import static java.time.ZoneOffset.UTC;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.OffsetDateTime;
@@ -45,15 +43,8 @@ public void test_isAfterOrEqual_assertion() {
 
   @Test
   public void test_isAfterOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(of(2000, 1, 5, 3, 0, 5, 0,
-                                                                                   UTC)).isAfterOrEqualTo(of(2012, 1, 1,
-                                                                                                             3, 3, 3, 0,
-                                                                                                             UTC)))
-                                                   .withMessage(format("%n" +
-                                                                       "Expecting:%n" +
-                                                                       "  <2000-01-05T03:00:05Z>%n" +
-                                                                       "to be after or equals to:%n" +
-                                                                       "  <2012-01-01T03:03:03Z>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isAfterOrEqualTo(AFTER))
+                                                   .withMessage(shouldBeAfterOrEqualTo(REFERENCE, AFTER).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isBeforeOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isBeforeOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isBeforeOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isBeforeOrEqualTo_Test.java
@@ -12,13 +12,11 @@
  */
 package org.assertj.core.api.offsetdatetime;
 
-import static java.lang.String.format;
-import static java.time.OffsetDateTime.of;
-import static java.time.ZoneOffset.UTC;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.OffsetDateTime;
@@ -45,15 +43,8 @@ public void test_isBeforeOrEqual_assertion() {
 
   @Test
   public void test_isBeforeOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(of(2000, 1, 5, 3, 0, 5, 0,
-                                                                                   UTC)).isBeforeOrEqualTo(of(1998, 1,
-                                                                                                              1, 3, 3,
-                                                                                                              3, 0,
-                                                                                                              UTC)))
-                                                   .withMessage(format("%nExpecting:%n" +
-                                                                       "  <2000-01-05T03:00:05Z>%n" +
-                                                                       "to be before or equals to:%n" +
-                                                                       "  <1998-01-01T03:03:03Z>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isBeforeOrEqualTo(BEFORE))
+                                                   .withMessage(shouldBeBeforeOrEqualTo(REFERENCE, BEFORE).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/offsettime/OffsetTimeAssert_isAfterOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/offsettime/OffsetTimeAssert_isAfterOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/offsettime/OffsetTimeAssert_isAfterOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/offsettime/OffsetTimeAssert_isAfterOrEqualTo_Test.java
@@ -12,15 +12,14 @@
  */
 package org.assertj.core.api.offsettime;
 
-import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.fail;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.OffsetTime;
-import java.time.ZoneOffset;
 
 import org.junit.jupiter.api.Test;
 
@@ -44,17 +43,8 @@ public void test_isAfterOrEqual_assertion() {
 
   @Test
   public void test_isAfterOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(OffsetTime.of(3, 0, 5, 0,
-                                                                                              ZoneOffset.UTC)).isAfterOrEqualTo(OffsetTime.of(3,
-                                                                                                                                              3,
-                                                                                                                                              3,
-                                                                                                                                              0,
-                                                                                                                                              ZoneOffset.UTC)))
-                                                   .withMessage(format("%n" +
-                                                                      "Expecting:%n" +
-                                                                      "  <03:00:05Z>%n" +
-                                                                      "to be after or equals to:%n" +
-                                                                      "  <03:03:03Z>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isAfterOrEqualTo(AFTER))
+                                                   .withMessage(shouldBeAfterOrEqualTo(REFERENCE, AFTER).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/offsettime/OffsetTimeAssert_isBeforeOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/offsettime/OffsetTimeAssert_isBeforeOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/offsettime/OffsetTimeAssert_isBeforeOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/offsettime/OffsetTimeAssert_isBeforeOrEqualTo_Test.java
@@ -12,15 +12,14 @@
  */
 package org.assertj.core.api.offsettime;
 
-import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.fail;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.OffsetTime;
-import java.time.ZoneOffset;
 
 import org.junit.jupiter.api.Test;
 
@@ -44,17 +43,8 @@ public void test_isBeforeOrEqual_assertion() {
 
   @Test
   public void test_isBeforeOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(OffsetTime.of(3, 0, 5, 0,
-                                                                                              ZoneOffset.UTC)).isBeforeOrEqualTo(OffsetTime.of(3,
-                                                                                                                                               0,
-                                                                                                                                               4,
-                                                                                                                                               0,
-                                                                                                                                               ZoneOffset.UTC)))
-                                                   .withMessage(format("%n" +
-                                                                       "Expecting:%n" +
-                                                                       "  <03:00:05Z>%n" +
-                                                                       "to be before or equals to:%n" +
-                                                                       "  <03:00:04Z>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isBeforeOrEqualTo(BEFORE))
+                                                   .withMessage(shouldBeBeforeOrEqualTo(REFERENCE, BEFORE).create());
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/zoneddatetime/ZonedDateTimeAssert_isAfterOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/zoneddatetime/ZonedDateTimeAssert_isAfterOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/zoneddatetime/ZonedDateTimeAssert_isAfterOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/zoneddatetime/ZonedDateTimeAssert_isAfterOrEqualTo_Test.java
@@ -12,12 +12,12 @@
  */
 package org.assertj.core.api.zoneddatetime;
 
-import static java.lang.String.format;
 import static java.time.ZoneOffset.UTC;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.fail;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.ZoneId;
@@ -57,8 +57,8 @@ public void isAfterOrEqualTo_should_compare_datetimes_in_actual_timezone() {
 
   @Test
   public void test_isAfterOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(ZonedDateTime.of(2000, 1, 5, 3, 0, 5, 0, UTC)).isAfterOrEqualTo(ZonedDateTime.of(2012, 1, 1, 3, 3, 3, 0, UTC)))
-                                                   .withMessage(format("%nExpecting:%n  <2000-01-05T03:00:05Z>%nto be after or equals to:%n  <2012-01-01T03:03:03Z>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isAfterOrEqualTo(AFTER))
+                                                   .withMessage(shouldBeAfterOrEqualTo(REFERENCE, AFTER).create());
   }
 
   @Test
@@ -66,7 +66,7 @@ public void should_fail_if_actual_is_null() {
     assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> {
       ZonedDateTime actual = null;
       assertThat(actual).isAfterOrEqualTo(ZonedDateTime.now());
-    }).withMessage( actualIsNull());
+    }).withMessage(actualIsNull());
   }
 
   @Test
@@ -82,7 +82,7 @@ public void should_fail_if_dateTime_as_string_parameter_is_null() {
   }
 
   private static void verify_that_isAfterOrEqual_assertion_fails_and_throws_AssertionError(ZonedDateTime dateToCheck,
-      ZonedDateTime reference) {
+                                                                                           ZonedDateTime reference) {
     try {
       assertThat(dateToCheck).isAfterOrEqualTo(reference);
     } catch (AssertionError e) {
diff --git a/src/test/java/org/assertj/core/api/zoneddatetime/ZonedDateTimeAssert_isBeforeOrEqualTo_Test.java b/src/test/java/org/assertj/core/api/zoneddatetime/ZonedDateTimeAssert_isBeforeOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/api/zoneddatetime/ZonedDateTimeAssert_isBeforeOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/api/zoneddatetime/ZonedDateTimeAssert_isBeforeOrEqualTo_Test.java
@@ -12,12 +12,11 @@
  */
 package org.assertj.core.api.zoneddatetime;
 
-import static java.lang.String.format;
-import static java.time.ZoneOffset.UTC;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.fail;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.time.ZoneId;
@@ -35,43 +34,31 @@ public class ZonedDateTimeAssert_isBeforeOrEqualTo_Test extends ZonedDateTimeAss
 
   @Test
   public void test_isBeforeOrEqual_assertion() {
-	// WHEN
-	assertThat(BEFORE).isBeforeOrEqualTo(REFERENCE);
-	assertThat(BEFORE).isBeforeOrEqualTo(REFERENCE.toString());
-	assertThat(REFERENCE).isBeforeOrEqualTo(REFERENCE);
-	assertThat(REFERENCE).isBeforeOrEqualTo(REFERENCE.toString());
-	// THEN
-	verify_that_isBeforeOrEqual_assertion_fails_and_throws_AssertionError(AFTER, REFERENCE);
+    // WHEN
+    assertThat(BEFORE).isBeforeOrEqualTo(REFERENCE);
+    assertThat(BEFORE).isBeforeOrEqualTo(REFERENCE.toString());
+    assertThat(REFERENCE).isBeforeOrEqualTo(REFERENCE);
+    assertThat(REFERENCE).isBeforeOrEqualTo(REFERENCE.toString());
+    // THEN
+    verify_that_isBeforeOrEqual_assertion_fails_and_throws_AssertionError(AFTER, REFERENCE);
   }
 
   @Test
   public void isBeforeOrEqualTo_should_compare_datetimes_in_actual_timezone() {
-	ZonedDateTime utcDateTime = ZonedDateTime.of(2013, 6, 10, 0, 0, 0, 0, ZoneOffset.UTC);
-	ZoneId cestTimeZone = ZoneId.of("Europe/Berlin");
-	ZonedDateTime cestDateTime1 = ZonedDateTime.of(2013, 6, 10, 2, 0, 0, 0, cestTimeZone);
-	ZonedDateTime cestDateTime2 = ZonedDateTime.of(2013, 6, 10, 3, 0, 0, 0, cestTimeZone);
-	// utcDateTime = cestDateTime1
-	assertThat(utcDateTime).as("in UTC time zone").isBeforeOrEqualTo(cestDateTime1);
-	// utcDateTime < cestDateTime2
-	assertThat(utcDateTime).as("in UTC time zone").isBeforeOrEqualTo(cestDateTime2);
+    ZonedDateTime utcDateTime = ZonedDateTime.of(2013, 6, 10, 0, 0, 0, 0, ZoneOffset.UTC);
+    ZoneId cestTimeZone = ZoneId.of("Europe/Berlin");
+    ZonedDateTime cestDateTime1 = ZonedDateTime.of(2013, 6, 10, 2, 0, 0, 0, cestTimeZone);
+    ZonedDateTime cestDateTime2 = ZonedDateTime.of(2013, 6, 10, 3, 0, 0, 0, cestTimeZone);
+    // utcDateTime = cestDateTime1
+    assertThat(utcDateTime).as("in UTC time zone").isBeforeOrEqualTo(cestDateTime1);
+    // utcDateTime < cestDateTime2
+    assertThat(utcDateTime).as("in UTC time zone").isBeforeOrEqualTo(cestDateTime2);
   }
 
   @Test
   public void test_isBeforeOrEqual_assertion_error_message() {
-    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(ZonedDateTime.of(2000, 1, 5, 3, 0, 5, 0,
-                                                                                                 UTC)).isBeforeOrEqualTo(ZonedDateTime.of(1998,
-                                                                                                                                          1,
-                                                                                                                                          1,
-                                                                                                                                          3,
-                                                                                                                                          3,
-                                                                                                                                          3,
-                                                                                                                                          0,
-                                                                                                                                          UTC)))
-                                                   .withMessage(format("%n" +
-                                                                       "Expecting:%n" +
-                                                                       "  <2000-01-05T03:00:05Z>%n" +
-                                                                       "to be before or equals to:%n" +
-                                                                       "  <1998-01-01T03:03:03Z>"));
+    assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThat(REFERENCE).isBeforeOrEqualTo(BEFORE))
+                                                   .withMessage(shouldBeBeforeOrEqualTo(REFERENCE, BEFORE).create());
   }
 
   @Test
@@ -95,19 +82,19 @@ public void should_fail_if_dateTime_as_string_parameter_is_null() {
   }
 
   private static void verify_that_isBeforeOrEqual_assertion_fails_and_throws_AssertionError(ZonedDateTime dateToCheck,
-	                                                                                        ZonedDateTime reference) {
-	try {
-	  assertThat(dateToCheck).isBeforeOrEqualTo(reference);
-	} catch (AssertionError e) {
-	  // AssertionError was expected, test same assertion with String based parameter
-	  try {
-		assertThat(dateToCheck).isBeforeOrEqualTo(reference.toString());
-	  } catch (AssertionError e2) {
-		// AssertionError was expected (again)
-		return;
-	  }
-	}
-	fail("Should have thrown AssertionError");
+                                                                                            ZonedDateTime reference) {
+    try {
+      assertThat(dateToCheck).isBeforeOrEqualTo(reference);
+    } catch (AssertionError e) {
+      // AssertionError was expected, test same assertion with String based parameter
+      try {
+        assertThat(dateToCheck).isBeforeOrEqualTo(reference.toString());
+      } catch (AssertionError e2) {
+        // AssertionError was expected (again)
+        return;
+      }
+    }
+    fail("Should have thrown AssertionError");
   }
 
 }
diff --git a/src/test/java/org/assertj/core/error/ShouldBeBeforeOrEqualsTo_create_Test.java b/src/test/java/org/assertj/core/error/ShouldBeAfterOrEqualTo_create_Test.java
similarity index 79%
rename from src/test/java/org/assertj/core/error/ShouldBeBeforeOrEqualsTo_create_Test.java
rename to src/test/java/org/assertj/core/error/ShouldBeAfterOrEqualTo_create_Test.java
--- a/src/test/java/org/assertj/core/error/ShouldBeBeforeOrEqualsTo_create_Test.java
+++ b/src/test/java/org/assertj/core/error/ShouldBeAfterOrEqualTo_create_Test.java
@@ -14,7 +14,7 @@
 
 import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.util.DateUtil.parse;
 
 import org.assertj.core.description.Description;
@@ -25,17 +25,17 @@
 
 /**
  * Tests for
- * <code>{@link ShouldBeBeforeOrEqualsTo#create(Description, org.assertj.core.presentation.Representation)}</code>.
+ * <code>{@link ShouldBeAfterOrEqualTo#create(Description, org.assertj.core.presentation.Representation)}</code>.
  * 
  * @author Joel Costigliola
  */
-public class ShouldBeBeforeOrEqualsTo_create_Test {
+public class ShouldBeAfterOrEqualTo_create_Test {
 
   private ErrorMessageFactory factory;
 
   @BeforeEach
   public void setUp() {
-    factory = shouldBeBeforeOrEqualsTo(parse("2011-01-01"), parse("2012-01-01"));
+    factory = shouldBeAfterOrEqualTo(parse("2011-01-01"), parse("2012-01-01"));
   }
 
   @Test
@@ -44,7 +44,7 @@ public void should_create_error_message() {
     assertThat(message).isEqualTo(format("[Test] %n" +
                                          "Expecting:%n" +
                                          "  <2011-01-01T00:00:00.000>%n" +
-                                         "to be before or equals to:%n" +
+                                         "to be after or equal to:%n" +
                                          "  <2012-01-01T00:00:00.000>"));
   }
 }
diff --git a/src/test/java/org/assertj/core/error/ShouldBeAfterOrEqualsTo_create_Test.java b/src/test/java/org/assertj/core/error/ShouldBeBeforeOrEqualTo_create_Test.java
similarity index 83%
rename from src/test/java/org/assertj/core/error/ShouldBeAfterOrEqualsTo_create_Test.java
rename to src/test/java/org/assertj/core/error/ShouldBeBeforeOrEqualTo_create_Test.java
--- a/src/test/java/org/assertj/core/error/ShouldBeAfterOrEqualsTo_create_Test.java
+++ b/src/test/java/org/assertj/core/error/ShouldBeBeforeOrEqualTo_create_Test.java
@@ -14,7 +14,7 @@
 
 import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.util.DateUtil.parse;
 
 import org.assertj.core.description.Description;
@@ -25,17 +25,17 @@
 
 /**
  * Tests for
- * <code>{@link ShouldBeAfterOrEqualsTo#create(Description, org.assertj.core.presentation.Representation)}</code>.
+ * <code>{@link ShouldBeBeforeOrEqualTo#create(Description, org.assertj.core.presentation.Representation)}</code>.
  * 
  * @author Joel Costigliola
  */
-public class ShouldBeAfterOrEqualsTo_create_Test {
+public class ShouldBeBeforeOrEqualTo_create_Test {
 
   private ErrorMessageFactory factory;
 
   @BeforeEach
   public void setUp() {
-    factory = shouldBeAfterOrEqualsTo(parse("2011-01-01"), parse("2012-01-01"));
+    factory = shouldBeBeforeOrEqualTo(parse("2011-01-01"), parse("2012-01-01"));
   }
 
   @Test
@@ -44,7 +44,7 @@ public void should_create_error_message() {
     assertThat(message).isEqualTo(format("[Test] %n" +
                                          "Expecting:%n" +
                                          "  <2011-01-01T00:00:00.000>%n" +
-                                         "to be after or equals to:%n" +
+                                         "to be before or equal to:%n" +
                                          "  <2012-01-01T00:00:00.000>"));
   }
 }
diff --git a/src/test/java/org/assertj/core/internal/dates/Dates_assertIsAfterOrEqualTo_Test.java b/src/test/java/org/assertj/core/internal/dates/Dates_assertIsAfterOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/internal/dates/Dates_assertIsAfterOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/internal/dates/Dates_assertIsAfterOrEqualTo_Test.java
@@ -14,7 +14,7 @@
 
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatNullPointerException;
-import static org.assertj.core.error.ShouldBeAfterOrEqualsTo.shouldBeAfterOrEqualsTo;
+import static org.assertj.core.error.ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo;
 import static org.assertj.core.internal.ErrorMessages.dateToCompareActualWithIsNull;
 import static org.assertj.core.test.TestData.someInfo;
 import static org.assertj.core.test.TestFailures.failBecauseExpectedAssertionErrorWasNotThrown;
@@ -24,6 +24,7 @@
 import java.util.Date;
 
 import org.assertj.core.api.AssertionInfo;
+import org.assertj.core.error.ShouldBeAfterOrEqualTo;
 import org.assertj.core.internal.Dates;
 import org.assertj.core.internal.DatesBaseTest;
 import org.junit.jupiter.api.Test;
@@ -43,7 +44,7 @@ public void should_fail_if_actual_is_not_strictly_after_given_date() {
     try {
       dates.assertIsAfterOrEqualTo(info, actual, other);
     } catch (AssertionError e) {
-      verify(failures).failure(info, shouldBeAfterOrEqualsTo(actual, other));
+      verify(failures).failure(info, shouldBeAfterOrEqualTo(actual, other));
       return;
     }
     failBecauseExpectedAssertionErrorWasNotThrown();
@@ -78,7 +79,7 @@ public void should_fail_if_actual_is_not_strictly_after_given_date_according_to_
     try {
       datesWithCustomComparisonStrategy.assertIsAfterOrEqualTo(info, actual, other);
     } catch (AssertionError e) {
-      verify(failures).failure(info, shouldBeAfterOrEqualsTo(actual, other, yearAndMonthComparisonStrategy));
+      verify(failures).failure(info, ShouldBeAfterOrEqualTo.shouldBeAfterOrEqualTo(actual, other, yearAndMonthComparisonStrategy));
       return;
     }
     failBecauseExpectedAssertionErrorWasNotThrown();
diff --git a/src/test/java/org/assertj/core/internal/dates/Dates_assertIsBeforeOrEqualTo_Test.java b/src/test/java/org/assertj/core/internal/dates/Dates_assertIsBeforeOrEqualTo_Test.java
--- a/src/test/java/org/assertj/core/internal/dates/Dates_assertIsBeforeOrEqualTo_Test.java
+++ b/src/test/java/org/assertj/core/internal/dates/Dates_assertIsBeforeOrEqualTo_Test.java
@@ -14,7 +14,7 @@
 
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatNullPointerException;
-import static org.assertj.core.error.ShouldBeBeforeOrEqualsTo.shouldBeBeforeOrEqualsTo;
+import static org.assertj.core.error.ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo;
 import static org.assertj.core.internal.ErrorMessages.dateToCompareActualWithIsNull;
 import static org.assertj.core.test.TestData.someInfo;
 import static org.assertj.core.test.TestFailures.failBecauseExpectedAssertionErrorWasNotThrown;
@@ -24,6 +24,7 @@
 import java.util.Date;
 
 import org.assertj.core.api.AssertionInfo;
+import org.assertj.core.error.ShouldBeBeforeOrEqualTo;
 import org.assertj.core.internal.Dates;
 import org.assertj.core.internal.DatesBaseTest;
 import org.junit.jupiter.api.Test;
@@ -43,7 +44,7 @@ public void should_fail_if_actual_is_not_strictly_before_given_date() {
     try {
       dates.assertIsBeforeOrEqualTo(info, actual, other);
     } catch (AssertionError e) {
-      verify(failures).failure(info, shouldBeBeforeOrEqualsTo(actual, other));
+      verify(failures).failure(info, shouldBeBeforeOrEqualTo(actual, other));
       return;
     }
     failBecauseExpectedAssertionErrorWasNotThrown();
@@ -78,7 +79,7 @@ public void should_fail_if_actual_is_not_strictly_before_given_date_according_to
     try {
       datesWithCustomComparisonStrategy.assertIsBeforeOrEqualTo(info, actual, other);
     } catch (AssertionError e) {
-      verify(failures).failure(info, shouldBeBeforeOrEqualsTo(actual, other, yearAndMonthComparisonStrategy));
+      verify(failures).failure(info, ShouldBeBeforeOrEqualTo.shouldBeBeforeOrEqualTo(actual, other, yearAndMonthComparisonStrategy));
       return;
     }
     failBecauseExpectedAssertionErrorWasNotThrown();

Typo in AbstractDateAssert#isBeforeOrEqualsTo method name?
#### Summary
`AbstractDateAssert#isBeforeOrEqualsTo` has a trailing 's' in 'Equals' and it looks like a typo compared to java 8 time assertions (same for `AbstractDateAssert#isAfterOrEqualsTo`). It is just a style issue and fixing it would be a backwards incompatible change.

Also `org.assertj.core.error.ShouldBeBeforeOrEqualsTo` and `org.assertj.core.error.ShouldBeAfterOrEqualsTo` have the same flaw.

#### Example

```java
assertThat(new Date).isBeforeOrEqualsTo(anotherDate)
assertThat(Instant.now()).isBeforeOrEqualTo(anotherInstant)
```


Yeah, good catch :man_facepalming: .

The way to go is is deprecate `isBeforeOrEqualsTo` / `isAfterOrEqualsTo` and add  `isBeforeOrEqualTo` / `isAfterOrEqualTo`. For the other typos a rename refactoring will do.