junit Tutorial
Erste Schritte mit junit
Suche…
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:
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
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());
}
}
@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.
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