Parameterized reuses TestClass

src/main/java/org/junit/experimental/theories/Theories.java

@@ -73,6 +73,11 @@ public Theories(Class<?> klass) throws InitializationError {
         super(klass);
     }
 
+    /** @since 4.13 */
+    protected Theories(TestClass testClass) throws InitializationError {
+        super(testClass);
+    }
+
     @Override
     protected void collectInitializationErrors(List<Throwable> errors) {
         super.collectInitializationErrors(errors);
@@ -215,7 +220,7 @@ protected void runWithIncompleteAssignment(Assignments incomplete)
 
         protected void runWithCompleteAssignment(final Assignments complete)
                 throws Throwable {
-            new BlockJUnit4ClassRunner(getTestClass().getJavaClass()) {
+            new BlockJUnit4ClassRunner(getTestClass()) {
                 @Override
                 protected void collectInitializationErrors(
                         List<Throwable> errors) {

src/main/java/org/junit/internal/Checks.java

@@ -0,0 +1,37 @@
+package org.junit.internal;
+
+/** @since 4.13 */
+public final class Checks {
+
+    private Checks() {}
+
+    /**
+     * Checks that the given value is not {@code null}.
+     *
+     * @param value object reference to check
+     * @return the passed-in value, if not {@code null}
+     * @throws NullPointerException if {@code value} is {@code null}
+     */
+    public static <T> T notNull(T value) {
+        if (value == null) {
+            throw new NullPointerException();
+        }
+        return value;
+    }
+
+    /**
+     * Checks that the given value is not {@code null}, using the given message
+     * as the exception message if an exception is thrown.
+     *
+     * @param value object reference to check
+     * @param message message to use if {@code value} is {@code null}
+     * @return the passed-in value, if not {@code null}
+     * @throws NullPointerException if {@code value} is {@code null}
+     */
+    public static <T> T notNull(T value, String message) {
+        if (value == null) {
+            throw new NullPointerException(message);
+        }
+        return value;
+    }
+}

src/main/java/org/junit/internal/builders/JUnit4Builder.java

@@ -1,12 +1,12 @@
 package org.junit.internal.builders;
 
 import org.junit.runner.Runner;
-import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.JUnit4;
 import org.junit.runners.model.RunnerBuilder;
 
 public class JUnit4Builder extends RunnerBuilder {
     @Override
     public Runner runnerForClass(Class<?> testClass) throws Throwable {
-        return new BlockJUnit4ClassRunner(testClass);
+        return new JUnit4(testClass);
     }
-}
+}

src/main/java/org/junit/runners/BlockJUnit4ClassRunner.java

@@ -30,6 +30,7 @@
 import org.junit.runners.model.InitializationError;
 import org.junit.runners.model.MultipleFailureException;
 import org.junit.runners.model.Statement;
+import org.junit.runners.model.TestClass;
 import org.junit.validator.PublicClassValidator;
 import org.junit.validator.TestClassValidator;
 
@@ -71,6 +72,16 @@ public BlockJUnit4ClassRunner(Class<?> testClass) throws InitializationError {
         super(testClass);
     }
 
+    /**
+     * Creates a BlockJUnit4ClassRunner to run {@code testClass}.
+     *
+     * @throws InitializationError if the test class is malformed.
+     * @since 4.13
+     */
+    protected BlockJUnit4ClassRunner(TestClass testClass) throws InitializationError {
+        super(testClass);
+    }
+
     //
     // Implementation of ParentRunner
     //

src/main/java/org/junit/runners/JUnit4.java

@@ -1,6 +1,7 @@
 package org.junit.runners;
 
 import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.TestClass;
 
 /**
  * Aliases the current default JUnit 4 class runner, for future-proofing. If
@@ -19,6 +20,6 @@ public final class JUnit4 extends BlockJUnit4ClassRunner {
      * Constructs a new instance of the default runner
      */
     public JUnit4(Class<?> klass) throws InitializationError {
-        super(klass);
+        super(new TestClass(klass));
     }
 }

src/main/java/org/junit/runners/ParentRunner.java

@@ -1,5 +1,6 @@
 package org.junit.runners;
 
+import static org.junit.internal.Checks.notNull;
 import static org.junit.internal.runners.rules.RuleMemberValidator.CLASS_RULE_METHOD_VALIDATOR;
 import static org.junit.internal.runners.rules.RuleMemberValidator.CLASS_RULE_VALIDATOR;
 
@@ -86,6 +87,21 @@ protected ParentRunner(Class<?> testClass) throws InitializationError {
         validate();
     }
 
+   /**
+    * Constructs a new {@code ParentRunner} that will run the {@code TestClass}.
+    *
+    * @since 4.13
+    */
+    protected ParentRunner(TestClass testClass) throws InitializationError {
+       this.testClass = notNull(testClass);
+       validate();
+    }
+
+    /**
+     * @deprecated Please use {@link #ParentRunner(org.junit.runners.model.TestClass)}.
+     * @since 4.12
+     */
+    @Deprecated
     protected TestClass createTestClass(Class<?> testClass) {
         return new TestClass(testClass);
     }

src/main/java/org/junit/runners/parameterized/BlockJUnit4ClassRunnerWithParameters.java

@@ -32,7 +32,7 @@ private enum InjectionType {
 
     public BlockJUnit4ClassRunnerWithParameters(TestWithParameters test)
             throws InitializationError {
-        super(test.getTestClass().getJavaClass());
+        super(test.getTestClass());
         parameters = test.getParameters().toArray(
                 new Object[test.getParameters().size()]);
         name = test.getName();

src/main/java/org/junit/runners/parameterized/TestWithParameters.java

@@ -1,6 +1,7 @@
 package org.junit.runners.parameterized;
 
 import static java.util.Collections.unmodifiableList;
+import static org.junit.internal.Checks.notNull;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -73,10 +74,4 @@ public String toString() {
         return testClass.getName() + " '" + name + "' with parameters "
                 + parameters;
     }
-
-    private static void notNull(Object value, String message) {
-        if (value == null) {
-            throw new NullPointerException(message);
-        }
-    }
 }

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

@@ -13,6 +13,7 @@
 @RunWith(Suite.class)
 @SuiteClasses({
         AnnotatedBuilderTest.class,
+        ChecksTest.class,
         ErrorReportingRunnerTest.class,
         ExpectExceptionTest.class,
         FailOnTimeoutTest.class,

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

@@ -0,0 +1,60 @@
+package org.junit.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+import static org.junit.internal.Checks.notNull;
+import org.junit.Test;
+
+/** Tests for {@link Checks}. */
+public class ChecksTest {
+
+    @Test
+    public void notNullShouldReturnNonNullValues() {
+        Double value = Double.valueOf(3.14);
+
+        Double result = notNull(value);
+
+        assertSame(value, result);
+    }
+
+    @Test
+    public void notNullShouldThrowOnNullValues() {
+        try {
+            notNull(null);
+            fail("NullPointerException expected");
+        } catch (NullPointerException e) {
+            assertNull("message should be null", e.getMessage());
+        }
+    }
+
+    @Test
+    public void notNullWithMessageShouldReturnNonNullValues() {
+        Float value = Float.valueOf(3.14f);
+
+        Float result = notNull(value, "woops");
+
+        assertSame(value, result);
+    }
+
+    @Test
+    public void notNullWithMessageShouldThrowOnNullValues() {
+        try {
+            notNull(null, "woops");
+            fail("NullPointerException expected");
+        } catch (NullPointerException e) {
+            assertEquals("message does not match", "woops", e.getMessage());
+        }
+    }
+
+    @Test
+    public void notNullWithNullMessageShouldThrowOnNullValues() {
+        try {
+            notNull(null, null);
+            fail("NullPointerException expected");
+        } catch (NullPointerException e) {
+            assertNull("message should be null", e.getMessage());
+        }
+    }
+}