Support formatting overloads in more AbstractThrowableAssert methods.

Fixes assertj#1502
filiphr · Sep 21, 2019 · b9074a6 · b9074a6
1 parent c867a15
commit b9074a6
Show file tree

Hide file tree

Showing 14 changed files with 431 additions and 23 deletions.
diff --git a/src/main/java/org/assertj/core/api/AbstractThrowableAssert.java b/src/main/java/org/assertj/core/api/AbstractThrowableAssert.java
@@ -12,6 +12,7 @@
  */
 package org.assertj.core.api;
 
+import static java.lang.String.format;
 import static org.assertj.core.error.ShouldNotHaveThrown.shouldNotHaveThrown;
 
 import java.util.IllegalFormatException;
@@ -91,7 +92,7 @@ public SELF hasMessage(String message) {
    * @throws IllegalFormatException if the message contains an illegal syntax according to {@link String#format(String, Object...)}.
    */
   public SELF hasMessage(String message, Object... parameters) {
-    return hasMessage(String.format(message, parameters));
+    return hasMessage(format(message, parameters));
   }
 
   /**
@@ -159,6 +160,15 @@ public SELF hasNoCause() {
 
   /**
    * Verifies that the message of the actual {@code Throwable} starts with the given description.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
+   *
+   * // assertion will pass:
+   * assertThat(throwableWithMessage).hasMessageStartingWith("wrong amount");
+   *
+   * // assertions will fail:
+   * assertThat(throwableWithMessage).hasMessageStartingWith("right amount"); </code></pre>
    *
    * @param description the description expected to start the actual {@code Throwable}'s message.
    * @return this assertion object.
@@ -170,6 +180,31 @@ public SELF hasMessageStartingWith(String description) {
     return myself;
   }
 
+  /**
+   * Verifies that the message of the actual {@code Throwable} starts with the given description, after being formatted using
+   * the {@link String#format} method.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
+   *
+   * // assertion will pass:
+   * assertThat(throwableWithMessage).hasMessageStartingWith("%s amount", "wrong");
+   *
+   * // assertions will fail:
+   * assertThat(throwableWithMessage).hasMessageStartingWith("%s amount", "right"); </code></pre>
+   *
+   * @param description the description expected to start the actual {@code Throwable}'s message.
+   * @param parameters argument referenced by the format specifiers in the format string
+   * @return this assertion object.
+   * @throws AssertionError if the actual {@code Throwable} is {@code null}.
+   * @throws AssertionError if the message of the actual {@code Throwable} does not start with the given description.
+   * @throws IllegalFormatException if the message contains an illegal syntax according to {@link String#format(String, Object...)}.
+   */
+  public SELF hasMessageStartingWith(String description, Object... parameters) {
+    throwables.assertHasMessageStartingWith(info, actual, format(description, parameters));
+    return myself;
+  }
+
   /**
    * Verifies that the message of the actual {@code Throwable} contains the given description.
    * <p>
@@ -194,6 +229,33 @@ public SELF hasMessageContaining(String description) {
     return myself;
   }
 
+  /**
+   * Verifies that the message of the actual {@code Throwable} contains the given description, after being formatted using
+   * the {@link String#format} method.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
+   * Throwable throwableWithoutMessage = new IllegalArgumentException();
+   *
+   * // assertion will pass:
+   * assertThat(throwableWithMessage).hasMessageContaining("amount %d", 123);
+   *
+   * // assertions will fail:
+   * assertThat(throwableWithoutMessage).hasMessageContaining("amount %d", 123);
+   * assertThat(throwableWithMessage).hasMessageContaining("%s amount", "right"); </code></pre>
+   *
+   * @param description the description expected to be contained in the actual {@code Throwable}'s message.
+   * @param parameters argument referenced by the format specifiers in the format string
+   * @return this assertion object.
+   * @throws AssertionError if the actual {@code Throwable} is {@code null}.
+   * @throws AssertionError if the message of the actual {@code Throwable} does not contain the given description.
+   * @throws IllegalFormatException if the message contains an illegal syntax according to {@link String#format(String, Object...)}.
+   */
+  public SELF hasMessageContaining(String description, Object... parameters) {
+    throwables.assertHasMessageContaining(info, actual, format(description, parameters));
+    return myself;
+  }
+
   /**
    * Verifies that the message of the actual {@code Throwable} contains all the given values.
    * <p>
@@ -270,6 +332,15 @@ public SELF hasMessageNotContainingAny(CharSequence... values) {
 
   /**
    * Verifies that the stack trace of the actual {@code Throwable} contains the given description.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
+   *
+   * // assertion will pass
+   * assertThat(throwableWithMessage).hasStackTraceContaining("amount 123");
+   *
+   * // assertion will fail
+   * assertThat(throwableWithMessage).hasStackTraceContaining("456");</code></pre>
    *
    * @param description the description expected to be contained in the actual {@code Throwable}'s stack trace.
    * @return this assertion object.
@@ -281,6 +352,31 @@ public SELF hasStackTraceContaining(String description) {
     return myself;
   }
 
+  /**
+   * Verifies that the stack trace of the actual {@code Throwable} contains the given description, after being formatted using
+   * the {@link String#format} method.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
+   *
+   * // assertion will pass
+   * assertThat(throwableWithMessage).hasStackTraceContaining("%s", amount);
+   *
+   * // assertion will fail
+   * assertThat(throwableWithMessage).hasStackTraceContaining("%d", 456);</code></pre>
+   *
+   * @param description the description expected to be contained in the actual {@code Throwable}'s stack trace.
+   * @param parameters argument referenced by the format specifiers in the format string
+   * @return this assertion object.
+   * @throws AssertionError if the actual {@code Throwable} is {@code null}.
+   * @throws AssertionError if the stack trace of the actual {@code Throwable} does not contain the given description.
+   * @throws IllegalFormatException if the message contains an illegal syntax according to {@link String#format(String, Object...)}.
+   */
+  public SELF hasStackTraceContaining(String description, Object... parameters) {
+    throwables.assertHasStackTraceContaining(info, actual, format(description, parameters));
+    return myself;
+  }
+
   /**
    * Verifies that the message of the actual {@code Throwable} matches the given regular expression.
    * <p>
@@ -334,6 +430,15 @@ public SELF hasMessageFindingMatch(String regex) {
 
   /**
    * Verifies that the message of the actual {@code Throwable} ends with the given description.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
+   *
+   * // assertion will pass
+   * assertThat(throwableWithMessage).hasMessageEndingWith("123");
+   *
+   * // assertion will fail
+   * assertThat(throwableWithMessage).hasMessageEndingWith("456");</code></pre>
    *
    * @param description the description expected to end the actual {@code Throwable}'s message.
    * @return this assertion object.
@@ -345,6 +450,31 @@ public SELF hasMessageEndingWith(String description) {
     return myself;
   }
 
+  /**
+   * Verifies that the message of the actual {@code Throwable} ends with the given description, after being formatted using
+   * the {@link String#format} method.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
+   *
+   * // assertion will pass
+   * assertThat(throwableWithMessage).hasMessageEndingWith("%s 123", "amount");
+   *
+   * // assertion will fail
+   * assertThat(throwableWithMessage).hasMessageEndingWith("amount %d", 456);</code></pre>
+   *
+   * @param description the description expected to end the actual {@code Throwable}'s message.
+   * @param parameters argument referenced by the format specifiers in the format string
+   * @return this assertion object.
+   * @throws AssertionError if the actual {@code Throwable} is {@code null}.
+   * @throws AssertionError if the message of the actual {@code Throwable} does not end with the given description.
+   * @throws IllegalFormatException if the message contains an illegal syntax according to {@link String#format(String, Object...)}.
+   */
+  public SELF hasMessageEndingWith(String description, Object... parameters) {
+    throwables.assertHasMessageEndingWith(info, actual, format(description, parameters));
+    return myself;
+  }
+
   /**
    * Verifies that the cause of the actual {@code Throwable} is an instance of the given type.
    * <p>

diff --git a/src/main/java/org/assertj/core/api/ThrowableAssertAlternative.java b/src/main/java/org/assertj/core/api/ThrowableAssertAlternative.java
@@ -12,6 +12,7 @@
  */
 package org.assertj.core.api;
 
+import java.util.IllegalFormatException;
 import org.assertj.core.description.Description;
 import org.assertj.core.util.CheckReturnValue;
 
@@ -181,6 +182,36 @@ public ThrowableAssertAlternative<T> withMessageStartingWith(String description)
     return this;
   }
 
+  /**
+   * Verifies that the message of the actual {@code Throwable} starts with the given description, after being formatted using
+   * the {@link String#format} method.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");
+   *
+   * // assertion will pass
+   * assertThatExceptionOfType(Throwable.class)
+   *           .isThrownBy(() -&gt; {throw illegalArgumentException;})
+   *           .withMessageStartingWith("%s amount", "wrong");
+   *
+   * // assertion will fail
+   * assertThatExceptionOfType(Throwable.class)
+   *           .isThrownBy(() -&gt; {throw illegalArgumentException;})
+   *           .withMessageStartingWith("%s amount", "right");</code></pre>
+   *
+   * @param description the description expected to start the actual {@code Throwable}'s message.
+   * @param parameters argument referenced by the format specifiers in the format string
+   * @return this assertion object.
+   * @throws AssertionError if the actual {@code Throwable} is {@code null}.
+   * @throws AssertionError if the message of the actual {@code Throwable} does not start with the given description.
+   * @throws IllegalFormatException if the message contains an illegal syntax according to {@link String#format(String, Object...)}.
+   * @see AbstractThrowableAssert#hasMessageStartingWith(String, Object...)
+   */
+  public ThrowableAssertAlternative<T> withMessageStartingWith(String description, Object... parameters) {
+    delegate.hasMessageStartingWith(description, parameters);
+    return this;
+  }
+
   /**
    * Verifies that the message of the actual {@code Throwable} contains the given description.
    * <p>
@@ -208,6 +239,36 @@ public ThrowableAssertAlternative<T> withMessageContaining(String description) {
     return this;
   }
 
+  /**
+   * Verifies that the message of the actual {@code Throwable} contains the given description, after being formatted using
+   * the {@link String#format} method.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");
+   *
+   * // assertion will pass
+   * assertThatExceptionOfType(Throwable.class)
+   *           .isThrownBy(() -&gt; {throw illegalArgumentException;})
+   *           .withMessageContaining("%s", amount);
+   *
+   * // assertion will fail
+   * assertThatExceptionOfType(Throwable.class)
+   *           .isThrownBy(() -&gt; {throw illegalArgumentException;})
+   *           .withMessageContaining("%d", 456);</code></pre>
+   *
+   * @param description the description expected to be contained in the actual {@code Throwable}'s message.
+   * @param parameters argument referenced by the format specifiers in the format string
+   * @return this assertion object.
+   * @throws AssertionError if the actual {@code Throwable} is {@code null}.
+   * @throws AssertionError if the message of the actual {@code Throwable} does not contain the given description.
+   * @throws IllegalFormatException if the message contains an illegal syntax according to {@link String#format(String, Object...)}.
+   * @see AbstractThrowableAssert#hasMessageContaining(String, Object...)
+   */
+  public ThrowableAssertAlternative<T> withMessageContaining(String description, Object... parameters) {
+    delegate.hasMessageContaining(description, parameters);
+    return this;
+  }
+
   /**
    * Verifies that the message of the actual {@code Throwable} contains all the given values.
    * <p>
@@ -320,6 +381,36 @@ public ThrowableAssertAlternative<T> withStackTraceContaining(String description
     return this;
   }
 
+  /**
+   * Verifies that the stack trace of the actual {@code Throwable} contains with the given description, after being formatted using
+   * the {@link String#format} method.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");
+   *
+   * // assertion will pass
+   * assertThatExceptionOfType(Throwable.class)
+   *           .isThrownBy(() -&gt; {throw illegalArgumentException;})
+   *           .withStackTraceContaining("%s", amount);
+   *
+   * // assertion will fail
+   * assertThatExceptionOfType(Throwable.class)
+   *           .isThrownBy(() -&gt; {throw illegalArgumentException;})
+   *           .withStackTraceContaining("%d", 456);</code></pre>
+   *
+   * @param description the description expected to be contained in the actual {@code Throwable}'s stack trace.
+   * @param parameters argument referenced by the format specifiers in the format string
+   * @return this assertion object.
+   * @throws AssertionError if the actual {@code Throwable} is {@code null}.
+   * @throws AssertionError if the stack trace of the actual {@code Throwable} does not contain the given description.
+   * @throws IllegalFormatException if the message contains an illegal syntax according to {@link String#format(String, Object...)}.
+   * @see AbstractThrowableAssert#hasStackTraceContaining(String, Object...)
+   */
+  public ThrowableAssertAlternative<T> withStackTraceContaining(String description, Object... parameters) {
+    delegate.hasStackTraceContaining(description, parameters);
+    return this;
+  }
+
   /**
    * Verifies that the message of the actual {@code Throwable} matches with the given regular expression.
    * <p>
@@ -375,6 +466,36 @@ public ThrowableAssertAlternative<T> withMessageEndingWith(String description) {
     return this;
   }
 
+  /**
+   * Verifies that the message of the actual {@code Throwable} ends with the given description, after being formatted using
+   * the {@link String#format} method.
+   * <p>
+   * Examples:
+   * <pre><code class='java'> Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");
+   *
+   * // assertion will pass
+   * assertThatExceptionOfType(Throwable.class)
+   *           .isThrownBy(() -&gt; {throw illegalArgumentException;})
+   *           .withMessageEndingWith("%d", 123);
+   *
+   * // assertion will fail
+   * assertThatExceptionOfType(Throwable.class)
+   *           .isThrownBy(() -&gt; {throw illegalArgumentException;})
+   *           .withMessageEndingWith("%d", 456);</code></pre>
+   *
+   * @param description the description expected to end the actual {@code Throwable}'s message.
+   * @param parameters argument referenced by the format specifiers in the format string
+   * @return this assertion object.
+   * @throws AssertionError if the actual {@code Throwable} is {@code null}.
+   * @throws AssertionError if the message of the actual {@code Throwable} does not end with the given description.
+   * @throws IllegalFormatException if the message contains an illegal syntax according to {@link String#format(String, Object...)}.
+   * @see AbstractThrowableAssert#hasMessageEndingWith(String, Object...)
+   */
+  public ThrowableAssertAlternative<T> withMessageEndingWith(String description, Object... parameters) {
+    delegate.hasMessageEndingWith(description, parameters);
+    return this;
+  }
+
   /**
    * Verifies that the cause of the actual {@code Throwable} is an instance of the given type.
    * <p>

diff --git a/src/test/java/org/assertj/core/api/Assertions_assertThatCode_Test.java b/src/test/java/org/assertj/core/api/Assertions_assertThatCode_Test.java
@@ -63,7 +63,7 @@ public void error_message_contains_stacktrace() {
 
     // Then
     assertThatExceptionOfType(AssertionError.class).isThrownBy(() -> assertThatCode(boom).doesNotThrowAnyException())
-                                                   .withMessageContaining("java.lang.Exception: boom")
+                                                   .withMessageContaining("java.lang.Exception: %s", "boom")
                                                    .withMessageContaining("at org.assertj.core.api.Assertions_assertThatCode_Test.error_message_contains_stacktrace");
   }
 

diff --git a/src/test/java/org/assertj/core/api/future/CompletableFutureAssert_hasNotFailed_Test.java b/src/test/java/org/assertj/core/api/future/CompletableFutureAssert_hasNotFailed_Test.java
@@ -57,7 +57,7 @@ public void should_fail_if_completable_future_has_failed() {
     assertThatThrownBy(() -> assertThat(future).hasNotFailed()).isInstanceOf(AssertionError.class)
                                                                .hasMessageStartingWith(format("%nExpecting%n  <CompletableFuture[Failed: java.lang.RuntimeException]%n"))
                                                                .hasMessageContaining("Caused by: java.lang.RuntimeException")
-                                                               .hasMessageEndingWith(format("to not have failed.%n%s", WARNING));
+                                                               .hasMessageEndingWith("to not have failed.%n%s", WARNING);
 
   }
 }
diff --git a/...rg/assertj/core/api/future/CompletableFutureAssert_isCompletedWithValueMatching_Test.java b/...rg/assertj/core/api/future/CompletableFutureAssert_isCompletedWithValueMatching_Test.java
@@ -94,7 +94,7 @@ public void should_fail_if_completable_future_has_failed() {
     assertThat(throwable).isInstanceOf(AssertionError.class)
                          .hasMessageStartingWith(format("%nExpecting%n  <CompletableFuture[Failed: java.lang.RuntimeException]%n"))
                          .hasMessageContaining("Caused by: java.lang.RuntimeException")
-                         .hasMessageEndingWith(format("to be completed.%n%s", WARNING));
+                         .hasMessageEndingWith("to be completed.%n%s", WARNING);
 
   }
 

diff --git a/...t/java/org/assertj/core/api/future/CompletableFutureAssert_isCompletedWithValue_Test.java b/...t/java/org/assertj/core/api/future/CompletableFutureAssert_isCompletedWithValue_Test.java
@@ -79,7 +79,7 @@ public void should_fail_if_completable_future_has_failed() {
     assertThat(throwable).isInstanceOf(AssertionError.class)
                          .hasMessageStartingWith(format("%nExpecting%n  <CompletableFuture[Failed: java.lang.RuntimeException]%n"))
                          .hasMessageContaining("Caused by: java.lang.RuntimeException")
-                         .hasMessageEndingWith(format("to be completed.%n%s", WARNING));
+                         .hasMessageEndingWith("to be completed.%n%s", WARNING);
 
   }
 

diff --git a/src/test/java/org/assertj/core/api/future/CompletableFutureAssert_isCompleted_Test.java b/src/test/java/org/assertj/core/api/future/CompletableFutureAssert_isCompleted_Test.java
@@ -53,7 +53,7 @@ public void should_fail_if_completable_future_has_failed() {
     assertThatThrownBy(() -> assertThat(future).isCompleted()).isInstanceOf(AssertionError.class)
                                                               .hasMessageStartingWith(format("%nExpecting%n  <CompletableFuture[Failed: java.lang.RuntimeException]%n"))
                                                               .hasMessageContaining("Caused by: java.lang.RuntimeException")
-                                                              .hasMessageEndingWith(format("to be completed.%n%s", WARNING));
+                                                              .hasMessageEndingWith("to be completed.%n%s", WARNING);
   }
 
   @Test