Erstellen Sie mehrere Parametersätze in einer parametrisierten Klasse (Junit)

Ja. Es gibt nichts spezielles, das Sie zu tun haben. Für jeden Satz von Wert(en) der Parameter, jeder @Test-Methode einmal ausgeführt wird, so haben gerade eine Methode test, add() und eine andere Methode testen, subtrahieren().

Kann ich auch hinzufügen, dass die person, die diktiert diese Anforderung ist falsch. Es gibt wenig Wert in das vorschreiben bestimmter design patterns "für alle Fälle" - könnte genauso gut mieten trainierten Affen.

InformationsquelleAutor der Antwort Bohemian

Ich bin mir sicher, dass Sie nicht mit diesem problem nicht mehr, aber ich dachte der 3 Möglichkeiten, wie Sie dies tun können, jeder mit seinen vor-und Nachteile. Mit der Parametrisierten Läufer, müssen Sie einen workaround.

- Mit mehr Parametern mit Parametrisierten

In Fall müssen Sie zum laden der Parameter extern, fügen Sie einfach einen parameter für die erwarteten Ergebnisse.

Profis: weniger codieren und es läuft alles tests.

Nachteile: neue Parameter für jeden anderen Satz von tests.

@RunWith(Parameterized.class)
public class CalculatorTest extends TestCase {
    private Calculator calculator;
    private int operator1;
    private int operator2;
    private int expectedSum;
    private int expectedSub;

    public CalculatorTest(int operator1, int operator2, int expectedSum, int expectedSub) {
        this.operator1 = operator1;
        this.operator2 = operator2;
    }

    @Params
    public static Collection<Object[]> setParameters() {
        Collection<Object[]> params = new ArrayList<>();
        //load the external params here
        //this is an example
        params.add(new Object[] {2, 1, 3, 1});
        params.add(new Object[] {5, 2, 7, 3});

        return params;
    }

    @Before
    public void createCalculator() {
        calculator = new Calculator();
    }

    @Test
    public void addShouldAddTwoNumbers() {
        assertEquals(expectedSum, calculator.add(operator1, operator2));
    }

    @Test
    public void subtractShouldSubtractTwoNumbers() {
        assertEquals(expectedSub, calculator.subtract(operator1, operator2));
    }

    @After
    public void endTest() {
        calculator = null;
        operator1 = null;
        operator2 = null;
        expectedSum = null;
        expectedSub = null;
    }
}

- Nicht mit Parametrisierten Läufer

Dies funktioniert gut, wenn Sie den Parameter programmgesteuert.

Profis: Sie können so viele tests wie Sie wollen, ohne eine riesige Menge von Parametern.

Nachteile: Weitere Codierung, und es Stoppt bei dem ersten Fehler (die möglicherweise nicht zu einer con).

@RunWith(JUnit4.class)
public class CalculatorTest extends TestCase {
    private Calculator calculator;

    @Before
    public void createCalculator() {
        calculator = new Calculator();
    }

    @Test
    public void addShouldAddTwoNumbers() {
        int[] operator1 = {1, 3, 5};
        int[] operator2 = {2, 7, 9};
        int[] expectedResults = {3, 10, 14};

        for (int i = 0; i < operator1.length; i++) {
            int actualResult = calculator.add(operator1[i], operator2[i]);
            assertEquals(expectedResults[i], actualResult);
        }
    }

    @Test
    public void subtractShouldSubtractTwoNumbers() {
        int[] operator1 = {5, 8, 7};
        int[] operator2 = {1, 2, 10};
        int[] expectedResults = {4, 6, -3};

        for (int i = 0; i < operator1.length; i++) {
            int actualResult = calculator.subtract(operator1[i], operator2[i]);
            assertEquals(expectedResults[i], actualResult);
        }
    }

    @After
    public void endTest() {
        calculator = null;
    }
}

- Mit JUnitParams

Ich habe keine Verbindung mit der Pragmatiker, ich habe gerade vor ein paar Tagen. Dieses framework läuft auf Basis von JUnit und Griffe parametrisierte tests anders. Die Parameter direkt übergeben werden, um die test-Methode, so können Sie in der gleichen Klasse unterschiedliche Parameter für verschiedene Methoden.

Profis: erzielt die gleichen Ergebnisse wie die oben genannten Lösungen ohne workarounds.

Nachteile: vielleicht ist Ihr Unternehmen nicht erlauben, fügen Sie eine neue Abhängigkeit zu der Projekt-oder zwingt Sie dazu verwenden, einige bizarre-coding-Regel (wie die Verwendung der Parametrisierten Läufer ausschließlich). Let ' s face it, es passiert mehr als wir möchten.

Hier's ein schönes Beispiel für JUnitParams in Aktion, und Sie können das Projekt/den code auf dieser Github Seite.

InformationsquelleAutor der Antwort Tarek

Anderen reinen JUnit, aber dennoch elegante Lösung aus meiner Sicht zu Kapseln, jeder parametrisierten test(s) in Ihre eigene innere statische Klasse, und verwenden Sie die Beiliegend test runner auf die top-level-test-Klasse. Dies ermöglicht Ihnen nicht nur, um verschiedene parameter-Werte für jeden test, die unabhängig voneinander aber auch zum testen von Methoden mit ganz unterschiedlichen Parametern.

Dies ist, wie es Aussehen würde:

@RunWith(Enclosed.class)
public class CalculatorTest {

  @RunWith(Parameterized.class)
  public static class AddTest {

    @Parameters
    public static Collection<Object[]> data() {
      return Arrays.asList(new Object[][] {
          { 23.0, 5.0, 28.0 }
      });
    }

    private Double a, b, expected;

    public AddTest(Double a, Double b, Double expected) {
      this.a = a;
      this.b = b;
      this.expected = expected;
    }

    @Test
    public void testAdd() {
      assertEquals(expected, Calculator.add(a, b));
    }
  }

  @RunWith(Parameterized.class)
  public static class SubstractTest {

    @Parameters
    public static Collection<Object[]> data() {
      return Arrays.asList(new Object[][] {
          { 3.0, 2.0, 1.0 }
      });
    }

    @Parameter(0)
    private Double a;
    @Parameter(1)
    private Double b;
    @Parameter(2)
    private Double expected;

    @Test
    public void testSubstract() {
      assertEquals(expected, Calculator.substract(a, b));
    }
  }

  @RunWith(Parameterized.class)
  public static class MethodWithOtherParametersTest {

    @Parameters
    public static Collection<Object[]> data() {
      return Arrays.asList(new Object[][] {
          { 3.0, 2.0, "OTHER", 1.0 }
      });
    }

    private Double a;
    private BigDecimal b;
    private String other;
    private Double expected;

    public MethodWithOtherParametersTest(Double a, BigDecimal b, String other, Double expected) {
      this.a = a;
      this.b = b;
      this.other = other;
      this.expected = expected;
    }

    @Test
    public void testMethodWithOtherParametersTest() {
      assertEquals(expected, Calculator.methodWithOtherParametersTest(a, b, other));
    }
  }

  public static class OtherNonParameterizedTests {

    //here you can add any other test which is not parameterized

    @Test
    public void otherTest() {
      //test something else
    }
  }
}

Hinweis: die Nutzung der @Parameter Anmerkung in der SubstractTestdie halte ich für besser lesbar. Aber das ist mehr eine Frage des Geschmacks.

InformationsquelleAutor der Antwort Alex