Hier is een voorbeeld van hoe je unit tests voor je Calculator-klasse kunt schrijven met JUnit 5, gericht op het testen van de methoden add en subtract met positieve getallen. Voorbeeld van de Calculator-klasse: ```java public class Calculator { public int add(int a, int b) { return a + b; } public int subtract(int a, int b) { return a - b; } } ``` Unit tests met JUnit 5: ```java import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; public class CalculatorTest { private final Calculator calculator = new Calculator(); @Test void testAddPositieveGetallen() { int result = calculator.add(5, 3); assertEquals(8, result, "De optelling van 5 en 3 zou 8 moeten zijn"); } @Test void testSubtractPositieveGetallen() { int result = calculator.subtract(10, 4); assertEquals(6, result, "De aftrekking van 4 van 10 zou 6 moeten zijn"); } } ``` Uitleg waarom deze tests effectief zijn: - Ze controleren de basisfunctionaliteit van de methoden add en subtract met positieve getallen. - Ze gebruiken `assertEquals` om te verifiëren dat het resultaat overeenkomt met de verwachte waarde. - Ze hebben duidelijke testnamen die aangeven wat er wordt getest. - Door verschillende inputwaarden te testen, wordt verzekerd dat de methoden correct werken voor positieve getallen. Deze tests vormen een goede basis en kunnen verder uitgebreid worden met tests voor bijvoorbeeld negatieve getallen, nul, of grote getallen om de robuustheid van je Calculator te waarborgen.

Hier is een voorbeeld van JUnit 5 tests voor je Calculator klasse: ```java import org.junit.jupiter.api.Test; import org.junit.jupiter.api.BeforeEach; import static org.junit.jupiter.api.Assertions.assertEquals; public class CalculatorTest { private Calculator calculator; @BeforeEach void setUp() { calculator = new Calculator(); } @Test void testAdd_PositiveNumbers_ReturnsCorrectSum() { // Arrange int a = 5; int b = 3; // Act int result = calculator.add(a, b); // Assert assertEquals(8, result, "5 + 3 moet 8 zijn"); } @Test void testAdd_AnotherPositiveNumbers_ReturnsCorrectSum() { // Arrange int a = 10; int b = 15; // Act int result = calculator.add(a, b); // Assert assertEquals(25, result, "10 + 15 moet 25 zijn"); } @Test void testSubtract_PositiveNumbers_ReturnsCorrectDifference() { // Arrange int a = 10; int b = 4; // Act int result = calculator.subtract(a, b); // Assert assertEquals(6, result, "10 - 4 moet 6 zijn"); } @Test void testSubtract_LargerNumberFromSmaller_ReturnsNegativeResult() { // Arrange int a = 3; int b = 8; // Act int result = calculator.subtract(a, b); // Assert assertEquals(-5, result, "3 - 8 moet -5 zijn"); } } ``` **Waarom deze tests effectief zijn:** 1. **Arrange-Act-Assert patroon**: Elke test is gestructureerd volgens dit patroon, wat de leesbaarheid verbetert 2. **@BeforeEach**: Zorgt dat voor elke test een nieuwe Calculator instantie wordt gemaakt, waardoor tests geïsoleerd zijn 3. **Descriptieve testnamen**: De namen beschrijven duidelijk wat er getest wordt (methode_scenario_verwachting) 4. **Meerdere testgevallen**: Verschillende combinaties van positieve getallen worden getest 5. **Duidelijke assertions**: Met beschrijvende foutmeldingen voor betere debugging 6. **Geen afhankelijkheden**: Zoals gevraagd, geen mocks nodig voor deze eenvoudige klasse **Vergeet niet** om de Calculator klasse zelf te implementeren: ```java public class Calculator { public int add(int a, int b) { return a + b; } public int subtract(int a, int b) { return a - b; } } ``` Deze tests dekken de basisfunctionaliteit en zorgen ervoor dat je optelling en aftrekking correct werken voor positieve getallen.