Add Assert#expectThrows

src/main/java/org/junit/Assert.java

@@ -955,4 +955,46 @@ public static <T> void assertThat(String reason, T actual,
             Matcher<? super T> matcher) {
         MatcherAssert.assertThat(reason, actual, matcher);
     }
+
+    /**
+     * This interface facilitates the use of expectThrows from Java 8. It allows
+     * method references to void methods (that declare checked exceptions) to be
+     * passed directly into expectThrows without wrapping. It is not meant to be
+     * implemented directly.
+     */
+    public interface ThrowingRunnable {
+        void run() throws Throwable;
+    }
+
+    /**
+     * Asserts that {@code runnable} throws an exception when executed. If it
+     * does, the exception object is returned. If it does not, an
+     * {@link AssertionError} is thrown.
+     *
+     * @param runnable A function that is expected to throw an exception when executed
+     * @return The exception thrown by {@code runnable}
+     */
+    public static Throwable expectThrows(ThrowingRunnable runnable) {
+        return expectThrows(null, runnable);
+    }
+
+
+    /**
+     * Asserts that {@code runnable} throws an exception when executed. If it
+     * does, the exception object is returned. If it does not, an
+     * {@link AssertionError} is thrown with the given message.
+     *
+     * @param message the identifying message for the {@link AssertionError}
+     * @param runnable A function that is expected to throw an exception when executed
+     * @return The exception thrown by {@code runnable}
+     */
+    public static Throwable expectThrows(String message, ThrowingRunnable runnable) {
+        try {
+            runnable.run();
+        } catch (Throwable t) {
+            return t;
+        }
+        fail(message);
+        throw new AssertionError(); // This statement is unreachable.
+    }
 }

src/test/java/org/junit/tests/assertion/AssertionTest.java

@@ -11,11 +11,13 @@
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.expectThrows;
 import static org.junit.Assert.fail;
 
 import java.math.BigDecimal;
 
 import org.junit.Assert;
+import org.junit.Assert.ThrowingRunnable;
 import org.junit.ComparisonFailure;
 import org.junit.Test;
 import org.junit.internal.ArrayComparisonFailure;
@@ -170,7 +172,7 @@ public void oneDimensionalDoubleArraysAreNotEqual() {
     public void oneDimensionalFloatArraysAreNotEqual() {
         assertArrayEquals(new float[]{1.0f}, new float[]{2.5f}, 1.0f);
     }
-    
+
     @Test(expected = AssertionError.class)
     public void oneDimensionalBooleanArraysAreNotEqual() {
         assertArrayEquals(new boolean[]{true}, new boolean[]{false});
@@ -674,4 +676,53 @@ public void assertNotEqualsIgnoresDeltaOnNaN() {
     public void assertNotEqualsIgnoresFloatDeltaOnNaN() {
         assertNotEquals(Float.NaN, Float.NaN, 1f);
     }
+
+    @Test(expected = AssertionError.class)
+    public void expectThrowsRequiresAnExceptionToBeThrown() {
+        expectThrows(nonThrowingRunnable());
+    }
+
+    @Test
+    public void expectThrowsIncludesNoMessageByDefault() {
+        try {
+            expectThrows(nonThrowingRunnable());
+            fail();
+        } catch (AssertionError ex) {
+            assertNull(ex.getMessage());
+        }
+    }
+
+    @Test
+    public void expectThrowsIncludesTheSuppliedMessage() {
+        try {
+            expectThrows("message", nonThrowingRunnable());
+            fail();
+        } catch (AssertionError ex) {
+            assertEquals("message", ex.getMessage());
+        }
+    }
+
+    @Test
+    public void expectThrowsReturnsTheSameObjectThrown() {
+        NullPointerException npe = new NullPointerException();
+
+        Throwable throwable = expectThrows(throwingRunnable(npe));
+
+        assertSame(npe, throwable);
+    }
+
+    private static ThrowingRunnable nonThrowingRunnable() {
+        return new ThrowingRunnable() {
+            public void run() throws Throwable {
+            }
+        };
+    }
+
+    private static ThrowingRunnable throwingRunnable(final Throwable t) {
+        return new ThrowingRunnable() {
+            public void run() throws Throwable {
+                throw t;
+            }
+        };
+    }
 }