junit Zelfstudie
Aan de slag met junit

Opmerkingen

versies

Installatie of instellingen

Omdat JUnit een Java-bibliotheek is, hoeft u alleen maar een paar JAR-bestanden toe te voegen aan het classpath van uw Java-project en bent u klaar om te beginnen.

U kunt deze twee JAR-bestanden handmatig downloaden: junit.jar & hamcrest-core.jar .

Als u Maven gebruikt, kunt u eenvoudig een afhankelijkheid toevoegen aan uw pom.xml :

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

Of als u Gradle gebruikt, voeg dan een afhankelijkheid toe aan uw build.gradle :

apply plugin: 'java'

dependencies {
    testCompile 'junit:junit:4.12'
}

Hierna kunt u uw eerste testklasse maken:

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class MyTest {
    @Test
    public void onePlusOneShouldBeTwo() {
        int sum = 1 + 1;
        assertEquals(2, sum);
    }
}

en voer het uit vanaf de opdrachtregel:

• Windows java -cp .;junit-X.YY.jar;hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest
• Linux of OsX java -cp .:junit-X.YY.jar:hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest -cp java -cp .:junit-X.YY.jar:hamcrest-core-XYjar org.junit.runner.JUnitCore MyTest

of met Maven: mvn test

Testvoorbeeld basiseenheid

Dit voorbeeld is een basisinstelling voor het ongedaan maken van een test voor StringBuilder.toString () met behulp van 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());
    }

}

@Voor na

Voor elke uitvoering van @Test methoden wordt een geannoteerde methode met @Before uitgevoerd. Analoge @After geannoteerde @After methode wordt uitgevoerd na elke @Test methode. Dit kan worden gebruikt om herhaaldelijk een testinstelling in te stellen en na elke test op te ruimen. De tests zijn dus onafhankelijk en de voorbereidingscode wordt niet binnen de @Test methode gekopieerd.

Voorbeeld:

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());
    }
}

Methoden die zijn geannoteerd met @Before of @After moeten public void en zonder argumenten.

Vangst verwachte uitzondering

Het is mogelijk om de uitzondering gemakkelijk te vangen zonder enige try catch -blok.

public class ListTest {
  private final List<Object> list = new ArrayList<>();

  @Test(expected = IndexOutOfBoundsException.class)
  public void testIndexOutOfBoundsException() {
    list.get(0);
  }
}

Het bovenstaande voorbeeld zou moeten volstaan voor eenvoudiger gevallen, wanneer u het bericht van de geworpen uitzondering niet wilt / moet controleren.

Als u informatie over uitzonderingen wilt controleren, kunt u het try / catch-blok gebruiken:

@Test
public void testIndexOutOfBoundsException() {
    try {
        list.get(0);
        Assert.fail("Should throw IndexOutOfBoundException");
    } catch (IndexOutOfBoundsException ex) {
        Assert.assertEquals("Index: 0, Size: 0", ex.getMessage());
    }
}

Voor dit voorbeeld moet u er rekening mee houden dat u altijd Assert.fail() moet toevoegen om ervoor te zorgen dat de test mislukt wanneer er geen uitzondering wordt gegenereerd.

Voor meer gedetailleerde gevallen heeft JUnit de ExpectedException @Rule , die deze informatie ook kan testen en als volgt wordt gebruikt:

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.");
     }
}

Uitzonderingen testen in JUnit5

Om hetzelfde te bereiken in JUnit 5, gebruikt u een volledig nieuw mechanisme :

De geteste 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;
    }
}

De test methode

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 negeren

Om een test te negeren, voegt u eenvoudig de annotatie @Ignore aan de test en geeft u optioneel een parameter voor de annotatie met de reden.

@Ignore("Calculator add not implemented yet.")
@Test
public void testPlus() {
    assertEquals(5, calculator.add(2,3));
}

Vergeleken met het becommentariëren van de test of het verwijderen van de @Test annotatie, zal de @Test deze test nog steeds melden en vaststellen dat deze is genegeerd.

Het is ook mogelijk om een testcase voorwaardelijk te negeren met behulp van JUnit- aannames . Een voorbeeld van een use-case zou zijn om de test-case alleen uit te voeren nadat een bepaalde bug door een ontwikkelaar is opgelost. Voorbeeld:

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));
}

De standaardagent behandelt tests met falende veronderstellingen als genegeerd. Het is mogelijk dat andere hardlopers zich anders gedragen, bijvoorbeeld door ze als geslaagd te behandelen.

JUnit - eenvoudige annotatievoorbeelden

Hier zijn enkele standaard JUnit-annotaties die je moet begrijpen:

@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