Tests expecting AssumptionViolatedException should be marked as passed, not skipped

src/main/java/org/junit/internal/runners/statements/ExpectException.java

@@ -19,7 +19,9 @@ public void evaluate() throws Exception {
             next.evaluate();
             complete = true;
         } catch (AssumptionViolatedException e) {
-            throw e;
+            if (!expected.isAssignableFrom(e.getClass())) {
+                throw e;
+            }
         } catch (Throwable e) {
             if (!expected.isAssignableFrom(e.getClass())) {
                 String message = "Unexpected exception, expected<"

src/test/java/org/junit/internal/AllInternalTests.java

@@ -4,6 +4,7 @@
 import org.junit.internal.matchers.StacktracePrintingMatcherTest;
 import org.junit.internal.matchers.ThrowableCauseMatcherTest;
 import org.junit.internal.runners.ErrorReportingRunnerTest;
+import org.junit.internal.runners.statements.ExpectExceptionTest;
 import org.junit.internal.runners.statements.FailOnTimeoutTest;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
@@ -13,6 +14,7 @@
 @SuiteClasses({
         AnnotatedBuilderTest.class,
         ErrorReportingRunnerTest.class,
+        ExpectExceptionTest.class,
         FailOnTimeoutTest.class,
         MethodSorterTest.class,
         StacktracePrintingMatcherTest.class,

src/test/java/org/junit/internal/runners/statements/ExpectExceptionTest.java

@@ -0,0 +1,88 @@
+package org.junit.internal.runners.statements;
+
+import org.junit.Test;
+import org.junit.internal.AssumptionViolatedException;
+import org.junit.runners.model.Statement;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+
+/**
+ * Integration tests can be found in {@link org.junit.tests.running.methods.ExpectedTest}.
+ * See e.g. {@link org.junit.tests.running.methods.ExpectedTest#expectsAssumptionViolatedException()}
+ */
+public class ExpectExceptionTest {
+
+    @Test
+    public void whenExpectingAssumptionViolatedExceptionStatementsThrowingItShouldPass() {
+        Statement delegate = new Fail(new AssumptionViolatedException("expected"));
+        ExpectException expectException = new ExpectException(delegate, AssumptionViolatedException.class);
+
+        try {
+            expectException.evaluate();
+            // then AssumptionViolatedException should not be thrown
+        } catch (Throwable e) { // need to explicitly catch and re-throw as an AssertionError or it might be skipped
+            fail("should not throw anything, but was thrown: " + e);
+        }
+    }
+
+    @Test
+    public void whenExpectingAssumptionViolatedExceptionStatementsThrowingSubclassShouldPass() {
+        Statement delegate = new Fail(new AssumptionViolatedExceptionSubclass("expected"));
+        ExpectException expectException = new ExpectException(delegate, AssumptionViolatedException.class);
+
+        try {
+            expectException.evaluate();
+            // then no exception should be thrown
+        } catch (Throwable e) {
+            fail("should not throw anything, but was thrown: " + e);
+        }
+    }
+
+    @Test
+    public void whenExpectingAssumptionViolatedExceptionStatementsThrowingDifferentExceptionShouldFail() {
+        Statement delegate = new Fail(new SomeException("not expected"));
+        ExpectException expectException = new ExpectException(delegate, AssumptionViolatedException.class);
+
+        try {
+            expectException.evaluate();
+            fail("should throw 'Unexpected exception' when statement throws an exception which is not the one expected");
+        } catch (Exception e) {
+            assertThat(e.getMessage(), equalTo("Unexpected exception, expected<org.junit.internal.AssumptionViolatedException> " +
+                    "but was<org.junit.internal.runners.statements.ExpectExceptionTest$SomeException>"));
+        }
+    }
+
+    @Test
+    public void whenExpectingAssumptionViolatedExceptionStatementsPassingShouldFail() throws Exception {
+        ExpectException expectException = new ExpectException(new PassingStatement(), AssumptionViolatedException.class);
+
+        try {
+            expectException.evaluate();
+        } catch (AssertionError e) {
+            assertThat(e.getMessage(), containsString("Expected exception: " + AssumptionViolatedException.class.getName()));
+            return;
+        }
+        fail("ExpectException should throw when the given statement passes");
+    }
+
+    private static class PassingStatement extends Statement {
+        public void evaluate() throws Throwable {
+            // nop
+        }
+    }
+
+    private static class SomeException extends RuntimeException {
+        public SomeException(String message) {
+            super(message);
+        }
+    }
+
+    private static class AssumptionViolatedExceptionSubclass extends AssumptionViolatedException {
+        public AssumptionViolatedExceptionSubclass(String assumption) {
+            super(assumption);
+        }
+    }
+}

src/test/java/org/junit/tests/running/methods/ExpectedTest.java

@@ -5,6 +5,7 @@
 import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
+import org.junit.internal.AssumptionViolatedException;
 import org.junit.runner.JUnitCore;
 import org.junit.runner.Result;
 import org.junit.runner.notification.Failure;
@@ -67,4 +68,16 @@ public void throwsSubclass() {
     public void expectsSuperclass() {
         assertTrue(new JUnitCore().run(ExpectSuperclass.class).wasSuccessful());
     }
+
+    public static class ExpectAssumptionViolatedException {
+        @Test(expected = AssumptionViolatedException.class)
+        public void throwsAssumptionViolatedException() {
+            throw new AssumptionViolatedException("expected");
+        }
+    }
+
+    @Test
+    public void expectsAssumptionViolatedException() {
+        assertTrue(new JUnitCore().run(ExpectAssumptionViolatedException.class).wasSuccessful());
+    }
 }