junit Samouczek
Rozpoczęcie pracy z junit
Szukaj…
Uwagi
JUnit to prosta platforma do pisania powtarzalnych testów dla języka programowania Java . Jest to instancja architektury xUnit dla platform testowania jednostkowego.
Główne cechy obejmują:
- Asercje , które pozwalają dostosować sposób testowania wartości w testach
- Testujący biegacze , którzy pozwalają określić, jak przeprowadzić testy w swojej klasie
- Reguły , które pozwalają elastycznie modyfikować zachowanie testów w klasie
- Pakiety , które pozwalają budować razem zestaw testów z wielu różnych klas
Przydatne rozszerzenie dla JUnit:
Wersje
Wersja | Data wydania |
---|---|
Kamień milowy JUnit 5 2 | 2016-07-23 |
Kamień milowy JUnit 5 1 | 07.07.2016 |
JUnit 4.12 | 18.04.2016 |
JUnit 4.11 | 14.11.2012 |
JUnit 4.10 | 28.09.2011 |
JUnit 4.9 | 2011-08-22 |
JUnit 4.8 | 01.12.2009 |
JUnit 4.7 | 2009-07-28 |
JUnit 4.6 | 14.04.2009 |
Instalacja lub konfiguracja
Ponieważ JUnit jest biblioteką Java, wystarczy zainstalować kilka plików JAR w ścieżce klas projektu Java i jesteś gotowy do pracy.
Możesz pobrać te dwa pliki JAR ręcznie: junit.jar i hamcrest-core.jar .
Jeśli używasz Maven, możesz po prostu dodać zależność do pom.xml
:
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
Lub jeśli używasz Gradle, dodaj zależność do swojego build.gradle
:
apply plugin: 'java'
dependencies {
testCompile 'junit:junit:4.12'
}
Następnie możesz utworzyć pierwszą klasę testową:
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class MyTest {
@Test
public void onePlusOneShouldBeTwo() {
int sum = 1 + 1;
assertEquals(2, sum);
}
}
i uruchom go z wiersza poleceń:
- Windows
java -cp .;junit-X.YY.jar;hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest
- Linux lub OsX
java -cp .:junit-X.YY.jar:hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest
lub za pomocą mvn test
Maven: mvn test
Przykład podstawowego testu jednostkowego
Ten przykład jest podstawową konfiguracją do odblokowania StringBuilder.toString () za pomocą 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());
}
}
@Przed po
Metoda z adnotacjami z @Before
będzie wykonywana przed każdym wykonaniem metod @Test
. Analogicznie metoda z adnotacją @After
jest wykonywana po każdej metodzie @Test
. Można tego użyć do wielokrotnego konfigurowania ustawienia Test i czyszczenia po każdym teście. Dlatego testy są niezależne, a kod przygotowawczy nie jest kopiowany w metodzie @Test
.
Przykład:
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());
}
}
Metody opatrzone adnotacją @Before
lub @After
muszą być public void
i bez argumentów.
Złap oczekiwany wyjątek
Możliwe jest łatwe złapanie wyjątku bez blokowania try catch
.
public class ListTest {
private final List<Object> list = new ArrayList<>();
@Test(expected = IndexOutOfBoundsException.class)
public void testIndexOutOfBoundsException() {
list.get(0);
}
}
Powyższy przykład powinien wystarczyć dla prostszych przypadków, gdy nie chcesz / nie musisz sprawdzać wiadomości przenoszonej przez zgłoszony wyjątek.
Jeśli chcesz sprawdzić informacje o wyjątku, możesz użyć bloku try / catch:
@Test
public void testIndexOutOfBoundsException() {
try {
list.get(0);
Assert.fail("Should throw IndexOutOfBoundException");
} catch (IndexOutOfBoundsException ex) {
Assert.assertEquals("Index: 0, Size: 0", ex.getMessage());
}
}
W tym przykładzie musisz pamiętać, aby zawsze dodawać Assert.fail()
aby upewnić się, że test zakończy się niepowodzeniem, gdy nie zostanie Assert.fail()
wyjątek.
W bardziej rozbudowanych przypadkach JUnit ma ExpectedException
@Rule
, który może również testować te informacje i jest używany w następujący sposób:
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.");
}
}
Testowanie wyjątków w JUnit5
Aby osiągnąć to samo w JUnit 5, używasz zupełnie nowego mechanizmu :
Testowana metoda
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;
}
}
Metoda testowa
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());
}
Ignorowanie testów
Aby zignorować test, po prostu dodaj do @Ignore
adnotację @Ignore
i opcjonalnie podaj parametr do adnotacji z podaniem przyczyny.
@Ignore("Calculator add not implemented yet.")
@Test
public void testPlus() {
assertEquals(5, calculator.add(2,3));
}
W porównaniu do komentowania testu lub usuwania adnotacji @Test
, osoba przeprowadzająca test nadal zgłosi ten test i zauważy, że został on zignorowany.
Możliwe jest również warunkowe zignorowanie przypadku testowego przy użyciu założeń JUnit. Przykładowym przypadkiem użycia byłoby uruchomienie przypadku testowego dopiero po naprawieniu określonego błędu przez programistę. Przykład:
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));
}
Domyślny biegacz traktuje testy z błędnymi założeniami jako ignorowane. Możliwe, że inni biegacze zachowują się inaczej, np. Traktują ich jak zaliczonych.
JUnit - podstawowe przykłady adnotacji
Oto kilka podstawowych adnotacji JUnit, które powinieneś zrozumieć:
@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