Definition des Bedingungsüberdeckungstests

Der Bedingungsüberdeckungstest, oft auch „Condition Coverage“ genannt, fokussiert sich auf die verschiedenen Bedingungen innerhalb einer Entscheidungsstruktur. Er zielt darauf ab, sicherzustellen, dass jede Bedingung mindestens einmal sowohl wahr als auch falsch getestet wird. Dies ermöglicht eine tiefgehende Analyse und stellt sicher, dass alle Bedingungszweige im Code überprüft werden.

Der Bedingungsüberdeckungstest gehört zu den Whitebox-Testmethoden. Bei Whitebox-Tests, auch als strukturbasierte oder gläserne Kasten-Tests bezeichnet, liegt der Fokus auf der internen Struktur des Codes. Der Tester hat vollen Einblick in den Quellcode und entwirft Testfälle basierend auf der inneren Logik und Struktur der Software.

Der Bedingungsüberdeckungstest speziell konzentriert sich darauf, dass jede einzelne Bedingung im Code sowohl wahr als auch falsch getestet wird. Damit untersucht er die internen Entscheidungsstrukturen und gewährleistet, dass alle möglichen Bedingungspfade abgedeckt sind.

Im Gegensatz dazu stehen Blackbox-Tests, bei denen der Tester keinen Einblick in den internen Code hat. Bei diesen Tests konzentriert man sich auf die Funktion der Software und darauf, ob sie die erwarteten Ergebnisse liefert, basierend auf den gegebenen Eingaben. Hierbei bleibt die innere Arbeitsweise der Software verborgen.

Entstehung des Bedingungsüberdeckungstests

Die wachsende Komplexität von Software-Systemen im Laufe der Zeit erforderte verbesserte Testmethoden. Während der Anweisungsüberdeckungstest sicherstellt, dass jede Anweisung ausgeführt wird, ging man mit dem Bedingungsüberdeckungstest einen Schritt weiter. Hier legt man den Fokus nicht nur auf die Anweisungen, sondern auch darauf, wie sie ausgeführt werden, abhängig von den gegebenen Bedingungen.

Effektives Vorgehen beim Bedingungsüberdeckungstest

1. Identifizierung der Entscheidungen: Zunächst identifiziert man alle Entscheidungsstrukturen im Code, wie z.B. if-, while- oder for-Statements.
2. Aufschlüsselung der Bedingungen: Jede Entscheidung kann mehrere Bedingungen haben. Diese Bedingungen trennt man und testet sie individuell.
3. Erstellung der Testfälle: Für jede identifizierte Bedingung entwickelt man Testfälle, die diese Bedingung sowohl wahr als auch falsch machen.
4. Ausführung und Auswertung: Nachdem die Testfälle entwickelt sind, führt man sie aus und wertet die Ergebnisse aus, um sicherzustellen, dass alle Bedingungen abgedeckt sind.

Beispiele für den Einsatz des Bedingungsüberdeckungstests

Beispiel 1: Ein einfaches If-Statement

if (A && B) {
    // Code
}

Hier gibt es zwei Bedingungen: A und B. Um eine vollständige Bedingungsüberdeckung zu gewährleisten, benötigt man Testfälle für:

• A = wahr, B = wahr
• A = wahr, B = falsch
• A = falsch, B = wahr
• A = falsch, B = falsch

Beispiel 2: Ein zusammengesetztes Statement

if (A && (B || C)) {
    // Code
}

Hier identifiziert man drei Bedingungen: A, B und C. Es ergeben sich diverse Testfälle, um sicherzustellen, dass jede Bedingung sowohl wahr als auch falsch getestet wird.

Interaktiv – Bedingungsüberdeckungstest mit einer Wetter-App

Bedienungsanleitung:

1. In das Feld „Stadt“ den Namen „München“ eingeben.
2. Zwischen „Aktueller Wetterbericht“ und „Wettervorhersage“ wählen, um den gewünschten Wettertyp zu bestimmen.
3. Auf „Prüfen“ klicken.
4. Die resultierende Ausgabe betrachten. Bei korrekter Eingabe erscheint entweder der aktuelle Wetterbericht oder die Wettervorhersage für München. Bei einer anderen Stadt zeigt eine Nachricht an, dass die Anwendung die Stadt nicht in der Datenbank finden kann. Wenn kein Wettertyp ausgewählt ist, erscheint eine Aufforderung zur Auswahl.

Fazit

Der Bedingungsüberdeckungstest stellt ein leistungsstarkes Werkzeug dar, um die Qualität von Software zu sichern. Indem man jede Bedingung gründlich testet, minimiert man das Risiko unentdeckter Fehler und gewährleistet eine robustere Anwendung. Es empfiehlt sich, diesen Test in Kombination mit anderen Testmethoden anzuwenden, um ein umfassendes Testniveau zu erreichen.

Der Beitrag Bedingungsüberdeckungstest – Jeden Codepfad analysieren und optimieren erschien zuerst auf CEOsBay.

Was ist die Zyklomatische Zahl?

Die Zyklomatische Zahl, auch als Zyklomatische Komplexität oder McCabe-Metrik bekannt, quantifiziert die Komplexität eines Programms oder einer Funktion basierend auf der Anzahl der linearen, unabhängigen Pfade durch den Code. Einfach ausgedrückt: Es handelt sich um eine Zahl, die angibt, wie viele verschiedene Wege es gibt, einen bestimmten Codeabschnitt auszuführen.

Entstehung

Thomas McCabe entwickelte die Zyklomatische Komplexität 1976. Er suchte nach einer Methode, die Komplexität von Software zu messen, um sowohl den Entwicklungsprozess zu verbessern als auch die Software-Qualität sicherzustellen. McCabes Forschung legte den Grundstein für viele der heutigen Softwaremetriken.

Vorgehensweise zur Bestimmung der Zyklomatischen Zahl

Die Bestimmung erfolgt durch die Formel:

V(G)=E−N+2P

wobei:

• V Die zyklomatische Komplexität
• G Kontrollflussgraph des Programms oder der Funktion, den man analysiert
• E Die Anzahl der Kanten im Kontrollflussgraphen
• N Die Anzahl der Knoten
• P Die Anzahl der verbundenen Komponenten (normalerweise 1 für einen zusammenhängenden Graphen) sind.

Anwendungsbeispiele

Qualitätssicherung: Ein hohes Maß an zyklomatischer Komplexität deutet auf einen Code hin, der schwer zu warten und zu testen ist. Ein niedriger Wert hingegen suggeriert einen einfacheren und wartungsfreundlicheren Code.

Software-Testing: Die Zyklomatische Zahl gibt an, wie viele Testfälle man mindestens benötigt, um jeden Pfad durch den Code einmal auszuführen. Dies erleichtert die Testplanung.

Praktische Beispiele

Bei der Betrachtung des nachfolgenden einfachen Codeausschnitts:

def beispiel_funktion(x): if x > 10: return "Groß" else: return "Klein"

Man stellt fest, dass die zyklomatische Komplexität dieses Codes 2 beträgt, da es zwei Pfade durch den Code gibt: Einmal, wenn die Bedingung wahr ist, und einmal, wenn sie falsch ist.

Ein komplexerer Code mit Schleifen und mehreren Bedingungen hätte entsprechend eine höhere zyklomatische Komplexität.

Zyklomatische Komplexität – Interaktive Visualisierung

Über die Anwendung:
Wie bereits erklärt, handelt es sich bei der zyklomatischen Komplexität um ein Software-Metriken-Indikator, der die Anzahl der linearen unabhängigen Pfade durch den Quellcode eines Programms misst. Sie dient als ein Maß für die Komplexität eines Programms. Diese interaktive Anwendung visualisiert diese Komplexität durch Knoten (entsprechend den Anweisungen/Blöcken in einem möglichen Code) und Verbindungen zwischen ihnen (entsprechend den Pfaden).

So wird die Anwendung verwendet:

1. Knoten hinzufügen/entfernen:
   Die Schaltflächen „Knoten hinzufügen“ und „Letzten Knoten entfernen“, um Knoten zum Diagramm hinzuzufügen bzw. zu entfernen.
2. Verbindungen erstellen:
   Klicken auf einen Knoten, um ihn auszuwählen (er wird markiert). Im Anschluss auf einen anderen Knoten klicken, um eine Verbindung zwischen den beiden Knoten herzustellen.
3. Knoten bewegen:
   Knoten ziehen, um seine Position im Diagramm zu verändern.
4. Zyklomatische Komplexität ablesen:
   Die zyklomatische Komplexität wird unter dem Diagramm angezeigt. Sie aktualisiert sich automatisch basierend auf der Anzahl der Knoten und Verbindungen in dem Diagramm.

Hinweis:
Die Visualisierung passt sich automatisch an, je nachdem, wie viele Knoten und Verbindungen man hinzufügt. Man kann mit verschiedenen Strukturen experimentieren, um ein besseres Verständnis für die zyklomatische Komplexität und ihre Bedeutung in der Softwareentwicklung zu erhalten.

Fazit

Die Zyklomatische Zahl bietet einen wertvollen Einblick in die Komplexität von Softwarecode. Sie ermöglicht Entwicklern und Testern, den Code besser zu verstehen, die Qualität zu bewerten und den Testaufwand einzuschätzen. Durch das Verständnis und die Anwendung dieses Konzepts können Softwareteams effizienter arbeiten und höherwertige Produkte liefern.

Der Beitrag Zyklomatische Komplexität – Messen. Verstehen. Optimieren. erschien zuerst auf CEOsBay.

Was ist der Entscheidungstabellentest?

Der Entscheidungstabellentest, auch bekannt als Decision Table Testing, ermöglicht die systematische Überprüfung von Systemverhalten auf Basis unterschiedlicher Eingaben. Hierbei steht die Kombination verschiedener Eingabeparameter und die resultierenden Ausgaben im Fokus.

Ursprung des Entscheidungstabellentests

Die Wurzeln des Entscheidungstabellentests liegen in den 1960er Jahren. Entwickler suchten nach einer Möglichkeit, die Verarbeitungslogik von Informationssystemen zu dokumentieren und zu verifizieren. Sie fanden in den Entscheidungstabellen ein effizientes Mittel, komplexe Geschäftsregeln und Entscheidungslogiken übersichtlich darzustellen.

Wie geht man den Entscheidungstabellentest an?

1. Identifikation der Entscheidungsparameter: Zuerst identifiziert man die relevanten Eingangsparameter und Ausgaben für den zu testenden Prozess oder das System.
2. Erstellung der Tabelle: Für jeden Eingangsparameter wird eine Zeile angelegt. Zusätzlich gibt es Zeilen für die jeweiligen Ausgaben. In den Spalten werden verschiedene Kombinationen der Eingaben und die dazugehörigen erwarteten Ausgaben dargestellt.
3. Ausarbeitung der Testfälle: Anhand der Tabelle lassen sich Testfälle erstellen, die alle möglichen Kombinationen von Eingaben abdecken.
4. Testdurchführung: Jeder Testfall wird nun gegen das System oder den Prozess ausgeführt und die tatsächlichen Ausgaben mit den erwarteten Ergebnissen verglichen.

Beispiele für den Einsatz vom Entscheidungstabellentest

• Online-Bestellsysteme: Bei einem Bestellsystem können verschiedene Parameter wie Artikelverfügbarkeit, Versandoptionen und Zahlungsmethoden kombiniert werden, um verschiedene Szenarien zu testen.
• Kreditsysteme in Banken: Banken können Entscheidungstabellen nutzen, um verschiedene Kreditantrags-Szenarien durchzuspielen, z.B. bei unterschiedlichen Einkommen, Kreditbeträgen oder Laufzeiten.
• Heizungssysteme: Bei der Entwicklung von intelligenten Heizungssystemen können unterschiedliche Temperatureinstellungen, Uhrzeiten und Modi kombiniert werden, um das Verhalten des Systems unter verschiedenen Bedingungen zu testen.

Genereller Überblick über die Struktur

1. Eingangsbedingungen (oben links): Dieser Bereich listet alle möglichen Eingabebedingungen oder -parameter auf.
2. Ausgabehandlungen (unten links): Hier werden die möglichen Ausgaben oder Aktionen des Systems aufgeführt.
3. Entscheidungsregeln (oben rechts): In diesem Abschnitt werden verschiedene Kombinationen der Eingabebedingungen aufgeführt. Jede Spalte repräsentiert einen Testfall.
4. Ergebnisse der Entscheidungsregeln (unten rechts): Hier werden die erwarteten Ausgaben für jede Regelkombination dargestellt.

Beispiel: Einfaches Online-Bestellsystem

Angenommen, wir haben ein einfaches Bestellsystem, in dem die Kunden entweder per Kreditkarte oder PayPal bezahlen können und es gibt eine Überprüfung, ob der Artikel vorrätig ist.

Für Regel 1 ist der Artikel verfügbar, und die Zahlung erfolgt per Kreditkarte. Für die Bestellung erfolgt die Akzeptanz und es gibt keinen Hinweis zur Nichtverfügbarkeit des Artikels. Bei Regel 3 ist der Artikel jedoch nicht verfügbar, und es spielt keine Rolle, welche Zahlungsmethode der User gewählt hat: Die Bestellung ist inakzeptabel und es erfolgt der Hinweis auf Nichtverfügbarkeit.

Auf diese Weise kann man verschiedene Kombinationen von Eingabeparametern testen und die erwarteten Ausgaben systematisch darstellen.

Konkrete Anwendung in der Praxis

Die vorherige Erklärung bietet einen generellen Überblick über die Struktur einer Entscheidungstabelle. Für eine konkrete Anwendung in der Praxis muss man oft spezifischere Details berücksichtigen. Nachfolgend ein detaillierteres Beispiel, um das Konzept besser zu illustrieren.

Rabattsystem eines Online-Shops

Ein Online-Shop bietet seinen Kunden Rabatte an, die auf der Gesamtmenge der gekauften Artikel und dem Kundenstatus basieren.

Regeln:

1. Standardkunden erhalten bei einer Bestellung von mehr als 10 Artikeln einen Rabatt von 5%.
2. Premiumkunden erhalten immer einen Rabatt von 5%.
3. Bei einer Bestellung von mehr als 20 Artikeln erhalten alle Kunden einen Rabatt von 10%.

Entscheidungstabelle:

In dieser Tabelle:

• Regel 1 repräsentiert einen Premiumkunden, der 11-20 Artikel kauft. Dieser erhält einen Rabatt von 5%.
• Regel 2 repräsentiert einen Premiumkunden, der mehr als 20 Artikel kauft. Dieser erhält einen Rabatt von 10% (da der 5%-Rabatt für Premiumkunden in diesem Fall vom höheren Mengenrabatt überschrieben wird).
• Regel 3 repräsentiert einen Premiumkunden, der 10 oder weniger Artikel kauft. Dieser erhält den standardmäßigen 5%-Rabatt für Premiumkunden.
• Regel 4 repräsentiert einen Standardkunden, der 10 oder weniger Artikel kauft. Dieser erhält keinen Rabatt.

Durch die Entscheidungstabelle stellt man klar, welchen Rabatt man unter welchen Bedingungen gewährt. Sie bietet einen systematischen Ansatz, um sicherzustellen, dass man alle Kombinationen von Bedingungen testet.

In der nachfolgenden Tabelle gilt es, die möglichen Testfälle für alle Aktionen zu ermitteln:

Zur Ermittlung der Anzahl von Testfällen, die alle Aktionen abdecken, wird die Tabelle analysiert:

• Aktion 1 wird in Spalte VI abgedeckt.
• Aktion 2 wird in den Spalten II und IV abgedeckt.
• Aktion 3 wird in den Spalten I, III, V und VII abgedeckt.
• Aktion 4 wird ebenfalls in Spalte VI abgedeckt.

Durch Analyse der Tabelle ergeben sich die folgenden Testfälle:

1. Spalte I deckt Aktion 3 ab.
2. Spalte II deckt Aktion 2 ab.
3. Spalte VI deckt Aktion 1, Aktion 3 und Aktion 4 ab.

Insgesamt werden 3 Testfälle benötigt, um alle Aktionen abzudecken.

Welche Software kann man dafür nutzen?

Für den Entscheidungstabellentest und andere Softwaretest-Aktivitäten gibt es eine Reihe von Werkzeugen, die auf dem Markt verfügbar sind. Die Wahl des besten Tools hängt von den spezifischen Anforderungen, dem Budget und der Komplexität des Projekts ab. Hier sind einige der populären Werkzeuge, die in der Softwaretest-Community weit verbreitet sind:

1. JIRA + Zephyr: Atlassian’s JIRA, in Kombination mit dem Zephyr-Plugin, bietet eine umfassende Testmanagement-Lösung, die es Teams ermöglicht, Testfälle zu erstellen, zu verwalten und Berichte zu erstellen.
2. TestRail: Ein beliebtes Testmanagement-Tool, das nahtlose Integrationen mit anderen gängigen Tools wie JIRA, Selenium und mehr bietet.
3. Selenium: Ein Open-Source-Tool für automatisierte Webanwendungstests. Es ist nicht speziell für den Entscheidungstabellentest entwickelt, man kann es aber zum Automatisieren von Testfällen verwenden, die man aus der Entscheidungstabelle ableitet.
4. HP Quality Center (jetzt Teil von Micro Focus): Ein umfassendes Testmanagement-Tool, das das Erstellen, Verwalten und Ausführen von Testfällen unterstützt.
5. QTest: Eine moderne Testmanagement-Plattform, die Agile-Teams bei der Planung, Verfolgung und Ausführung von Testfällen unterstützt.
6. SpecFlow: Ein Behavior-Driven Development (BDD) Tool, das man in Kombination mit der Gherkin-Syntax verwendet. Es kann zur Definition von Szenarien basierend auf Entscheidungstabellen und zur Automatisierung dieser Szenarien eingesetzt werden.
7. Confluence: Auch wenn es primär ein Team-Kollaborations-Werkzeug ist, nutzen einige Teams Confluence, um Entscheidungstabellen zu erstellen und zu verwalten.
8. Excel oder Google Sheets: Man kann auch einfache Tabellenkalkulationsprogramme verwenden, um Entscheidungstabellen zu entwerfen und zu verwalten. Sie bieten Flexibilität, sind aber nicht speziell für das Testen entwickelt.

Es gibt viele weitere spezialisierte Tools auf dem Markt. Die Wahl hängt letztlich von den spezifischen Bedürfnissen des Testteams und den vorhandenen Technologie-Stacks ab. Es empfiehlt sich, eine gründliche Bewertung durchzuführen und möglicherweise einige Demos oder Testversionen auszuprobieren, bevor man sich für ein bestimmtes Tool entscheidet.

Fazit

Der Entscheidungstabellentest bietet eine strukturierte und systematische Methode, um komplexe Systeme oder Prozesse zu testen. Durch die umfassende Berücksichtigung aller möglichen Kombinationen von Eingaben gewährleistet dieser Test eine hohe Abdeckung und ermöglicht eine qualitativ hochwertige Qualitätssicherung.

Der Beitrag Entscheidungstabellentest – Effektivität trifft Präzision erschien zuerst auf CEOsBay.

Man verwendet den Ausdruck Modultest unter anderem bei frühen Teststufen, in denen man die inneren, detailliertesten Komponenten der Software testet. Gemäß Software Validation & Verification Plan sind diese Tests nur für Module mit geringer Kritikalität nicht notwendig. Im Grunde genommen bei Fehlern, die dem User nur geringfügige Unannehmlichkeiten bereiten.

In einer Abstraktion der verwendeten Programmiersprache, spricht man von Komponente oder Softwarebaustein. Den Test eines solchen einzelnen Softwarebausteins bezeichnet man auch allgemeiner als Komponententest.

Als Testbasis kann man in der Regel die komponentenspezifische Anforderung und das Softwaredesign der Komponente (auch Komponentenspezifikation genannt) heranziehen. Für Whitebox-Testfälle oder um Aussagen zur Codeüberdeckung zu erhalten, kann man zusätzlich den Sourcecode einer Komponente analysieren und diesen als Testbasis verwenden. Wobei dabei auch Tools wie Jacoco helfen können. Ob die Komponente auf einen Testfall richtig reagiert, muss man allerdings auch hier auf Basis der Design- und Anforderungsdokumente beurteilen.

Typische Testobjekte sind wie bereits beschrieben Programmunits, -Module bzw. Klassen. Aber auch Kommandozeilenskripte des Betriebssystems (Shell-Skripte), Datenbankskripte, Datenkonvertierungs- oder Migrationsprozeduren, Datenbankinhalte sowie Konfigurationsdaten können Testobjekte sein. Kennzeichnend ist in der Regel der isolierte Test eines einzelnen Softwarebausteins. Dies dient primär, um komponentenexterne Einflüsse beim Testen auszuschließen. Alle so ermittelten Fehler kann man so dem spezifischen Modul zuordnen.

Klar zu unterscheiden ist auf jeden Fall der Integrationstest, den ich in einem separaten Beitrag thematisiere. Bei einem Integrationstest konzentriert man sich auf die Wechselwirkung mit Nachbarkomponenten.

Die Erstellung solcher Tests ist in der Regel die Aufgabe eines Programmierers. Dies liegt zum einen daran, dass man ein ausgeprägtes Verständnis für die Programmiersprache in der die Anwendung geschrieben ist haben muss. Und zum anderen daran, dass man meist auch einen Testtreiber benötigt, dessen Programmierung in der Regel auch der Entwickler übernimmt.

Einordnung im Testprozess

Algorithmen auf Unitebene besitzen meist nur eine begrenzte Komplexität und man kann sie über klar definierte Schnittstellen aktivieren. Daher kann sie mit relativ wenigen Testfällen weitgehend vollständig testen. Dies gilt als Voraussetzung für die anschließende Teststufe. Dem Integrationstest, um dort die Testfälle auf das integrierte Zusammenwirken größerer Funktionsteile oder der gesamten Anwendung ausrichten zu können. Die modulspezifischen Detailkonstellationen lassen sich damit auf Stichproben beschränken, was die Anzahl der erforderlichen Testfälle signifikant reduziert.

Zum Vergleich: Ein Gerät wird erst dann als Ganzes getestet, wenn die Funktionsfähigkeit seiner Einzelteile gesichert ist.

Test des Vertrages und nicht der Algorithmen

Man testet bei Modultests gemäß dem Design-by-contract-Prinzip möglichst nicht die Interna einer Methode, sondern nur ihre externen Auswirkungen (Rückgabewerte, Ausgaben, Zustandsänderungen, Zusicherungen). Sind die internen Details der Methode geprüft (dies wird als White-Box-Testing bezeichnet), kann der Test fehlschlagen, obwohl sich die externen Auswirkungen nicht geändert haben. Daher empfiehlt man in der Regel das sogenannte Black-Box-Testing, bei dem man sich auf das Prüfen der externen Auswirkungen beschränkt.

Was sind die Vorteile von Unit Tests?

• Mittels automatisierter Unittests kann man im Schnitt 30 % der Fehler erkennen. Bei der Verwendung von TDD (Test Driven Development) kann man im Schnitt 45 % und im besten Fall 85 % der Fehler vermeiden.
• Fehler erkennt man durch Modultests bereits während der Entwicklung. Die durch Unittests vermiedenen Fehlerkosten sind daher gemäß der Rule of Ten (Dazu später mehr) um ein Vielfaches höher als bei späteren Teststufen, was Unittests zur effizientesten Teststufe machen.
• Im Falle eines Fehlers kann man diesen sehr viel genauer eingrenzen und damit schneller finden und beheben.
• Die Tests erfüllen den Zweck einer lebenden Dokumentation. In Kombination mit einer sinnvollen Benamung der Objekte (Clean Code) können zusätzliche Dokumentationsmaßnahmen entfallen.
• Da einzelne Module nur wenige mögliche Codeausführungspfade besitzen, muss man viel weniger mögliche kombinatorische Ausführungspfade berücksichtigen als bei anderen Testarten. Bei übergeordneten Tests kann man sich dann stichprobenartig auf die wichtigsten Ausführungspfade konzentrieren und damit die Anzahl dieser Tests deutlich reduzieren.
• Da man nur einzelne Module testet, kann man Modultests, oft um mehrere Größenordnungen, schneller und damit öfter (bzw. kontinuierlich) ausführen als andere Testarten.
• Wenn man Fehler mit einem Test absichert, kann man den erneuten Auftritt des gleichen Fehlers verhindern.
• Durch die Fehlerreduktion ergeben sich Geschwindigkeitsvorteile in der Entwicklung in mittleren bis großen Softwareprojekten.
• Da man Abhängigkeiten zwingend vermeiden muss, um einen Modultest zu ermöglichen, bleibt der Code verhältnismäßig schnell änderbar. Hierdurch kann man schneller auf wechselnde Anforderungen reagieren. Siehe Agile Manifest 😉
• Da automatisch ausgeführte Tests um mehrere Größenordnungen schneller sind als manuelle Tests, reduziert sich der Zeitaufwand für das Testen deutlich. Hierdurch kann man die Entwicklungsstufen schneller durchlaufen und die Release-Zyklen signifikant verkürzen.

Was sind die Nachteile von Unit Tests?

• Bei der Implementierung neuer Funktionen muss man nicht nur die Funktion implementieren, sondern auch die dazugehörenden Tests vorbereiten bzw. definieren. Dadurch ergibt sich ein oft mehrfacher Implementierungsaufwand.
• Bei Änderungen muss man nicht nur die geänderten Funktionen, sondern auch die dazugehörenden Tests anpassen. Insbesondere bei der Entwicklung von Prototypen, bei der sich die Codebasis schnell verändert, ist das Testen daher oft eher ein Hindernis.
• Da man die Funktionalität der Tests verwendet, ist in den IDEs schwerer ersichtlich, ob eine Funktionalität keine Verwendung mehr findet und ob man es daher entfernen kann.
• Weisen die Tests untereinander Abhängigkeiten auf (z. B. durch gemeinsame Testdaten), so können einzelne Änderungen an der Codebasis eine Vielzahl von Tests beeinflussen, was den Änderungsaufwand mit der Größe der Codebasis exponentiell erhöht.

Fehlerkosten 10er Regel (Rule of ten)

Die Zehnerregel der Fehlerkosten besagt, dass je weiter ein Fehler sich unentdeckt in die späten Phasen des Werdegangs eines Produktes oder Prozesses bewegt – oder gar bis zum Kunden –, desto höher steigen die Kosten zur Behebung des Fehlers. Eindrucksvoll untermauert durch die Ergebnisse einiger Studien aus den 70er Jahren in Japan, USA und Großbritannien, die sich mit den Ursachen von Produkt- bzw. Qualitätsmängeln beschäftigten. Alle Analysen lieferten nahezu die gleichen Ergebnisse: Ca. 70 % aller Produktmängel hatten ihre Ursache bereits in der Entwicklung, Konstruktion und Arbeitsvorbereitung. Der Herstellungsprozess selbst hat bezüglich der Endqualität des Produktes offensichtlich eher einen sekundären Einfluss. Eine VDMA-Studie zum Thema „Qualitätsbezogene Kosten“ Anfang der 90er Jahre in der Bundesrepublik Deutschland bestätigt dieses Ergebnis.

Die Zehnerregel der Fehlerkosten oder „Rule of ten“ sagt aus, dass sich die Fehlerkosten für einen nicht entdeckten Fehler von Stufe zu Stufe der Wertschöpfung um den Faktor 10 erhöhen. Je früher ein Fehler entdeckt und beseitigt wird, desto kostengünstiger ist dies für die Organisation und schlussendlich auch für den User bzw. Kunden.

Ansonsten sind diese auch in der DIN 55350-11 im Rahmen des Qualitätsmanagements festgehalten. Doch darauf gehe ich in einem separaten Beitrag ein.

Wo sind die Grenzen der Unit Tests?

Unit Tests können (wie jeder Test) die Fehlerfreiheit der getesteten Units, Module usw. nicht garantieren oder nachweisen, sondern lediglich unterstützen. Die Grenzen von Unit Tests liegen primär nur in den Fällen vor in denen man Fehler finden kann, zu deren Entdeckung die verwendeten Tests geeignet sind. Eine Softwarekomponente, die „grün“ testet, ist also nur bedingt fehlerfrei.

Das Merkmal von Code, „grün“ zu testen, und durchaus auch der Wunsch nach diesem Ergebnis, kann dazu führen, dass man tatsächlich (unbewusst) nur so viel testet, bis alle Tests „grün“ sind. Module, die keine fehlschlagenden Modultests haben, als fehlerfrei zu behandeln, ist ein Fehlschluss in der Praxis des (TDD) Test Driven Development.

Um eine ausreichende Testabdeckung zu erzielen, lohnt es sich u.U., vor dem Erstellen der Testfälle Refactoring-Maßnahmen anzuwenden. Dies erst nach abgeschlossenen Unit Tests (für den alten Code) zu tun, schafft Raum (wie jede Änderung im Code) für neue Fehlerrisiken und kann deshalb wiederholtes Testen erforderlich machen.

Wenn der Autor von Unit Tests mit dem Autor der Module identisch ist, können Denkfehler in der Implementierung auch im Test erscheinen und verpasst gegebenenfalls die Chance, diese aufzudecken. Wenn es sich um dieselbe Person handelt, kann man die vorrangige Entwicklung der Tests ebenfalls nicht garantieren, da sowohl die beabsichtigte Funktionsweise des Codes als auch die zukünftige Gestalt bereits im Gedankengut des Testautors und späteren Codeautors präsent sein können. Dies kann im Extreme Programming durch „Test Ping-Pong“ abgefangen werden, bei der sich Entwickler bei der Implementierung der Funktionalität und der Tests abwechseln.

Bei der Entwicklung von Modultests können Testfälle entstehen, die der Zielsetzung und dem Charakter von Modultests nicht oder nur zum Teil entsprechen. Wie bei der Programmierung existieren daher auch für die Entwicklung von Modultests Anti-Pattern, die man möglichst vermeiden sollte.

Der Beitrag Unit Tests – Fundament für stabile und effiziente Software erschien zuerst auf CEOsBay.