Ejecutando dos pruebas con argumentos diferentes

Question

Tengo una prueba con 15-20 casos de prueba diferentes, quiero ejecutar la misma prueba dos veces con dos parámetros diferentes que se supone pasan al método BeforeClass de la prueba, por ejemplo:

public class TestOne { 
    private static ClassToTest classToTest; 

    @BeforeClass 
    public static void setUp() throws Exception { 
     classToTest = new ClassToTest("Argument1", "Argument2"); 
    } 

    @Test 
    public void testOne() { 
    ........roughly 15 - 20 tests here 
} 

public class TestTwo { 
    private static ClassToTest classToTest; 

    @BeforeClass 
    public static void setUp() throws Exception { 
     classToTest = new ClassToTest("Argument3", "Argument4"); 
    } 

    @Test 
    public void testOne() { 
    ........roughly 15 - 20 tests here, same as in TestOne 
} 

Como se puede ver la única diferencia entre las dos pruebas es en el método de configuración, que pasa a valores diferentes para el constructor de la ClassToTest. No quiero replicar los métodos de prueba en ambas clases, pero preferiría heredar o alguna otra forma inteligente de lograr esto en una clase.

Answer 1

Esto parece un caso de uso perfecto para JUnit4 @Parameters; ver https://blogs.oracle.com/jacobc/entry/parameterized_unit_tests_with_junit o http://www.mkyong.com/unittest/junit-4-tutorial-6-parameterized-test/. Dicho esto, tendrás que mover la inicialización del método setUp a un constructor para la clase de prueba.

Answer 2

De acuerdo con la documentación (http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html):

Una subclase no hereda los miembros privados de su clase padre . Sin embargo, si la superclase tiene métodos públicos o protegidos para accediendo a sus campos privados, estos también pueden ser utilizados por la subclase.

Answer 3

¿Qué tal esto: contar O para mantener método de reducción::

public class TestOne { 
    private static ClassToTest classToTest1, classToTest2; 

    @BeforeClass 
    public static void setUp() throws Exception { 
     classToTest1 = new ClassToTest("Argument1", "Argument2"); 
     classToTest2 = new ClassToTest("Argument3", "Argument4"); 
    } 

    @Test 
    public void testOne() { 
     testOneImpl(classToTest1); 
     testOneImpl(classToTest2); 
    } 

    public void testOneImpl(ClassToTest classToTest) { 
     // exact samew as whatever your current testOne() test method is 
    } 

    .... 
} 

EDITAR

public class TestOne { 
    private static List<ClassToTest> classesToTest; 

    @BeforeClass 
    public static void setUp() throws Exception { 
     classesToTest = new ArrayList<>; 
     classesToTest.add(new ClassToTest("Argument1", "Argument2")); 
     classesToTest.add(new ClassToTest("Argument3", "Argument4")); 
    } 

    @Test 
    public void testOne() { 
     for (ClassToTest classToTest: classesToTest) { 
      ... same test content as before 
     } 
    } 

Answer 4

Por lo que vale la pena, aquí es cómo usted lo haría con TestNG:

public class TestFactory { 
    @Factory 
    public Object[] createTests() { 
    return new Object[] { 
     new ClassToTest("arg1", "arg2"), 
     new ClassToTest("arg3", "arg4") 
    }; 
    } 
} 

public class ClassToTest { 
    public ClassToTest(String arg1, String arg2) { 
    this.arg1 = arg1; 
    this.arg2 = arg2; 
    } 

    @Test 
    public void testOne() { 
    // use arg1 and arg2 
    } 
} 

Answer 5

Gracias a todos por su q uick responde. Esta es la forma en que lo hice finalmente

public abstract class Base { 
    final HeavyObject heavy; 

    protected Base(HeavyObject heavy) { 
     this.param = param; 
    } 

    @Test 
    public void test() { 
     param.doSomething(); 
    } 

    @Test 
    .............More tests here 

} 


public class FirstTest extends Base{ 

    private static HeavyObject param; 

    @BeforeClass 
    public static void init() { 
     param = new HeavyObject("arg1", "arg2"); 
    } 

    public FirstTest() { 
     super(param); 
    } 
} 

public class SecondTest extends Base{ 

    private static HeavyObject param; 

    @BeforeClass 
    public static void init() { 
     param = new HeavyObject("arg3", "arg4"); 
    } 

    public FirstTest() { 
     super(param); 
    } 
} 

base es una clase abstracta que tiene todas las pruebas y FirstTest y SecondTest crear sus propios objetos con diferentes parámetros y lo pasan a la clase abstracta para usarlo.