Fix formatting and tests improvements

src/main/java/org/assertj/core/api/Assertions.java

@@ -92,30 +92,18 @@
  */
 public class Assertions {
 
-
   /**
    * Create assertion for {@link java.util.Optional}.
    *
    * @param optional the actual value.
-   * @param <T>      the type of the value contained in the {@link java.util.Optional}.
+   * @param <T> the type of the value contained in the {@link java.util.Optional}.
    *
    * @return the created assertion object.
    */
   public static <T> OptionalAssert<T> assertThat(Optional<T> optional) {
     return new OptionalAssert<>(optional);
   }
 
-  /**
-   * Create assertion for {@link java.time.OffsetTime}.
-   *
-   * @param offsetTime the actual value.
-   *
-   * @return the created assertion object.
-   */
-  public static OffsetTimeAssert assertThat(OffsetTime offsetTime) {
-      return new OffsetTimeAssert(offsetTime);
-  }
-
   /**
    * Create assertion for {@link java.util.OptionalDouble}.
    *
@@ -124,7 +112,7 @@ public static OffsetTimeAssert assertThat(OffsetTime offsetTime) {
    * @return the created assertion object.
    */
   public static OptionalDoubleAssert assertThat(OptionalDouble optionalDouble) {
-      return new OptionalDoubleAssert(optionalDouble);
+    return new OptionalDoubleAssert(optionalDouble);
   }
 
   /**
@@ -135,7 +123,7 @@ public static OptionalDoubleAssert assertThat(OptionalDouble optionalDouble) {
    * @return the created assertion object.
    */
   public static OptionalIntAssert assertThat(OptionalInt optionalInt) {
-      return new OptionalIntAssert(optionalInt);
+    return new OptionalIntAssert(optionalInt);
   }
 
   /**
@@ -146,10 +134,10 @@ public static OptionalIntAssert assertThat(OptionalInt optionalInt) {
    * @return the created assertion object.
    */
   public static OptionalLongAssert assertThat(OptionalLong optionalLong) {
-        return new OptionalLongAssert(optionalLong);
-    }
+    return new OptionalLongAssert(optionalLong);
+  }
 
-    /**
+  /**
    * Creates a new instance of <code>{@link BigDecimalAssert}</code>.
    *
    * @param actual the actual value.
@@ -360,7 +348,7 @@ public static AbstractFileAssert<?> assertThat(File actual) {
    * @param actual the path to test
    * @return the created assertion object
    */
-  public static AbstractPathAssert<?> assertThat(Path actual)  {
+  public static AbstractPathAssert<?> assertThat(Path actual) {
     return new PathAssert(actual);
   }
 
@@ -670,29 +658,39 @@ public static AbstractLocalDateTimeAssert<?> assertThat(LocalDateTime localDateT
    * @return the created assertion object.
    */
   public static AbstractOffsetDateTimeAssert<?> assertThat(OffsetDateTime actual) {
-      return new OffsetDateTimeAssert(actual);
+    return new OffsetDateTimeAssert(actual);
   }
-
+
+  /**
+   * Create assertion for {@link java.time.OffsetTime}.
+   *
+   * @param actual the actual value.
+   * @return the created assertion object.
+   */
+  public static AbstractOffsetTimeAssert<?> assertThat(OffsetTime offsetTime) {
+    return new OffsetTimeAssert(offsetTime);
+  }
+
   /**
    * Creates a new instance of <code>{@link LocalTimeAssert}</code>.
    *
    * @param actual the actual value.
    * @return the created assertion object.
    */
   public static AbstractLocalTimeAssert<?> assertThat(LocalTime actual) {
-	return new LocalTimeAssert(actual);
+    return new LocalTimeAssert(actual);
   }
-  
+
   /**
    * Creates a new instance of <code>{@link LocalDateAssert}</code>.
    *
    * @param localDate the actual value.
    * @return the created assertion object.
    */
   public static AbstractLocalDateAssert<?> assertThat(LocalDate localDate) {
-	return new LocalDateAssert(localDate);
+    return new LocalDateAssert(localDate);
   }
-  
+
   /**
    * Creates a new instance of <code>{@link ThrowableAssert}</code>.
    *

src/test/java/org/assertj/core/api/Assertions_assertThat_with_OffsetTime_Test.java

@@ -36,13 +36,13 @@ public void before() {
 
   @Test
   public void should_create_Assert() {
-    OffsetTimeAssert assertions = Assertions.assertThat(actual);
+    AbstractOffsetTimeAssert<?> assertions = Assertions.assertThat(actual);
     assertNotNull(assertions);
   }
 
   @Test
   public void should_pass_actual() {
-    OffsetTimeAssert assertions = Assertions.assertThat(actual);
+    AbstractOffsetTimeAssert<?> assertions = Assertions.assertThat(actual);
     assertSame(actual, assertions.actual);
   }
 }

src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssertBaseTest.java

@@ -41,10 +41,11 @@ public class OffsetDateTimeAssertBaseTest extends BaseTest {
   @DataPoint
   public static OffsetDateTime offsetDateTime6 = OffsetDateTime.of(2000, 12, 14, 22, 15, 15, 876, ZoneOffset.UTC);
 
-  protected static void testAssumptions(OffsetDateTime reference, OffsetDateTime dateBefore,
-                                        OffsetDateTime dateAfter) {
-    assumeTrue(dateBefore.isBefore(reference));
-    assumeTrue(dateAfter.isAfter(reference));
+  protected static void testAssumptions(OffsetDateTime reference, OffsetDateTime before, OffsetDateTime equal,
+                                        OffsetDateTime after) {
+    assumeTrue(before.isBefore(reference));
+    assumeTrue(equal.isEqual(reference));
+    assumeTrue(after.isAfter(reference));
   }
 
 }

src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isAfterOrEqualTo_Test.java

@@ -12,6 +12,7 @@
  */
 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;
@@ -34,27 +35,29 @@
 public class OffsetDateTimeAssert_isAfterOrEqualTo_Test extends OffsetDateTimeAssertBaseTest {
 
   @Theory
-  public void test_isAfterOrEqual_assertion(OffsetDateTime referenceDate, OffsetDateTime dateBefore,
+  public void test_isAfterOrEqual_assertion(OffsetDateTime reference, OffsetDateTime dateBefore, OffsetDateTime dateEqual,
                                             OffsetDateTime dateAfter) {
     // GIVEN
-    testAssumptions(referenceDate, dateBefore, dateAfter);
+    testAssumptions(reference, dateBefore, dateEqual, dateAfter);
     // WHEN
-    assertThat(dateAfter).isAfterOrEqualTo(referenceDate);
-    assertThat(referenceDate).isAfterOrEqualTo(referenceDate);
+    assertThat(dateAfter).isAfterOrEqualTo(reference);
+    assertThat(dateAfter).isAfterOrEqualTo(reference.toString());
+    assertThat(dateEqual).isAfterOrEqualTo(reference);
+    assertThat(dateEqual).isAfterOrEqualTo(reference.toString());
     // THEN
-    verify_that_isAfterOrEqual_assertion_fails_and_throws_AssertionError(dateBefore, referenceDate);
+    verify_that_isAfterOrEqual_assertion_fails_and_throws_AssertionError(dateBefore, reference);
   }
 
   @Test
   public void test_isAfterOrEqual_assertion_error_message() {
     try {
       assertThat(of(2000, 1, 5, 3, 0, 5, 0, UTC)).isAfterOrEqualTo(of(2012, 1, 1, 3, 3, 3, 0, UTC));
     } catch (AssertionError e) {
-      assertThat(e).hasMessage("\n" +
-                               "Expecting:\n" +
-                               "  <2000-01-05T03:00:05Z>\n" +
-                               "to be after or equals to:\n" +
-                               "  <2012-01-01T03:03:03Z>");
+      assertThat(e).hasMessage(format("%n" +
+                               "Expecting:%n" +
+                               "  <2000-01-05T03:00:05Z>%n" +
+                               "to be after or equals to:%n" +
+                                      "  <2012-01-01T03:03:03Z>"));
       return;
     }
     fail("Should have thrown AssertionError");

src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isAfter_Test.java

@@ -12,6 +12,7 @@
  */
 package org.assertj.core.api.offsetdatetime;
 
+import static java.lang.String.format;
 import static java.time.OffsetDateTime.parse;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
@@ -33,9 +34,10 @@
 public class OffsetDateTimeAssert_isAfter_Test extends OffsetDateTimeAssertBaseTest {
 
   @Theory
-  public void test_isAfter_assertion(OffsetDateTime referenceDate, OffsetDateTime dateBefore, OffsetDateTime dateAfter) {
+  public void test_isAfter_assertion(OffsetDateTime referenceDate, OffsetDateTime dateBefore, OffsetDateTime dateEqual,
+                                     OffsetDateTime dateAfter) {
     // GIVEN
-    testAssumptions(referenceDate, dateBefore, dateAfter);
+    testAssumptions(referenceDate, dateBefore, dateEqual, dateAfter);
     // WHEN
     assertThat(dateAfter).isAfter(referenceDate);
     assertThat(dateAfter).isAfter(referenceDate.toString());
@@ -49,11 +51,11 @@ public void test_isAfter_assertion_error_message() {
     try {
       assertThat(parse("2000-01-01T03:00:05.123Z")).isAfter(parse("2000-01-01T03:00:05.123456789Z"));
     } catch (AssertionError e) {
-      assertThat(e).hasMessage("\n" +
-                               "Expecting:\n" +
-                               "  <2000-01-01T03:00:05.123Z>\n" +
-                               "to be strictly after:\n" +
-                               "  <2000-01-01T03:00:05.123456789Z>");
+      assertThat(e).hasMessage(format("%n" +
+                               "Expecting:%n" +
+                               "  <2000-01-01T03:00:05.123Z>%n" +
+                               "to be strictly after:%n" +
+                                      "  <2000-01-01T03:00:05.123456789Z>"));
       return;
     }
     fail("Should have thrown AssertionError");

src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isBeforeOrEqualTo_Test.java

@@ -12,6 +12,7 @@
  */
 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;
@@ -34,24 +35,28 @@
 public class OffsetDateTimeAssert_isBeforeOrEqualTo_Test extends OffsetDateTimeAssertBaseTest {
 
   @Theory
-  public void test_isBeforeOrEqual_assertion(OffsetDateTime referenceDate, OffsetDateTime dateBefore,
-                                             OffsetDateTime dateAfter) {
+  public void test_isBeforeOrEqual_assertion(OffsetDateTime reference, OffsetDateTime dateBefore,
+                                             OffsetDateTime dateEqual, OffsetDateTime dateAfter) {
     // GIVEN
-    testAssumptions(referenceDate, dateBefore, dateAfter);
+    testAssumptions(reference, dateBefore, dateEqual, dateAfter);
     // WHEN
-    assertThat(dateBefore).isBeforeOrEqualTo(referenceDate);
-    assertThat(referenceDate).isBeforeOrEqualTo(referenceDate);
+    assertThat(dateBefore).isBeforeOrEqualTo(reference);
+    assertThat(dateBefore).isBeforeOrEqualTo(reference.toString());
+    assertThat(dateEqual).isBeforeOrEqualTo(reference);
+    assertThat(dateEqual).isBeforeOrEqualTo(reference.toString());
     // THEN
-    verify_that_isBeforeOrEqual_assertion_fails_and_throws_AssertionError(dateAfter, referenceDate);
+    verify_that_isBeforeOrEqual_assertion_fails_and_throws_AssertionError(dateAfter, reference);
   }
 
   @Test
   public void test_isBeforeOrEqual_assertion_error_message() {
     try {
       assertThat(of(2000, 1, 5, 3, 0, 5, 0, UTC)).isBeforeOrEqualTo(of(1998, 1, 1, 3, 3, 3, 0, UTC));
     } catch (AssertionError e) {
-      assertThat(e).hasMessage(
-                               "\nExpecting:\n  <2000-01-05T03:00:05Z>\nto be before or equals to:\n  <1998-01-01T03:03:03Z>");
+      assertThat(e).hasMessage(format("%nExpecting:%n" +
+                                      "  <2000-01-05T03:00:05Z>%n" +
+                                      "to be before or equals to:%n" +
+                                      "  <1998-01-01T03:03:03Z>"));
       return;
     }
     fail("Should have thrown AssertionError");

src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isBefore_Test.java

@@ -12,6 +12,7 @@
  */
 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;
@@ -34,22 +35,27 @@
 public class OffsetDateTimeAssert_isBefore_Test extends OffsetDateTimeAssertBaseTest {
 
   @Theory
-  public void test_isBefore_assertion(OffsetDateTime referenceDate, OffsetDateTime dateBefore, OffsetDateTime dateAfter) {
+  public void test_isBefore_assertion(OffsetDateTime reference, OffsetDateTime dateBefore, OffsetDateTime dateEqual,
+                                      OffsetDateTime dateAfter) {
     // GIVEN
-    testAssumptions(referenceDate, dateBefore, dateAfter);
+    testAssumptions(reference, dateBefore, dateEqual, dateAfter);
     // WHEN
-    assertThat(dateBefore).isBefore(referenceDate);
+    assertThat(dateBefore).isBefore(reference);
+    assertThat(dateBefore).isBefore(reference.toString());
     // THEN
-    verify_that_isBefore_assertion_fails_and_throws_AssertionError(referenceDate, referenceDate);
-    verify_that_isBefore_assertion_fails_and_throws_AssertionError(dateAfter, referenceDate);
+    verify_that_isBefore_assertion_fails_and_throws_AssertionError(reference, reference);
+    verify_that_isBefore_assertion_fails_and_throws_AssertionError(dateAfter, reference);
   }
 
   @Test
   public void test_isBefore_assertion_error_message() {
     try {
       assertThat(of(2000, 1, 5, 3, 0, 5, 0, UTC)).isBefore(of(1998, 1, 1, 3, 3, 3, 0, UTC));
     } catch (AssertionError e) {
-      assertThat(e).hasMessage("\nExpecting:\n  <2000-01-05T03:00:05Z>\nto be strictly before:\n  <1998-01-01T03:03:03Z>");
+      assertThat(e).hasMessage(format("%nExpecting:%n" +
+                                      "  <2000-01-05T03:00:05Z>%n" +
+                                      "to be strictly before:%n" +
+                                      "  <1998-01-01T03:03:03Z>"));
       return;
     }
     fail("Should have thrown AssertionError");

src/test/java/org/assertj/core/api/offsetdatetime/OffsetDateTimeAssert_isEqualToIgnoringHours_Test.java

@@ -12,6 +12,7 @@
  */
 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.AbstractOffsetDateTimeAssert.NULL_OFFSET_DATE_TIME_PARAMETER_MESSAGE;
@@ -37,9 +38,11 @@ public void should_fail_if_actual_is_not_equal_to_given_offsetdatetime_with_hour
     try {
       assertThat(refOffsetDateTime).isEqualToIgnoringHours(refOffsetDateTime.minusHours(1));
     } catch (AssertionError e) {
-      assertThat(e.getMessage())
-                                .isEqualTo(
-                                           "\nExpecting:\n  <2000-01-02T00:00Z>\nto have same year, month and day as:\n  <2000-01-01T23:00Z>\nbut had not.");
+      assertThat(e).hasMessage(format("%n" +
+                                      "Expecting:%n" +
+                                      "  <2000-01-02T00:00Z>%n" +
+                                      "to have same year, month and day as:%n" +
+                                      "  <2000-01-01T23:00Z>%nbut had not."));
       return;
     }
     failBecauseExpectedAssertionErrorWasNotThrown();
@@ -50,9 +53,12 @@ public void should_fail_as_hours_fields_are_different_even_if_time_difference_is
     try {
       assertThat(refOffsetDateTime).isEqualToIgnoringHours(refOffsetDateTime.minusNanos(1));
     } catch (AssertionError e) {
-      assertThat(e.getMessage())
-                                .isEqualTo(
-                                           "\nExpecting:\n  <2000-01-02T00:00Z>\nto have same year, month and day as:\n  <2000-01-01T23:59:59.999999999Z>\nbut had not.");
+      assertThat(e).hasMessage(format("%n" +
+                                      "Expecting:%n" +
+                                      "  <2000-01-02T00:00Z>%n" +
+                                      "to have same year, month and day as:%n" +
+                                      "  <2000-01-01T23:59:59.999999999Z>%n" +
+                                      "but had not."));
       return;
     }
     failBecauseExpectedAssertionErrorWasNotThrown();