This is an old revision of the document!
1. A legfontosabb rész:
@Test
Ez mondja meg a JUnitnak, hogy ez egy tesztmetódus. Az assertion: assertEquals(5, result);
azt jelenti: elvárt érték = 5 tényleges érték = result
2. A legfontosabb assertionök Ezeket fogod a legtöbbször használni:
assertEquals(expected, actual); assertNotEquals(expected, actual); assertTrue(condition); assertFalse(condition); assertNull(value); assertNotNull(value);
Például: @Test void simpleAssertions() {
assertEquals(4, 2 + 2);
assertTrue(10 > 5);
assertFalse(3 > 10);
String name = "Oliver"; assertNotNull(name);
}
Nagyon fontos szokás: assertEquals(expected, actual);
tehát először az elvárt, utána a kapott érték. 3. Több teszt ugyanarra az osztályra Például bővítsük a Calculator osztályt: public class Calculator {
public int add(int a, int b) {
return a + b;
}
public int subtract(int a, int b) {
return a - b;
}
public int multiply(int a, int b) {
return a * b;
}
}
A teszt: class CalculatorTest {
@Test
void additionWorks() {
Calculator calculator = new Calculator();
assertEquals(5, calculator.add(2, 3)); }
@Test
void subtractionWorks() {
Calculator calculator = new Calculator();
assertEquals(7, calculator.subtract(10, 3)); }
@Test
void multiplicationWorks() {
Calculator calculator = new Calculator();
assertEquals(20, calculator.multiply(4, 5)); }
}
Mavenből: mvn test
VS Code-ban pedig az egyes @Test metódusok mellett is megjelenhet a Run Test gomb; a Java Test Runner JUnit 5-öt is támogatja. Visual Studio Code 4. @BeforeEach Gyakran ugyanazt az objektumot kell minden teszthez létrehoznunk. Ez: @Test void additionWorks() {
Calculator calculator = new Calculator();
assertEquals(5, calculator.add(2, 3));
}
@Test void subtractionWorks() {
Calculator calculator = new Calculator();
assertEquals(7, calculator.subtract(10, 3));
}
ismétli ezt: Calculator calculator = new Calculator();
Erre való a: @BeforeEach
Például: import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
class CalculatorTest {
private Calculator calculator;
@BeforeEach
void setUp() {
calculator = new Calculator();
}
@Test
void additionWorks() {
assertEquals(5, calculator.add(2, 3));
}
@Test
void subtractionWorks() {
assertEquals(7, calculator.subtract(10, 3));
}
}
A setUp() minden egyes teszt előtt lefut. Tehát: @BeforeEach
↓
@Test #1
@BeforeEach
↓
@Test #2
@BeforeEach
↓
@Test #3
Ez nagyon fontos unit testing minta. 5. @BeforeAll és @AfterAll Van olyan inicializáció, amit csak egyszer akarunk lefuttatni. @BeforeAll static void beforeAllTests() {
System.out.println("Tests starting...");
}
és a végén: @AfterAll static void afterAllTests() {
System.out.println("Tests finished.");
}
Teljes példa: import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test;
class ExampleTest {
@BeforeAll
static void beforeAll() {
System.out.println("START");
}
@Test
void testOne() {
System.out.println("testOne");
}
@Test
void testTwo() {
System.out.println("testTwo");
}
@AfterAll
static void afterAll() {
System.out.println("END");
}
}
6. Kivételek tesztelése: assertThrows Ez különösen fontos. Tegyük fel, hogy van osztás: public int divide(int a, int b) {
if (b == 0) {
throw new IllegalArgumentException("Division by zero");
}
return a / b;
}
Azt szeretnénk tesztelni, hogy nullával osztás esetén valóban kivételt kapunk: @Test void divisionByZeroThrowsException() {
Calculator calculator = new Calculator();
assertThrows(
IllegalArgumentException.class,
() -> calculator.divide(10, 0)
);
}
Ez nagyon tipikus JUnit 5 kód. Még jobb: @Test void divisionByZeroThrowsException() {
IllegalArgumentException exception =
assertThrows(
IllegalArgumentException.class,
() -> calculator.divide(10, 0)
);
assertEquals(
"Division by zero",
exception.getMessage()
);
}
Itt már nemcsak azt ellenőrizzük, hogy volt exception, hanem az üzenetét is. 7. assertAll Több dolgot egyszerre is ellenőrizhetsz: @Test void severalAssertions() {
int result = 10;
assertAll(
() -> assertTrue(result > 0),
() -> assertTrue(result < 100),
() -> assertEquals(10, result)
);
}
Előnye, hogy a JUnit megpróbálja az összes assertiont kiértékelni. 8. @DisplayName Olvasható nevet adhatsz a tesztnek: import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test;
class CalculatorTest {
@Test
@DisplayName("2 + 3 eredménye 5")
void additionWorks() {
Calculator calculator = new Calculator();
assertEquals(5, calculator.add(2, 3)); }
}
A VS Code Testing nézetében így sokkal érthetőbb lehet a teszt. 9. @Disabled Ideiglenesen kikapcsolhatsz egy tesztet: import org.junit.jupiter.api.Disabled;
@Test @Disabled void unfinishedTest() {
// még nincs kész
}
Vagy indoklással: @Disabled(“A funkció még nincs implementálva”)
10. Paraméterezett tesztek Ez a JUnit 5 egyik nagyon hasznos funkciója. Tegyük fel, hogy ezt akarjuk tesztelni: calculator.add(…)
Nem akarunk öt külön tesztet írni: assertEquals(3, calculator.add(1, 2)); assertEquals(7, calculator.add(3, 4)); assertEquals(0, calculator.add(-1, 1));
Használhatunk @ParameterizedTest-et: import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource;
import static org.junit.jupiter.api.Assertions.assertEquals;
class CalculatorTest {
private final Calculator calculator = new Calculator();
@ParameterizedTest
@CsvSource({
"1, 2, 3",
"3, 4, 7",
"-1, 1, 0",
"10, 20, 30"
})
void additionWorks(
int a,
int b,
int expected) {
assertEquals(
expected,
calculator.add(a, b)
);
}
}
Ez gyakorlatilag négyszer futtatja ugyanazt a tesztet különböző adatokkal. 11. @ValueSource Egyszerű paraméterlistához: @ParameterizedTest @ValueSource(ints = {1, 2, 3, 10, 100}) void positiveNumbersArePositive(int number) {
assertTrue(number > 0);
}
12. Jó teszt felépítése: Arrange – Act – Assert Ezt érdemes megszokni. @Test void additionWorks() {
// Arrange Calculator calculator = new Calculator();
// Act int result = calculator.add(2, 3);
// Assert assertEquals(5, result);
}
A három rész: Arrange ↓ előkészítjük a tesztet
Act ↓ meghívjuk a tesztelendő kódot
Assert ↓ ellenőrizzük az eredményt
Ez az egyik legfontosabb unit testing gondolkodásmód.