JUnit - Ein Framework für Unit Tests

Richard Cyganiak, Daniel Schulze

Inhalt

JUnit installieren
Unit Tests mit JUnit schreiben
Tests ablaufen lassen
Tests zu TestSuites zusammenfassen
Testorganisation
Tips und Tricks
Quellen

JUnit installieren

Gute IDEs wie JBuilder und Eclipse unterstützen JUnit "out-of-the-box", es muss nichts installiert werden!

Für die notepad-, UltraEdit- und vi-Benutzer: Erstmal JUnit hier runterladen und unzippen. Dann JUnit in den Classpath einbinden, z.B. unter Windows am DOS-Prompt:

set classpath=%classpath%;c:\pfad\zu\junit\junit.jar

Testen ob die Installation geklappt hat:

java junit.swingui.TestRunner

Fertig.

Unit Tests mit JUnit schreiben

Ein typischer Testfall besteht aus vier Schritten:

1. Testobjekte ("Fixtures") erzeugen, Dateien öffnen, Datenbank- und Netzwerkverbindungen öffnen
2. Operationen mit den Testobjekten durchführen
3. Ergebnisse dieser Operationen mit den erwarteten Ergebnissen vergleichen
4. (ggf. Dateien schließen, Verbindungen trennen, "aufräumen")

Man bringt die Testfälle in einer Klasse unter, die von junit.framework.TestCase abgeleitet wird.

In der Methode setUp() werden die Fixtures erzeugt (Schritt 1). Diese Methode wird vom Framework automatisch vor jedem Testfall aufgerufen.

Die einzelnen Testfälle, welches dieses Fixture benutzen, bringt man in Methoden mit Namen testXXXX() unter (Schritte 2 und 3).

Zum Überprüfen der Ergebnisse (Schritt 3) stellt JUnit eine Reihe von Methoden zur Verfügung:

assertTrue(boolean)
assertEquals(foo, bar)
assertNotNull(Object)
assertNull(Object)
assertSame(Object, Object)
fail()

Details zu diesen Methoden findet man in den JUnit-javadocs.

In der Methode tearDown() kann man das Fixture aufräumen (Schritt 4).

Beispiel: EuroTest.java (als HTML) und die getestete Klasse Euro.java (als HTML) (mit einem Fehler!)

Tests ablaufen lassen

JUnit hat drei User Interfaces:

• swingui
• awtui
• textui

Zum Starten der Tests gibt es mehrere Möglichkeiten.

Entweder ruft man JUnit direkt von der Kommandozeile auf:

javaw junit.swingui.TestRunner mypackage.MyTest
javaw junit.awtui.TestRunner mypackage.MyTest
java junit.textui.TestRunner mypackage.MyTest

Oder man lässt JUnit aus der main()-Methode der Testklasse starten:

    public static void main(String[] args) {
        junit.swingui.TestRunner.run(EuroTest.class);
    }

java mypackage.EuroTest

In jedem Fall muss junit.jar im classpath stehen!

Und so sieht es dann aus:

Das swingui User Interface

Das awtui User Interface

Das textui User Interface

Tests zu TestSuites zusammenfassen

Dazu fügt man in jede TestCase-Klasse folgende Methode ein (TestCaseName durch Klassenname ersetzen:

    public static Test suite() {
        return new TestSuite(TestCaseName.class);
    }

Nun leitet man eine neue Klasse von TestCase ab mit folgender Methode:

    public static Test suite() {
        TestSuite mySuite = new TestSuite();
        mySuite.add(MyTestCase1.suite());
        mySuite.add(MyTestCase2.suite());
        mySuite.add(MyTestCase3.suite());
        mySuite.add(MyTestCase4.suite());
        return mySuite;
    }

Diese Klasse fasst die verschiedenen TestCases zu einem Test zusammen und kann wie jeder andere TestCase gestartet werden.

Testorganisation

• TestCases in der gleichen package wie getesteter Code
• naheliegend: für jede zu testende Klasse eine eigene TestCase-Klasse
• oft sinnvoller: für jeden Satz von Fixtures eine eigene TestCase-Klasse
• alle TestCases einer Package zu einer TestSuite zusammenfassen
• diese möglichst bei jedem Kompiliervorgang ausführen
• die TestSuites aller Packages zu einer Haupt-TestSuite zusammenfassen
• diese auch regelmäßig, mindestens täglich, ablaufen lassen

Tips und Tricks

• Stellen Sie sicher, dass alle Tests voll automatisiert sind und ihre eigenen Resultate prüfen.
• Führen Sie möglichst nach jedem erfolgreichen Kompiliervorgang alle gesammelten Unit Tests aus.
• Schreiben Sie Tests, bevor Sie den Code schreiben, der diese Tests erfüllen soll, damit Sie sicherstellen, daß Ihr Code einfach zu testen ist. Außerdem wissen Sie so genau, wann Sie fertig sind.
• Schreiben Sie nur Tests für solchen Code, der unter Umständen fehlschlagen könnte.
• Denken Sie an die Grenzbedingungen, unter denen etwas schief gehen kann, und konzentrieren Sie Ihre Tests dort.
• Wenn Sie einen Bug Report bekommen, schreiben Sie zuerst einen Unit Test, der den Bug aufdeckt.
• Beobachten Sie den Return-on-Investment, wenn Sie Tests schreiben. Schreiben Sie nur Tests der Art, die ihren Aufwand wert sind. Aber lieber einen Test zuviel, als einen zuwenig.
• Testen Sie pro Testfallmethode nicht zuviel, nur eine ganz bestimmte Funktion und dabei immer nur eine interessante Randbedingung zurzeit, sonst verliert man bei Fehlern leicht den Überblick wo was schiefgeht.
• Zum effektiven Testen müssen Testfälle isoliert voneinander ausführbar sein. Treffen Sie deshalb keine Annahmen über die Reihenfolge, in der Testfälle ausgeführt werden. Führen Sie voneinander abhängige Tests stattdessen gemeinsam in einem Testfall aus.
• Organisieren Sie Testklassen um eine gemeinsame Fixture von Testobjekten, nicht um die getestete Klasse.

• Vergessen sie nicht Fehlersituationen zu testen, z.B. Exceptions (werden sie dort geworfen wo man will und unter der Bedingung die man will). Typischer Code:

      try {
          myObject.shouldThrowSomeException();
          fail("should have thrown SomeException");
      } catch (SomeException e) {}
  

• Wenn Sie Angst haben, dass Testen nicht alle Bugs aufhalten wird: Lassen Sie sich dadurch nicht davon abhalten, die Tests zu schreiben, die die meisten Bugs aufhalten werden.
• Für die Tests gilt der gleiche Qualitätsanspruch wie für den übrigen Code: selbstdokumentierend, kein duplizierter Code und möglichst einfach.
• Halten Sie Ideen sofort fest, verlieren Sie sie nicht wieder.
• Spendieren Sie Ihren Klassen ruhig zusätzliche öffentliche Methoden (public), wenn sie dadurch leichter getestet werden können.
• Refaktorisieren Sie Ihren Testcode genauso regelmäßig und sorgfältig wie ihren übrigen Code.
• Durch Testen kann man nicht beweisen das ein Programm 100% funktioniert. Aber man kann überprüfen, ob ein bestimmter Programmablauf so funktioniert wie man es will.

Quellen

www.junit.org - die JUnit-Homepage.

Frank Westphal: Unit Testing mit JUnit. http://www.frankwestphal.de/UnitTestingmitJUnit.html

Eine sehr gute deutschsprachige Einführung in JUnit. Das Euro-Beispiel stammt von dieser Seite.

Erich Gamma, Kent Beck: JUnitTest Infected: Programmers Love Writing Tests. http://junit.sourceforge.net/doc/testinfected/testing.htm

Sehr gute Einführung von den JUnit-Programmierern.

Martin Fowler: Refactoring. Improving the Design of Existing Code. Addison-Wesley, 1999