Change: fix composition chain.

`ThrowsException` is now responsible for safely executing the runnable, extracting the exception (if any), and delegating the actual test to the composed matcher.

Author: ggalmazor

hamcrest/src/main/java/org/hamcrest/exception/ThrowsException.java

@@ -4,44 +4,58 @@
 import org.hamcrest.Matcher;
 import org.hamcrest.TypeSafeMatcher;
 
-import static org.hamcrest.exception.ThrowsExceptionEqual.throwsExceptionEqual;
+import static org.hamcrest.exception.ThrowsExceptionEqualTo.exceptionEqualTo;
 
 /**
  * Tests if a Runnable throws a matching exception.
+ *
+ * @param <T> the type of the matched Runnable
  */
-public class ThrowsException extends TypeSafeMatcher<Runnable> {
+public class ThrowsException<T extends Runnable> extends TypeSafeMatcher<T> {
 
-    private final Matcher<Runnable> elementMatcher;
+    private final Matcher<? super Throwable> exceptionMatcher;
+    private Throwable actualException;
 
     /**
      * Constructor, best called from one of the static factory methods.
+     *
      * @param elementMatcher matches the expected element
      */
-    ThrowsException(Matcher<Runnable> elementMatcher) {
-        super(Runnable.class);
-        this.elementMatcher = elementMatcher;
+    ThrowsException(Matcher<? super Throwable> elementMatcher) {
+        this.exceptionMatcher = elementMatcher;
     }
 
-    public static <U extends Throwable> ThrowsException throwsException(U item) {
-        return new ThrowsException(throwsExceptionEqual(item));
+    public static <U extends Runnable, T extends Throwable> ThrowsException<U> throwsException(T item) {
+        return new ThrowsException<>(exceptionEqualTo(item));
     }
 
-    public static ThrowsException throwsException(Matcher<Runnable> itemMatcher) {
-        return new ThrowsException(itemMatcher);
+    public static <U extends Runnable> ThrowsException<U> throwsException(Matcher<? super Throwable> exceptionMatcher) {
+        return new ThrowsException<>(exceptionMatcher);
     }
 
     @Override
-    protected boolean matchesSafely(Runnable item) {
-        return elementMatcher.matches(item);
+    public boolean matchesSafely(T runnable) {
+        try {
+            runnable.run();
+            return false;
+        } catch (Throwable t) {
+            actualException = t;
+            return exceptionMatcher.matches(t);
+        }
     }
 
     @Override
     public void describeTo(Description description) {
-        description.appendText("a runnable throwing ").appendDescriptionOf(elementMatcher);
+        description.appendText("a runnable throwing ").appendDescriptionOf(exceptionMatcher);
     }
 
     @Override
-    protected void describeMismatchSafely(Runnable item, Description mismatchDescription) {
-        elementMatcher.describeMismatch(item, mismatchDescription);
+    public void describeMismatchSafely(T runnable, Description mismatchDescription) {
+        if (actualException == null) {
+            mismatchDescription.appendText("the runnable didn't throw");
+            return;
+        }
+        mismatchDescription.appendText("the runnable threw ");
+        exceptionMatcher.describeMismatch(actualException, mismatchDescription);
     }
 }

hamcrest/src/main/java/org/hamcrest/exception/ThrowsExceptionEqual.java

@@ -0,0 +1,45 @@
+package org.hamcrest.exception;
+
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeMatcher;
+
+/**
+ * A matcher that checks if a Runnable throws an expected exception when run.
+ *
+ * @param <T> the type of the expected exception.
+ */
+public class ThrowsExceptionEqualTo<T extends Throwable> extends TypeSafeMatcher<T> {
+    private final T expectedException;
+
+    /**
+     * Constructor, best called from one of the static factory methods.
+     *
+     * @param expectedException the expected exception.
+     */
+    ThrowsExceptionEqualTo(T expectedException) {
+        this.expectedException = expectedException;
+    }
+
+    public static <U extends Throwable> ThrowsExceptionEqualTo<U> exceptionEqualTo(U expectedException) {
+        return new ThrowsExceptionEqualTo<>(expectedException);
+    }
+
+    @Override
+    public boolean matchesSafely(T item) {
+        return this.expectedException.getClass().isAssignableFrom(item.getClass()) && item.getMessage().equals(this.expectedException.getMessage());
+    }
+
+    @Override
+    public void describeTo(Description description) {
+        description.appendValue(expectedException.getClass().getName()).appendText(" with message ").appendValue(expectedException.getMessage());
+    }
+
+    @Override
+    protected void describeMismatchSafely(T item, Description mismatchDescription) {
+        if (this.expectedException.getClass().isAssignableFrom(item.getClass())) {
+            mismatchDescription.appendValue(item.getClass().getName()).appendText(" with message ").appendValue(item.getMessage()).appendText(" instead of ").appendValue(this.expectedException.getMessage());
+            return;
+        }
+        mismatchDescription.appendValue(item.getClass().getName()).appendText(" instead of a ").appendValue(this.expectedException.getClass().getName()).appendText(" exception");
+    }
+}

hamcrest/src/main/java/org/hamcrest/exception/ThrowsExceptionEqualTo.java

@@ -11,46 +11,38 @@
  *
  * @param <T> the type of the expected exception.
  */
-public class ThrowsExceptionWithMessage<T extends String> extends TypeSafeMatcher<Runnable> {
-    private final Matcher<? super T> messageMatcher;
-    private String actualMessage;
+public class ThrowsExceptionWithMessage<T extends Throwable> extends TypeSafeMatcher<T> {
+    private final Matcher<? super String> messageMatcher;
 
     /**
      * Constructor, best called from one of the static factory methods.
      *
      * @param messageMatcher matches the exception message
      */
-    ThrowsExceptionWithMessage(Matcher<? super T> messageMatcher) {
-        super(Runnable.class);
+    ThrowsExceptionWithMessage(Matcher<? super String> messageMatcher) {
         this.messageMatcher = messageMatcher;
     }
 
-    public static <U extends String> ThrowsExceptionWithMessage<U> withMessage(U message) {
+    public static <U extends Throwable, V extends String> ThrowsExceptionWithMessage<U> withMessage(V message) {
         return new ThrowsExceptionWithMessage<>(equalTo(message));
     }
 
-    public static <U extends String> ThrowsExceptionWithMessage<U> withMessage(Matcher<? super U> messageMatcher) {
+    public static <U extends Throwable> ThrowsExceptionWithMessage<U> withMessage(Matcher<? super String> messageMatcher) {
         return new ThrowsExceptionWithMessage<>(messageMatcher);
     }
 
     @Override
-    protected boolean matchesSafely(Runnable item) {
-        try {
-            item.run();
-            return false;
-        } catch (Throwable t) {
-            actualMessage = t.getMessage();
-            return this.messageMatcher.matches(t.getMessage());
-        }
+    protected boolean matchesSafely(T item) {
+        return this.messageMatcher.matches(item.getMessage());
     }
 
     @Override
     public void describeTo(Description description) {
-        description.appendText("a runnable throwing an exception with message ").appendDescriptionOf(messageMatcher);
+        description.appendText("an exception with message ").appendDescriptionOf(messageMatcher);
     }
 
     @Override
-    protected void describeMismatchSafely(Runnable item, Description mismatchDescription) {
-        mismatchDescription.appendText("exception message was ").appendValue(actualMessage).appendText(" instead of ").appendDescriptionOf(messageMatcher);
+    protected void describeMismatchSafely(T item, Description mismatchDescription) {
+        mismatchDescription.appendText("an exception with message ").appendValue(item.getMessage()).appendText(" instead of ").appendDescriptionOf(messageMatcher);
     }
 }

hamcrest/src/main/java/org/hamcrest/exception/ThrowsExceptionWithMessage.java

@@ -4,15 +4,12 @@
 import org.hamcrest.Matcher;
 
 import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.exception.ThrowsException.throwsException;
 import static org.hamcrest.exception.ThrowsExceptionWithMessage.withMessage;
 
 public class ThrowsExceptionEqualTest extends AbstractMatcherTest {
 
-    private Runnable runnableThrowing(String message) {
-        return new ThrowingRunnable(new IllegalArgumentException(message));
-    }
-
     private Runnable runnableThrowing(Throwable exception) {
         return new ThrowingRunnable(exception);
     }
@@ -23,31 +20,95 @@ protected Matcher<?> createMatcher() {
     }
 
     public void testEvaluatesToTrueIfRunnableThrowsExpectedExceptionWithMatchingMessage() {
-        Matcher<Runnable> matcher = throwsException(new IllegalArgumentException("Boom!"));
-
-        assertMatches(matcher, runnableThrowing("Boom!"));
-        assertDoesNotMatch(matcher, runnableThrowing("Bang!"));
-        assertMismatchDescription("threw \"java.lang.IllegalArgumentException\" with message \"Bang!\" instead of \"Boom!\"", matcher, runnableThrowing("Bang!"));
-        assertDoesNotMatch(matcher, runnableThrowing(new NullPointerException("Boom!")));
-        assertMismatchDescription("threw a \"java.lang.NullPointerException\" instead of a \"java.lang.IllegalArgumentException\" exception", matcher, runnableThrowing(new NullPointerException("Boom!")));
+        assertMatches(
+                throwsException(new IllegalArgumentException("Boom!")),
+                runnableThrowing(new IllegalArgumentException("Boom!"))
+        );
+
+        assertDescription(
+                "a runnable throwing \"java.lang.IllegalArgumentException\" with message \"Boom!\"",
+                throwsException(new IllegalArgumentException("Boom!"))
+        );
+
+        assertMismatchDescription(
+                "the runnable threw \"java.lang.IllegalArgumentException\" with message \"Bang!\" instead of \"Boom!\"",
+                throwsException(new IllegalArgumentException("Boom!")),
+                runnableThrowing(new IllegalArgumentException("Bang!"))
+        );
+
+        assertMismatchDescription(
+                "the runnable threw \"java.lang.NullPointerException\" instead of a \"java.lang.IllegalArgumentException\" exception",
+                throwsException(new IllegalArgumentException("Boom!")),
+                runnableThrowing(new NullPointerException("Boom!"))
+        );
+
+        assertMismatchDescription(
+                "the runnable didn't throw",
+                throwsException(new IllegalArgumentException("Boom!")),
+                (Runnable) () -> {}
+        );
     }
 
     public void testEvaluatesToTrueIfRunnableThrowsExceptionExtendingTheExpectedExceptionWithMatchingMessage() {
-        Matcher<Runnable> matcher = throwsException(new IllegalArgumentException("Boom!"));
-
-        assertMatches(matcher, runnableThrowing(new TestException("Boom!")));
+        assertMatches(
+                throwsException(new IllegalArgumentException("Boom!")),
+                runnableThrowing(new TestException("Boom!"))
+        );
     }
 
     public void testEvaluatesToTrueIfRunnableThrowsExceptionWithExpectedMessage() {
-        Matcher<Runnable> matcher = throwsException(withMessage("Boom!"));
-
-        assertMatches(matcher, runnableThrowing(new TestException("Boom!")));
+        assertMatches(
+                throwsException(withMessage("Boom!")),
+                runnableThrowing(new TestException("Boom!"))
+        );
+
+        assertDescription(
+                "a runnable throwing an exception with message \"Boom!\"",
+                throwsException(withMessage("Boom!"))
+        );
+
+        assertMismatchDescription(
+                "the runnable threw an exception with message \"Bang!\" instead of \"Boom!\"",
+                throwsException(withMessage("Boom!")),
+                runnableThrowing(new IllegalArgumentException("Bang!"))
+        );
     }
 
     public void testEvaluatesToTrueIfRunnableThrowsExceptionWithMatchingMessage() {
-        Matcher<Runnable> matcher = throwsException(withMessage(containsString("bar")));
 
-        assertMatches(matcher, runnableThrowing(new TestException("Foo bar baz")));
+        assertMatches(
+                throwsException(withMessage(containsString("bar"))),
+                runnableThrowing(new TestException("Foo bar baz"))
+        );
+
+        assertDescription(
+                "a runnable throwing an exception with message a string containing \"bar\"",
+                throwsException(withMessage(containsString("bar")))
+        );
+
+        assertMismatchDescription(
+                "the runnable threw an exception with message \"Bang!\" instead of a string containing \"bar\"",
+                throwsException(withMessage(containsString("bar"))),
+                runnableThrowing(new IllegalArgumentException("Bang!"))
+        );
+    }
+
+    public void testEvaluatesToTrueIfRunnableThrowsMatchingException() {
+        assertMatches(
+                throwsException(instanceOf(TestException.class)),
+                runnableThrowing(new TestException("Boom!"))
+        );
+
+        assertDescription(
+                "a runnable throwing an instance of java.lang.NullPointerException",
+                throwsException(instanceOf(NullPointerException.class))
+        );
+
+        assertMismatchDescription(
+                "the runnable threw <java.lang.IllegalArgumentException: Bang!> is a java.lang.IllegalArgumentException",
+                throwsException(instanceOf(NullPointerException.class)),
+                runnableThrowing(new IllegalArgumentException("Bang!"))
+        );
     }
 
     public static class TestException extends IllegalArgumentException {