Change: support junit style, matching against type matching of exceptions.

At heart, the matcher keeps checking instances, but some QoL alias support matching against types.

Author: ggalmazor

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

@@ -4,7 +4,10 @@
 import org.hamcrest.Matcher;
 import org.hamcrest.TypeSafeMatcher;
 
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.exception.ThrowsExceptionEqualTo.exceptionEqualTo;
+import static org.hamcrest.exception.ThrowsExceptionWithMessage.withMessage;
 
 /**
  * Tests if a Runnable throws a matching exception.
@@ -25,6 +28,10 @@ public class ThrowsException<T extends Runnable> extends TypeSafeMatcher<T> {
         this.exceptionMatcher = elementMatcher;
     }
 
+    public static <U extends Runnable> ThrowsException<U> throwsException() {
+        return new ThrowsException<>(instanceOf(Throwable.class));
+    }
+
     public static <U extends Runnable, T extends Throwable> ThrowsException<U> throwsException(T item) {
         return new ThrowsException<>(exceptionEqualTo(item));
     }
@@ -33,6 +40,18 @@ public static <U extends Runnable> ThrowsException<U> throwsException(Matcher<?
         return new ThrowsException<>(exceptionMatcher);
     }
 
+    public static <U extends Runnable, T extends Throwable> ThrowsException<U> throwsException(Class<T> item) {
+        return new ThrowsException<>(instanceOf(item));
+    }
+
+    public static <U extends Runnable, T extends Throwable> ThrowsException<U> throwsException(Class<T> item , String message) {
+        return new ThrowsException<>(allOf(instanceOf(item), withMessage(message)));
+    }
+
+    public static <U extends Runnable, T extends Throwable> ThrowsException<U> throwsException(Class<T> item , Matcher<? super Throwable> exceptionMatcher) {
+        return new ThrowsException<>(allOf(instanceOf(item), exceptionMatcher));
+    }
+
     @Override
     public boolean matchesSafely(T runnable) {
         try {

hamcrest/src/test/java/org/hamcrest/exception/ThrowsExceptionEqualTest.java

@@ -3,6 +3,7 @@
 import org.hamcrest.AbstractMatcherTest;
 import org.hamcrest.Matcher;
 
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.exception.ThrowsException.throwsException;
@@ -16,7 +17,23 @@ private Runnable runnableThrowing(Throwable exception) {
 
     @Override
     protected Matcher<?> createMatcher() {
-        return throwsException(new IllegalArgumentException("Boom!"));
+        return throwsException(IllegalArgumentException.class);
+    }
+
+    public void testExamples() {
+        RuntimeException boom = new RuntimeException("boom");
+        Runnable codeThatThrows = () -> {
+            throw boom;
+        };
+
+        assertThat(codeThatThrows, throwsException());
+        assertThat(codeThatThrows, throwsException(boom));
+        assertThat(codeThatThrows, throwsException(RuntimeException.class));
+        assertThat(codeThatThrows, throwsException(withMessage("boom")));
+        assertThat(codeThatThrows, throwsException(withMessage(containsString("oom"))));
+        assertThat(codeThatThrows, throwsException(RuntimeException.class, "boom"));
+        assertThat(codeThatThrows, throwsException(RuntimeException.class, withMessage("boom")));
+        assertThat(codeThatThrows, throwsException(RuntimeException.class, withMessage(containsString("boom"))));
     }
 
     public void testEvaluatesToTrueIfRunnableThrowsExpectedExceptionWithMatchingMessage() {
@@ -45,7 +62,8 @@ public void testEvaluatesToTrueIfRunnableThrowsExpectedExceptionWithMatchingMess
         assertMismatchDescription(
                 "the runnable didn't throw",
                 throwsException(new IllegalArgumentException("Boom!")),
-                (Runnable) () -> {}
+                (Runnable) () -> {
+                }
         );
     }