Class Parameterized

  • All Implemented Interfaces:
    Describable, Filterable, Sortable

    public class Parameterized
    extends Suite
    The custom runner Parameterized implements parameterized tests. When running a parameterized test class, instances are created for the cross-product of the test methods and the test data elements.

    For example, to test a Fibonacci function, write:

     @RunWith(Parameterized.class)
     public class FibonacciTest {
         @Parameters(name= "{index}: fib[{0}]={1}")
         public static Iterable<Object[]> data() {
             return Arrays.asList(new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 1 },
                     { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } });
         }
    
         private int fInput;
    
         private int fExpected;
    
         public FibonacciTest(int input, int expected) {
             fInput= input;
             fExpected= expected;
         }
    
         @Test
         public void test() {
             assertEquals(fExpected, Fibonacci.compute(fInput));
         }
     }
     

    Each instance of FibonacciTest will be constructed using the two-argument constructor and the data values in the @Parameters method.

    In order that you can easily identify the individual tests, you may provide a name for the @Parameters annotation. This name is allowed to contain placeholders, which are replaced at runtime. The placeholders are

    {index}
    the current parameter index
    {0}
    the first parameter value
    {1}
    the second parameter value
    ...
    ...

    In the example given above, the Parameterized runner creates names like [1: fib(3)=2]. If you don't use the name parameter, then the current parameter index is used as name.

    You can also write:

     @RunWith(Parameterized.class)
     public class FibonacciTest {
      @Parameters
      public static Iterable<Object[]> data() {
          return Arrays.asList(new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 1 },
                     { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } });
      }
      
      @Parameter(0)
      public int fInput;
    
      @Parameter(1)
      public int fExpected;
    
      @Test
      public void test() {
          assertEquals(fExpected, Fibonacci.compute(fInput));
      }
     }
     

    Each instance of FibonacciTest will be constructed with the default constructor and fields annotated by @Parameter will be initialized with the data values in the @Parameters method.

    The parameters can be provided as an array, too:

     @Parameters
     public static Object[][] data() {
            return new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 }, { 4, 3 },
                            { 5, 5 }, { 6, 8 } };
     }
     

    Tests with single parameter

    If your test needs a single parameter only, you don't have to wrap it with an array. Instead you can provide an Iterable or an array of objects.

     @Parameters
     public static Iterable<? extends Object> data() {
            return Arrays.asList("first test", "second test");
     }
     

    or

     @Parameters
     public static Object[] data() {
            return new Object[] { "first test", "second test" };
     }
     

    Create different runners

    By default the Parameterized runner creates a slightly modified BlockJUnit4ClassRunner for each set of parameters. You can build an own Parameterized runner that creates another runner for each set of parameters. Therefore you have to build a ParametersRunnerFactory that creates a runner for each TestWithParameters. ( TestWithParameters are bundling the parameters and the test name.) The factory must have a public zero-arg constructor.

     public class YourRunnerFactory implements ParameterizedRunnerFactory {
         public Runner createRunnerForTestWithParameters(TestWithParameters test)
                 throws InitializationError {
             return YourRunner(test);
         }
     }
     

    Use the Parameterized.UseParametersRunnerFactory to tell the Parameterized runner that it should use your factory.

     @RunWith(Parameterized.class)
     @UseParametersRunnerFactory(YourRunnerFactory.class)
     public class YourTest {
         ...
     }
     
    Since:
    4.0
    • Field Detail

      • NO_RUNNERS

        private static final java.util.List<Runner> NO_RUNNERS
      • runners

        private final java.util.List<Runner> runners
    • Constructor Detail

      • Parameterized

        public Parameterized​(java.lang.Class<?> klass)
                      throws java.lang.Throwable
        Only called reflectively. Do not use programmatically.
        Throws:
        java.lang.Throwable
    • Method Detail

      • getParametersRunnerFactory

        private ParametersRunnerFactory getParametersRunnerFactory​(java.lang.Class<?> klass)
                                                            throws java.lang.InstantiationException,
                                                                   java.lang.IllegalAccessException
        Throws:
        java.lang.InstantiationException
        java.lang.IllegalAccessException
      • getChildren

        protected java.util.List<Runner> getChildren()
        Description copied from class: ParentRunner
        Returns a list of objects that define the children of this Runner.
        Overrides:
        getChildren in class Suite
      • createTestWithNotNormalizedParameters

        private TestWithParameters createTestWithNotNormalizedParameters​(java.lang.String pattern,
                                                                         int index,
                                                                         java.lang.Object parametersOrSingleParameter)
      • allParameters

        private java.lang.Iterable<java.lang.Object> allParameters()
                                                            throws java.lang.Throwable
        Throws:
        java.lang.Throwable
      • getParametersMethod

        private FrameworkMethod getParametersMethod()
                                             throws java.lang.Exception
        Throws:
        java.lang.Exception
      • createTestsForParameters

        private java.util.List<TestWithParameters> createTestsForParameters​(java.lang.Iterable<java.lang.Object> allParameters,
                                                                            java.lang.String namePattern)
                                                                     throws java.lang.Exception
        Throws:
        java.lang.Exception
      • parametersMethodReturnedWrongType

        private java.lang.Exception parametersMethodReturnedWrongType()
                                                               throws java.lang.Exception
        Throws:
        java.lang.Exception
      • createTestWithParameters

        private static TestWithParameters createTestWithParameters​(TestClass testClass,
                                                                   java.lang.String pattern,
                                                                   int index,
                                                                   java.lang.Object[] parameters)