Institute of Information Science - University of Miskolc

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.