junitErste Schritte mit junit


Bemerkungen

JUnit ist ein einfaches Framework, um wiederholbare Tests für die Java-Programmiersprache zu schreiben. Es ist eine Instanz der xUnit-Architektur für Unit-Test-Frameworks.

Hauptmerkmale bestehen aus:

  • Assertionen , mit denen Sie das Testen von Werten in Ihren Tests anpassen können
  • Test Läufer, die Sie angeben können , wie die Tests in Ihrer Klasse laufen
  • Regeln , mit denen Sie das Verhalten von Tests in Ihrer Klasse flexibel ändern können
  • Suiten , mit denen Sie eine Reihe von Tests aus vielen verschiedenen Klassen zusammenstellen können

Nützliche Erweiterung für JUnit:

  • AssertJ : Fließende Behauptungen für Java
  • Mockito : Spottender Rahmen für Java

Versionen

Ausführung Veröffentlichungsdatum
JUnit 5 Meilenstein 2 2016-07-23
JUnit 5 Meilenstein 1 2016-07-07
JUnit 4.12 2016-04-18
JUnit 4.11 2012-11-14
JUnit 4.10 2011-09-28
JUnit 4.9 2011-08-22
JUnit 4.8 2009-12-01
JUnit 4.7 2009-07-28
JUnit 4.6 2009-04-14

Installation oder Setup

Da es sich bei JUnit um eine Java-Bibliothek handelt, müssen Sie zur Installation nur ein paar JAR-Dateien in den Klassenpfad Ihres Java-Projekts einfügen, und schon kann es losgehen.

Sie können diese beiden JAR-Dateien manuell herunterladen: junit.jar & hamcrest-core.jar .

Wenn Sie Maven verwenden, können Sie einfach eine Abhängigkeit in Ihre pom.xml :

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>
 

Wenn Sie Gradle verwenden, fügen Sie eine Abhängigkeit in Ihr build.gradle :

apply plugin: 'java'

dependencies {
    testCompile 'junit:junit:4.12'
}
 

Danach können Sie Ihre erste Testklasse erstellen:

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class MyTest {
    @Test
    public void onePlusOneShouldBeTwo() {
        int sum = 1 + 1;
        assertEquals(2, sum);
    }
}
 

und führen Sie es von der Kommandozeile aus:

  • Windows java -cp .;junit-X.YY.jar;hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest
  • Linux oder OsX java -cp .:junit-X.YY.jar:hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest

oder mit Maven: mvn test

@Vorher Nachher

Eine mit @Before annotierte Methode wird vor jeder Ausführung von @Test Methoden ausgeführt. Analog wird eine @After annotierte Methode nach jeder @Test Methode ausgeführt. Damit können Sie wiederholt eine Testeinstellung einrichten und nach jedem Test aufräumen. Die Tests sind also unabhängig und der Vorbereitungscode wird nicht in die @Test Methode kopiert.

Beispiel:

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class DemoTest {

    private List<Integer> list;

    @Before
    public void setUp() {
        list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(4);
        list.add(1);
        list.add(5);
        list.add(9);
    }

    @After
    public void tearDown() {
        list.clear();
    }

    @Test
    public void shouldBeOkToAlterTestData() {
        list.remove(0); // Remove first element of list.
        assertEquals(5, list.size()); // Size is down to five
    }

    @Test
    public void shouldBeIndependentOfOtherTests() {
        assertEquals(6, list.size());
    }
}
 

Mit @Before oder @After annotierte Methoden müssen public void und ohne Argumente sein.

Beispiel für den Test der Basiseinheit

Dieses Beispiel ist eine grundlegende Einrichtung zum Aufheben der Überprüfung von StringBuilder.toString () mit junit.

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class StringBuilderTest {

    @Test
    public void stringBuilderAppendShouldConcatinate()  {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("String");
        stringBuilder.append("Builder");
        stringBuilder.append("Test");

        assertEquals("StringBuilderTest", stringBuilder.toString());
    }

}
 

Erwartete Ausnahme abfangen

Es ist möglich, die Ausnahme leicht zu erfassen, ohne einen try catch Block auszuführen.

public class ListTest {
  private final List<Object> list = new ArrayList<>();

  @Test(expected = IndexOutOfBoundsException.class)
  public void testIndexOutOfBoundsException() {
    list.get(0);
  }
}
 

Das obige Beispiel sollte für einfachere Fälle ausreichen, wenn Sie die von der ausgelösten Ausnahme getragene Nachricht nicht prüfen möchten / müssen.

Wenn Sie Informationen zu Ausnahmen prüfen möchten, können Sie try / catch block verwenden:

@Test
public void testIndexOutOfBoundsException() {
    try {
        list.get(0);
        Assert.fail("Should throw IndexOutOfBoundException");
    } catch (IndexOutOfBoundsException ex) {
        Assert.assertEquals("Index: 0, Size: 0", ex.getMessage());
    }
}
 

In diesem Beispiel müssen Sie immer Assert.fail() hinzufügen, um sicherzustellen, dass der Test fehlschlägt, wenn keine Ausnahme ausgelöst wird.

Für ausführlichere Fälle verfügt JUnit über die ExpectedException @Rule , die auch diese Informationen testen kann und wie folgt verwendet wird:

public class SimpleExpectedExceptionTest {
     @Rule
     public ExpectedException expectedException = ExpectedException.none();

     @Test
     public void throwsNothing() {
         // no exception expected, none thrown: passes.
     }

     @Test
     public void throwsExceptionWithSpecificType() {
         expectedException.expect(NullPointerException.class);

         throw new NullPointerException();
     }

     @Test
     public void throwsExceptionWithSpecificTypeAndMessage() {
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Wanted a donut.");

         throw new IllegalArgumentException("Wanted a donut.");
     }
}
 

Testen von Ausnahmen in JUnit5

Um dies in JUnit 5 zu erreichen, verwenden Sie einen völlig neuen Mechanismus :

Die getestete Methode

public class Calculator {
    public double divide(double a, double b) {
        if (b == 0.0) {
            throw new IllegalArgumentException("Divider must not be 0");
        }
        return a/b;
    }
}
 

Die Testmethode

public class CalculatorTest {
    @Test
    void triangularMinus5() { // The test method does not have to be public in JUnit5
        Calculator calc = new Calculator();

        IllegalArgumentException thrown = assertThrows(
            IllegalArgumentException.class, 
            () -> calculator.divide(42.0, 0.0));
        // If the exception has not been thrown, the above test has failed.

        // And now you may further inspect the returned exception...
        // ...e.g. like this:
        assertEquals("Divider must not be 0", thrown.getMessage());
}
 

Tests ignorieren

Um einen Test zu ignorieren, fügen @Ignore einfach die Annotation @Ignore zum Test hinzu und geben Sie optional einen Parameter mit der Begründung an die Annotation.

@Ignore("Calculator add not implemented yet.")
@Test
public void testPlus() {
    assertEquals(5, calculator.add(2,3));
}
 

Verglichen mit dem Kommentieren des Tests oder dem Entfernen der @Test Test-Anmerkung wird der Testläufer weiterhin diesen Test melden und feststellen, dass er ignoriert wurde.

Es ist auch möglich, einen Testfall unter Verwendung von JUnit- Annahmen bedingt zu ignorieren. Ein Beispielanwendungsfall wäre, den Testfall erst auszuführen, nachdem ein bestimmter Fehler von einem Entwickler behoben wurde. Beispiel:

import org.junit.Assume;
import org.junit.Assert;
...

@Test 
public void testForBug1234() {

    Assume.assumeTrue(isBugFixed(1234));//will not run this test until the bug 1234 is fixed

    Assert.assertEquals(5, calculator.add(2,3));
}
 

Der Standard-Runner behandelt Tests mit fehlerhaften Annahmen als ignoriert. Es ist möglich, dass sich andere Läufer anders verhalten, zB sie als bestanden behandeln.

JUnit - Beispiele für grundlegende Anmerkungen

Hier sind einige grundlegende JUnit-Anmerkungen, die Sie verstehen sollten:

@BeforeClass – Run once before any of the test methods in the class, public static void 
@AfterClass – Run once after all the tests in the class has been run, public static void
@Before – Run before @Test, public void
@After – Run after @Test, public void
@Test – This is the test method to run, public void