Softwaretesting und Dokumentation

Softwaretesting und saubere Codedokumentation in Java

Qualitätssicherung ist ein entscheidender Aspekt in der Softwareentwicklung. Zwei wesentliche Säulen dabei sind das Testen von Software und eine aussagekräftige Dokumentation des Quellcodes.

Grundlagen des Softwaretestings

Softwaretests dienen dazu, Fehler (Bugs) zu identifizieren und sicherzustellen, dass die Software die Anforderungen erfüllt und stabil funktioniert. Es gibt verschiedene Teststufen:

• Unit-Tests (Komponententests)

  Hierbei werden die kleinsten testbaren Einheiten einer Anwendung (z.B. einzelne Methoden oder Klassen) isoliert getestet. Ziel ist es, die korrekte Funktion jeder Komponente zu überprüfen.

  Beispiel (Java mit JUnit):

  public class Calculator {
      public int add(int a, int b) {
          return a + b;
      }
  }
  
  // Testklasse
  import org.junit.jupiter.api.Test;
  import static org.junit.jupiter.api.Assertions.assertEquals;
  
  public class CalculatorTest {
      @Test
      void testAdd() {
          Calculator calculator = new Calculator();
          assertEquals(5, calculator.add(2, 3));
          assertEquals(0, calculator.add(-1, 1));
      }
  }

• Integrationstests

  Diese Tests überprüfen das Zusammenspiel mehrerer Komponenten oder Module. Hierbei wird getestet, ob die Schnittstellen zwischen den Komponenten korrekt funktionieren und Daten richtig ausgetauscht werden.

• Systemtests

  Hier wird das gesamte System als Einheit getestet, um zu überprüfen, ob es die funktionalen und nicht-funktionalen Anforderungen erfüllt. Systemtests simulieren oft realistische Benutzerszenarien.

• Akzeptanztests

  Diese Tests werden vom Kunden oder Endbenutzer durchgeführt, um zu bestätigen, dass die Software ihren Erwartungen entspricht und die Geschäftsanforderungen erfüllt. Sie sind oft die letzte Teststufe vor der Freigabe.

Saubere Codedokumentation in Java (Javadoc)

Guter Code ist selbsterklärend, aber selbst der beste Code benötigt eine Dokumentation, die das *Warum* und die übergeordneten Zusammenhänge erklärt. In Java ist Javadoc der Standard für die Codedokumentation.

• Zweck von Javadoc

  Javadoc ermöglicht es, Kommentare im Quellcode so zu formatieren, dass daraus automatisch HTML-Dokumentationen generiert werden können. Dies ist unerlässlich für die Wartung, Wiederverwendbarkeit und das Verständnis von APIs (Application Programming Interfaces).

• Wichtige Javadoc-Tags

  • @param <Parametername> <Beschreibung>: Beschreibt einen Parameter einer Methode.
  • @return <Beschreibung>: Beschreibt den Rückgabewert einer Methode.
  • @throws <AusnahmeKlasse> <Beschreibung>: Beschreibt eine Ausnahme, die von einer Methode geworfen werden kann.
  • @author <Name>: Gibt den Autor der Klasse an.
  • @version <Versionsnummer>: Gibt die Version der Klasse an.
  • @since <Version>: Gibt an, seit welcher Version die Klasse/Methode existiert.

• Beispiel für Javadoc

  /**
   * Diese Klasse repräsentiert eine einfache Person mit Namen und Alter.
   * Es können Informationen über die Person abgerufen und manipuliert werden.
   * @author Max Mustermann
   * @version 1.0
   * @since 2025-12-27
   */
  public class Person {
      private String name;
      private int alter;
  
      /**
       * Konstruktor für die Klasse Person.
       * Erstellt eine neue Person mit dem angegebenen Namen und Alter.
       * @param name Der Name der Person.
       * @param alter Das Alter der Person.
       * @throws IllegalArgumentException Wenn der Name null oder leer ist oder das Alter negativ ist.
       */
      public Person(String name, int alter) {
          if (name == null || name.trim().isEmpty()) {
              throw new IllegalArgumentException("Name darf nicht leer sein.");
          }
          if (alter < 0) {
              throw new IllegalArgumentException("Alter darf nicht negativ sein.");
          }
          this.name = name;
          this.alter = alter;
      }
  
      /**
       * Gibt den Namen der Person zurück.
       * @return Der Name der Person als String.
       */
      public String getName() {
          return name;
      }
  
      /**
       * Setzt den Namen der Person.
       * @param name Der neue Name der Person.
       * @throws IllegalArgumentException Wenn der Name null oder leer ist.
       */
      public void setName(String name) {
          if (name == null || name.trim().isEmpty()) {
              throw new IllegalArgumentException("Name darf nicht leer sein.");
          }
          this.name = name;
      }
  
      /**
       * Gibt das Alter der Person zurück.
       * @return Das Alter der Person als Integer.
       */
      public int getAlter() {
          return alter;
      }
  
      /**
       * Setzt das Alter der Person.
       * @param alter Das neue Alter der Person.
       * @throws IllegalArgumentException Wenn das Alter negativ ist.
       */
      public void setAlter(int alter) {
          if (alter < 0) {
              throw new IllegalArgumentException("Alter darf nicht negativ sein.");
          }
          this.alter = alter;
      }
  }
  

Übungsaufgabe: Testen und Dokumentieren einer einfachen Funktion

Aufgabenstellung: Erstelle eine Java-Klasse StringUtil mit einer statischen Methode reverseString(String input), die einen übergebenen String umkehrt. Schreibe anschließend eine JUnit-Testklasse StringUtilTest, die mindestens drei Testfälle für die reverseString-Methode enthält (z.B. für einen normalen String, einen leeren String, einen Palindrom-String). Kommentiere die Klasse und die Methode reverseString vollständig mit Javadoc-Tags.

Hinweise zur Lösung: Achte auf Edge Cases (z.B. leere Eingaben) in deinen Tests und auf die korrekte Verwendung der Javadoc-Tags (@param, @return).

Schwierigkeitsgrad: mittel

Erwartete Bearbeitungszeit: 30 Minuten