Assertion

Eine Assertion (deutsch: Zusicherung) ist eine programmatische Anweisung, die überprüft, ob eine bestimmte Bedingung zur Laufzeit wahr ist. Wenn die Bedingung erfüllt ist, läuft das Programm normal weiter. Ist sie jedoch falsch, wird ein Fehler ausgelöst - typischerweise ein AssertionError. Assertions dienen dazu, Annahmen des Entwicklers über den Programmzustand explizit zu machen und automatisch zu überprüfen.

Der Begriff wurde 1967 von Robert Floyd in seinem Artikel "Assigning Meanings to Programs" formalisiert. Assertions sind heute ein fundamentales Werkzeug in der Softwareentwicklung - sowohl für das Debugging während der Entwicklung als auch für automatisierte Unit-Tests. Sie helfen dabei, Fehler frühzeitig zu erkennen, bevor sie zu schwer auffindbaren Bugs in der Produktion führen.

Wofür werden Assertions verwendet?

Assertions haben zwei Hauptanwendungsgebiete: die Überprüfung von Programmannahmen während der Entwicklung und die Verifizierung von Ergebnissen in Unit-Tests.

Assertions zur Laufzeitüberprüfung

In der Entwicklungsphase kannst du Assertions verwenden, um sicherzustellen, dass bestimmte Bedingungen erfüllt sind. Das ist besonders nützlich bei:

• Vorbedingungen (Preconditions): Überprüfung, ob Eingabeparameter gültig sind
• Nachbedingungen (Postconditions): Überprüfung, ob das Ergebnis einer Operation korrekt ist
• Invarianten: Überprüfung, ob bestimmte Zustände während der gesamten Programmausführung gelten

Für angehende Fachinformatiker für Anwendungsentwicklung sind Assertions ein wichtiges Thema. Sie tauchen in der Prüfung häufig im Zusammenhang mit Softwarequalität, Testverfahren und defensiver Programmierung auf. Das Verständnis von Design by Contract und der Unterschied zwischen Assertions und Exceptions sind prüfungsrelevante Konzepte.

Im Berufsalltag wirst du Assertions vor allem beim Schreiben von Unit-Tests und beim Debugging verwenden. Die Fähigkeit, gute Assertions zu formulieren, ist ein Zeichen für saubere, wartbare Codebasis und professionelle Softwareentwicklung.

Quellen und weiterführende Links

• Oracle: Programming With Assertions - Offizielle Java-Dokumentation zu Assertions
• Python: Assert Statement - Python-Dokumentation zur assert-Anweisung
• Jest Documentation: Expect - Assertion-Methoden im Jest-Framework
• Design by Contract - Eiffel - Ursprüngliche DbC-Dokumentation
• Wikipedia: Assertion (Informatik) - Grundlegende Erklärung mit historischem Kontext

Java

Java unterstützt Assertions seit Version 1.4 mit dem assert-Schlüsselwort. Eine Besonderheit: Assertions sind standardmäßig deaktiviert und müssen beim Programmstart mit der Option -ea (enable assertions) aktiviert werden.

// Einfache Assertion
assert alter >= 0;

// Assertion mit Fehlermeldung
assert alter >= 0 : "Alter darf nicht negativ sein: " + alter;

// Beispiel: Methode mit Vor- und Nachbedingung
public double berechneWurzel(double zahl) {
    // Vorbedingung: Zahl muss positiv sein
    assert zahl >= 0 : "Wurzel aus negativer Zahl nicht möglich";
    
    double ergebnis = Math.sqrt(zahl);
    
    // Nachbedingung: Ergebnis muss korrekt sein
    assert Math.abs(ergebnis * ergebnis - zahl) < 0.0001;
    
    return ergebnis;
}

Python

Python bietet eine einfache assert-Anweisung, die einen AssertionError auslöst, wenn die Bedingung falsch ist. Mit der Option -O können Assertions beim Start des Interpreters deaktiviert werden.

# Einfache Assertion
assert len(liste) > 0

# Assertion mit Fehlermeldung
assert alter >= 18, "Person muss volljährig sein"

# Praktisches Beispiel: Funktion mit Validierung
def durchschnitt(werte):
    assert len(werte) > 0, "Liste darf nicht leer sein"
    assert all(isinstance(w, (int, float)) for w in werte), "Nur Zahlen erlaubt"
    
    return sum(werte) / len(werte)

JavaScript

JavaScript hat kein natives assert-Schlüsselwort. Stattdessen werden Assertions über Test-Frameworks wie Jest, Mocha oder die Assertion-Bibliothek Chai implementiert. Node.js bietet ein eingebautes assert-Modul.

// Node.js assert-Modul
const assert = require('assert');
assert.strictEqual(ergebnis, 42, 'Ergebnis sollte 42 sein');

// Jest Test-Framework
test('Addition funktioniert korrekt', () => {
    expect(addiere(2, 3)).toBe(5);
    expect(addiere(-1, 1)).toBe(0);
});

// Chai (BDD-Style)
const { expect } = require('chai');
expect(benutzer).to.have.property('name');
expect(liste).to.have.lengthOf(3);

Design by Contract

Design by Contract (DbC) ist ein von Bertrand Meyer entwickeltes Softwaredesign-Konzept, das Assertions systematisch einsetzt. Die Idee: Jede Methode hat einen "Vertrag" mit dem aufrufenden Code, bestehend aus Vorbedingungen, Nachbedingungen und Klasseninvarianten.

Wenn eine Vorbedingung verletzt wird, liegt der Fehler beim aufrufenden Code. Wenn eine Nachbedingung verletzt wird, liegt der Fehler in der aufgerufenen Methode. Diese klare Verantwortungsverteilung erleichtert das Debugging erheblich.

Best Practices für Assertions

Um Assertions effektiv einzusetzen, solltest du einige wichtige Grundsätze beachten:

• Keine Seiteneffekte: Assertions sollten den Programmzustand nicht verändern, da sie möglicherweise deaktiviert werden
• Keine Eingabevalidierung: Für die Überprüfung von Benutzereingaben solltest du Exceptions verwenden, nicht Assertions
• Aussagekräftige Fehlermeldungen: Gib immer eine klare Beschreibung an, was schiefgelaufen ist
• Nicht übermäßig verwenden: Assertions sollten kritische Annahmen überprüfen, nicht jeden trivialen Zustand

// FALSCH: Assertion mit Seiteneffekt
assert liste.remove(element) != null;  // Entfernt Element auch wenn Assertions deaktiviert!

// RICHTIG: Seiteneffekt vor der Assertion
Object entfernt = liste.remove(element);
assert entfernt != null;

// FALSCH: Assertion für Benutzereingaben
assert benutzereingabe != null;  // Könnte in Produktion deaktiviert sein!

// RICHTIG: Exception für Benutzereingaben
if (benutzereingabe == null) {
    throw new IllegalArgumentException("Eingabe darf nicht leer sein");
}

Assertions vs. Exceptions

Ein häufiges Missverständnis ist die Verwechslung von Assertions und Exceptions. Beide behandeln Fehlersituationen, aber auf unterschiedliche Weise:

Faustregel: Verwende Assertions für Bedingungen, die niemals falsch sein sollten, wenn dein Code korrekt ist. Verwende Exceptions für Situationen, die auch bei korrektem Code auftreten können (z.B. Netzwerkfehler, ungültige Benutzereingaben).

Assertions in Unit-Tests: Das AAA-Pattern

In Unit-Tests folgen Assertions typischerweise dem Arrange-Act-Assert (AAA) Pattern. Dieses Muster strukturiert Tests in drei klare Phasen:

@Test
void testKontoAbhebung() {
    // Arrange: Testdaten vorbereiten
    Konto konto = new Konto(1000.00);
    
    // Act: Die zu testende Aktion ausführen
    boolean erfolg = konto.abheben(300.00);
    
    // Assert: Ergebnis überprüfen
    assertTrue(erfolg);
    assertEquals(700.00, konto.getKontostand(), 0.01);
}

Moderne Test-Frameworks bieten viele spezialisierte Assertion-Methoden wie assertEquals(), assertTrue(), assertNull(), assertThrows() und viele mehr. Diese liefern bei Fehlern aussagekräftigere Meldungen als ein einfaches assert.

Assertions in der Ausbildung