Uruchamianie dwóch tych samych testów z różnymi argumentami

Question

Mam test z 15-20 różnymi testami, chcę uruchomić ten sam test z dwukrotnie dwoma różnymi parametrami, które mają zostać przekazane do metody BeforeClass testu, na przykład:

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 
} 

Jak widać jedyna różnica pomiędzy tymi dwoma testami jest w metodzie setup, który przechodzi różne wartości do konstruktora ClassToTest. Nie chcę replikować metod testowych w obu klasach, ale wolałbym dziedziczenie lub inny inteligentny sposób osiągnięcia tego w jednej klasie.

Answer 1

Wydaje się to doskonałym przykładem użycia JUnit4's @Parameters; patrz https://blogs.oracle.com/jacobc/entry/parameterized_unit_tests_with_junit lub http://www.mkyong.com/unittest/junit-4-tutorial-6-parameterized-test/. Powiedział, że będziesz musiał przenieść inicjalizację z metody setUp do konstruktora dla klasy testowej.

Answer 2

Zgodnie z dokumentacją (http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html):

Podklasa nie dziedziczy prywatnych członków swojej klasie nadrzędnej . Jeśli jednak nadklasa ma publiczne lub chronione metody dostępu do jej prywatnych pól przez , mogą one być również używane przez podklasę.

Answer 3

Jak o tym:

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 
    } 

    .... 
} 

EDIT: Albo zachować metoda odliczanie:

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

Na co warto, oto jak można to zrobić z 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

Dziękuję wszystkim za Twój q Odpowiedzi uick. To jak to zrobiłem w końcu

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); 
    } 
} 

zasadą jest klasa abstrakcyjna, która posiada wszystkie testy i FirstTest i SecondTest tworzenie własnych obiektów z różnymi parametrami i przekazać je do klasy abstrakcyjnej, aby go używać.