AssertJThrowingCallableRules

SUGGESTION

Simplification

View source code on GitHub

Suppression

Disable all rules by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$).* as compiler argument.

Table of contents

1. AssertThatThrownByIllegalArgumentException
2. AssertThatThrownByIllegalArgumentExceptionHasMessage
3. AssertThatThrownByIllegalArgumentExceptionHasMessageParameters
4. AssertThatThrownByIllegalArgumentExceptionHasMessageStartingWith
5. AssertThatThrownByIllegalArgumentExceptionHasMessageContaining
6. AssertThatThrownByIllegalArgumentExceptionHasMessageNotContainingAny
7. AssertThatThrownByIllegalStateException
8. AssertThatThrownByIllegalStateExceptionHasMessage
9. AssertThatThrownByIllegalStateExceptionHasMessageParameters
10. AssertThatThrownByIllegalStateExceptionHasMessageStartingWith
11. AssertThatThrownByIllegalStateExceptionHasMessageContaining
12. AssertThatThrownByIllegalStateExceptionHasMessageNotContaining
13. AssertThatThrownByNullPointerException
14. AssertThatThrownByNullPointerExceptionHasMessage
15. AssertThatThrownByNullPointerExceptionHasMessageParameters
16. AssertThatThrownByNullPointerExceptionHasMessageStartingWith
17. AssertThatThrownByNullPointerExceptionHasMessageContaining
18. AssertThatThrownByNullPointerExceptionHasMessageNotContaining
19. AssertThatThrownByIOException
20. AssertThatThrownByIOExceptionHasMessage
21. AssertThatThrownByIOExceptionHasMessageParameters
22. AssertThatThrownByIOExceptionHasMessageStartingWith
23. AssertThatThrownByIOExceptionHasMessageContaining
24. AssertThatThrownByIOExceptionHasMessageNotContaining
25. AssertThatThrownBy
26. AssertThatThrownByHasMessage
27. AssertThatThrownByHasMessageParameters
28. AssertThatThrownByHasMessageStartingWith
29. AssertThatThrownByHasMessageContaining
30. AssertThatThrownByHasMessageNotContaining
31. AbstractThrowableAssertHasMessage
32. AbstractThrowableAssertWithFailMessage

AssertThatThrownByIllegalArgumentException

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalArgumentException") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalArgumentException).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalArgumentException() {
-  return assertThatIllegalArgumentException().isThrownBy(() -> {});
+  return assertThatThrownBy(() -> {}).isInstanceOf(IllegalArgumentException.class);
 }

AssertThatThrownByIllegalArgumentExceptionHasMessage

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalArgumentExceptionHasMessage") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalArgumentExceptionHasMessage).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalArgumentExceptionHasMessage() {
-  return assertThatIllegalArgumentException().isThrownBy(() -> {}).withMessage("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("foo");
 }

AssertThatThrownByIllegalArgumentExceptionHasMessageParameters

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalArgumentExceptionHasMessageParameters") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalArgumentExceptionHasMessageParameters).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalArgumentExceptionHasMessageParameters() {
-  return assertThatIllegalArgumentException().isThrownBy(() -> {}).withMessage("foo %s", "bar");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("foo %s", "bar");
 }

AssertThatThrownByIllegalArgumentExceptionHasMessageStartingWith

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalArgumentExceptionHasMessageStartingWith") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalArgumentExceptionHasMessageStartingWith).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?>
     testAssertThatThrownByIllegalArgumentExceptionHasMessageStartingWith() {
-  return assertThatIllegalArgumentException().isThrownBy(() -> {}).withMessageStartingWith("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessageStartingWith("foo");
 }

AssertThatThrownByIllegalArgumentExceptionHasMessageContaining

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalArgumentExceptionHasMessageContaining") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalArgumentExceptionHasMessageContaining).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalArgumentExceptionHasMessageContaining() {
-  return assertThatIllegalArgumentException().isThrownBy(() -> {}).withMessageContaining("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessageContaining("foo");
 }

AssertThatThrownByIllegalArgumentExceptionHasMessageNotContainingAny

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalArgumentExceptionHasMessageNotContainingAny") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalArgumentExceptionHasMessageNotContainingAny).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?>
     testAssertThatThrownByIllegalArgumentExceptionHasMessageNotContainingAny() {
-  return assertThatIllegalArgumentException()
-      .isThrownBy(() -> {})
-      .withMessageNotContainingAny("foo", "bar");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessageNotContainingAny("foo", "bar");
 }

AssertThatThrownByIllegalStateException

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalStateException") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalStateException).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalStateException() {
-  return assertThatIllegalStateException().isThrownBy(() -> {});
+  return assertThatThrownBy(() -> {}).isInstanceOf(IllegalStateException.class);
 }

AssertThatThrownByIllegalStateExceptionHasMessage

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalStateExceptionHasMessage") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalStateExceptionHasMessage).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalStateExceptionHasMessage() {
-  return assertThatIllegalStateException().isThrownBy(() -> {}).withMessage("foo");
+  return assertThatThrownBy(() -> {}).isInstanceOf(IllegalStateException.class).hasMessage("foo");
 }

AssertThatThrownByIllegalStateExceptionHasMessageParameters

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalStateExceptionHasMessageParameters") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalStateExceptionHasMessageParameters).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalStateExceptionHasMessageParameters() {
-  return assertThatIllegalStateException().isThrownBy(() -> {}).withMessage("foo %s", "bar");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalStateException.class)
+      .hasMessage("foo %s", "bar");
 }

AssertThatThrownByIllegalStateExceptionHasMessageStartingWith

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalStateExceptionHasMessageStartingWith") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalStateExceptionHasMessageStartingWith).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalStateExceptionHasMessageStartingWith() {
-  return assertThatIllegalStateException().isThrownBy(() -> {}).withMessageStartingWith("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalStateException.class)
+      .hasMessageStartingWith("foo");
 }

AssertThatThrownByIllegalStateExceptionHasMessageContaining

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalStateExceptionHasMessageContaining") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalStateExceptionHasMessageContaining).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalStateExceptionHasMessageContaining() {
-  return assertThatIllegalStateException().isThrownBy(() -> {}).withMessageContaining("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalStateException.class)
+      .hasMessageContaining("foo");
 }

AssertThatThrownByIllegalStateExceptionHasMessageNotContaining

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIllegalStateExceptionHasMessageNotContaining") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIllegalStateExceptionHasMessageNotContaining).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIllegalStateExceptionHasMessageNotContaining() {
-  return assertThatIllegalStateException().isThrownBy(() -> {}).withMessageNotContaining("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalStateException.class)
+      .hasMessageNotContaining("foo");
 }

AssertThatThrownByNullPointerException

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByNullPointerException") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByNullPointerException).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByNullPointerException() {
-  return assertThatNullPointerException().isThrownBy(() -> {});
+  return assertThatThrownBy(() -> {}).isInstanceOf(NullPointerException.class);
 }

AssertThatThrownByNullPointerExceptionHasMessage

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByNullPointerExceptionHasMessage") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByNullPointerExceptionHasMessage).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByNullPointerExceptionHasMessage() {
-  return assertThatNullPointerException().isThrownBy(() -> {}).withMessage("foo");
+  return assertThatThrownBy(() -> {}).isInstanceOf(NullPointerException.class).hasMessage("foo");
 }

AssertThatThrownByNullPointerExceptionHasMessageParameters

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByNullPointerExceptionHasMessageParameters") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByNullPointerExceptionHasMessageParameters).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByNullPointerExceptionHasMessageParameters() {
-  return assertThatNullPointerException().isThrownBy(() -> {}).withMessage("foo %s", "bar");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(NullPointerException.class)
+      .hasMessage("foo %s", "bar");
 }

AssertThatThrownByNullPointerExceptionHasMessageStartingWith

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByNullPointerExceptionHasMessageStartingWith") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByNullPointerExceptionHasMessageStartingWith).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByNullPointerExceptionHasMessageStartingWith() {
-  return assertThatNullPointerException().isThrownBy(() -> {}).withMessageStartingWith("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(NullPointerException.class)
+      .hasMessageStartingWith("foo");
 }

AssertThatThrownByNullPointerExceptionHasMessageContaining

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByNullPointerExceptionHasMessageContaining") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByNullPointerExceptionHasMessageContaining).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByNullPointerExceptionHasMessageContaining() {
-  return assertThatNullPointerException().isThrownBy(() -> {}).withMessageContaining("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(NullPointerException.class)
+      .hasMessageContaining("foo");
 }

AssertThatThrownByNullPointerExceptionHasMessageNotContaining

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByNullPointerExceptionHasMessageNotContaining") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByNullPointerExceptionHasMessageNotContaining).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByNullPointerExceptionHasMessageNotContaining() {
-  return assertThatNullPointerException().isThrownBy(() -> {}).withMessageNotContaining("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(NullPointerException.class)
+      .hasMessageNotContaining("foo");
 }

AssertThatThrownByIOException

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIOException") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIOException).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIOException() {
-  return assertThatIOException().isThrownBy(() -> {});
+  return assertThatThrownBy(() -> {}).isInstanceOf(IOException.class);
 }

AssertThatThrownByIOExceptionHasMessage

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIOExceptionHasMessage") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIOExceptionHasMessage).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIOExceptionHasMessage() {
-  return assertThatIOException().isThrownBy(() -> {}).withMessage("foo");
+  return assertThatThrownBy(() -> {}).isInstanceOf(IOException.class).hasMessage("foo");
 }

AssertThatThrownByIOExceptionHasMessageParameters

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIOExceptionHasMessageParameters") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIOExceptionHasMessageParameters).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIOExceptionHasMessageParameters() {
-  return assertThatIOException().isThrownBy(() -> {}).withMessage("foo %s", "bar");
+  return assertThatThrownBy(() -> {}).isInstanceOf(IOException.class).hasMessage("foo %s", "bar");
 }

AssertThatThrownByIOExceptionHasMessageStartingWith

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIOExceptionHasMessageStartingWith") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIOExceptionHasMessageStartingWith).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIOExceptionHasMessageStartingWith() {
-  return assertThatIOException().isThrownBy(() -> {}).withMessageStartingWith("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IOException.class)
+      .hasMessageStartingWith("foo");
 }

AssertThatThrownByIOExceptionHasMessageContaining

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIOExceptionHasMessageContaining") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIOExceptionHasMessageContaining).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIOExceptionHasMessageContaining() {
-  return assertThatIOException().isThrownBy(() -> {}).withMessageContaining("foo");
+  return assertThatThrownBy(() -> {}).isInstanceOf(IOException.class).hasMessageContaining("foo");
 }

AssertThatThrownByIOExceptionHasMessageNotContaining

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByIOExceptionHasMessageNotContaining") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByIOExceptionHasMessageNotContaining).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByIOExceptionHasMessageNotContaining() {
-  return assertThatIOException().isThrownBy(() -> {}).withMessageNotContaining("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IOException.class)
+      .hasMessageNotContaining("foo");
 }

AssertThatThrownBy

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownBy") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownBy).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownBy() {
-  return assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> {});
+  return assertThatThrownBy(() -> {}).isInstanceOf(IllegalArgumentException.class);
 }

AssertThatThrownByHasMessage

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByHasMessage") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByHasMessage).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByHasMessage() {
-  return assertThatExceptionOfType(IllegalArgumentException.class)
-      .isThrownBy(() -> {})
-      .withMessage("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("foo");
 }

AssertThatThrownByHasMessageParameters

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByHasMessageParameters") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByHasMessageParameters).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByHasMessageParameters() {
-  return assertThatExceptionOfType(IllegalArgumentException.class)
-      .isThrownBy(() -> {})
-      .withMessage("foo %s", "bar");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("foo %s", "bar");
 }

AssertThatThrownByHasMessageStartingWith

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByHasMessageStartingWith") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByHasMessageStartingWith).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByHasMessageStartingWith() {
-  return assertThatExceptionOfType(IllegalArgumentException.class)
-      .isThrownBy(() -> {})
-      .withMessageStartingWith("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessageStartingWith("foo");
 }

AssertThatThrownByHasMessageContaining

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByHasMessageContaining") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByHasMessageContaining).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByHasMessageContaining() {
-  return assertThatExceptionOfType(IllegalArgumentException.class)
-      .isThrownBy(() -> {})
-      .withMessageContaining("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessageContaining("foo");
 }

AssertThatThrownByHasMessageNotContaining

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AssertThatThrownByHasMessageNotContaining") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AssertThatThrownByHasMessageNotContaining).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 AbstractObjectAssert<?, ?> testAssertThatThrownByHasMessageNotContaining() {
-  return assertThatExceptionOfType(IllegalArgumentException.class)
-      .isThrownBy(() -> {})
-      .withMessageNotContaining("foo");
+  return assertThatThrownBy(() -> {})
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessageNotContaining("foo");
 }

AbstractThrowableAssertHasMessage

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AbstractThrowableAssertHasMessage") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AbstractThrowableAssertHasMessage).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<AbstractThrowableAssert<?, ? extends Throwable>>
     testAbstractThrowableAssertHasMessage() {
   return ImmutableSet.of(
       assertThatThrownBy(() -> {})
           .isInstanceOf(IllegalArgumentException.class)
-          .hasMessage(String.format("foo %s", "bar")),
+          .hasMessage("foo %s", "bar"),
       assertThatThrownBy(() -> {})
           .isInstanceOf(IllegalArgumentException.class)
-          .hasMessage(String.format("foo %s %s", "bar", 1)));
+          .hasMessage("foo %s %s", "bar", 1));
 }

AbstractThrowableAssertWithFailMessage

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("AbstractThrowableAssertWithFailMessage") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!AssertJThrowingCallableRules\$AbstractThrowableAssertWithFailMessage).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<AbstractThrowableAssert<?, ? extends Throwable>>
     testAbstractThrowableAssertWithFailMessage() {
   return ImmutableSet.of(
       assertThatThrownBy(() -> {})
           .isInstanceOf(IllegalArgumentException.class)
-          .withFailMessage(String.format("foo %s", "bar")),
+          .withFailMessage("foo %s", "bar"),
       assertThatThrownBy(() -> {})
           .isInstanceOf(IllegalArgumentException.class)
-          .withFailMessage(String.format("foo %s %s", "bar", 1)));
+          .withFailMessage("foo %s %s", "bar", 1));
 }