So – nach langer, arbeitsbedingter Blog-Pause melde ich mich zurück! Jetzt ist aber endlich meine Promotion beendet und ich habe (hoffentlich) wieder Zeit für einigermaßen regelmäßige Beiträge.
Anfangen möchte ich direkt mit dem Thema, mit dem ich mich die letzten Jahre über beschäftigt habe: dem Testen von Software. Konkret möchte ich im Rahmen einer kleinen Artikelserie zum Thema meiner Dissertation hinleiten und es im letzten Teil auch kurz vorstellen. Also – los geht es!
Jeder, der mit Computern arbeitet, kennt es vermutlich: Man benutzt eine Software (für die eventuell sogar viel Geld bezahlt wurde) und – zack! – stürzt sie ab oder zeigt ein anderes unerwünschtes Verhalten – kurz: einen Fehler. Warum sich Fehler in Programme einschleichen, ist nicht verwunderlich: da sie auch nur von Menschen programmiert werden, ist es nur natürlich, dass hin und wieder auch Fehler gemacht werden. Interessanter – und auch oft gestellt, nicht selten mit empörtem Unterton – ist dagegen die Frage, warum es diese Fehler ins fertige Produkt schaffen und sich scheinbar vorher niemand die Mühe gemacht hat, sie zu suchen und zu beseitigen.
Der Vorwurf ist natürlich einfach erhoben; es darf jedoch nicht vergessen werden, dass es in vielen Programmen oft unzählige Anwendungsfälle gibt, die oft auch vom Nutzerverhalten über einen längeren Zeitraum abhängen. Diese alle im Voraus zu erahnen und zu überprüfen, ist – vorsichtig ausgedrückt – nicht unbedingt einfach. Was uns auch direkt zur eigentlichen Frage des Beitrags führt: Wie kann Software überhaupt getestet werden?
Die einfachste Möglichkeit ist natürlich, dass sich jemand hinsetzt und die Software ausprobiert (vorzugsweise übrigens nicht der Programmierer selber, da er nur testet, ob die implementierten Sachen funktionieren – und nicht, was alles nicht klappt!). Wie gerade erwähnt, ist das bei hinreichend komplexer Software (und das heißt, alles, was über das einfachste hinausgeht) eine überaus undankbare, wenig zielführend und kaum zu bewältigende Aufgabe. Erschwert wird dies noch dadurch, dass an einem Programm natürlich auch immer noch weiter programmiert wird. Jede Änderung am Programmcode erfordert im Grunde ein neues Testprogramm. Auf diese Art könnte kaum sichergestellt werden, dass eine Software keine Fehler enthält (nichtsdestotrotz hat das manuelle Testen natürlich seine Daseinsberechtigung; insbesondere Software wie Computerspiele mit vielen Nutzereingaben über einen langen Zeitraum werden ausgiebig manuell getestet).
Wenn manuelles Testen keine Lösung ist, muss ein automatisierter Prozess her. Und in der Tat gibt es verschiedene Möglichkeiten, Software automatisiert zu testen. Eine der grundlegendsten Methoden ist die der Komponententests.
Software ist in der Regel aus mehreren Einzelteilen oder Komponenten zusammengesetzt. Was genau eine Komponente darstellt, ist etwas unscharf definiert; es kann sich hierbei um eine einzelne Methode eines Programms, eine Klasse (Randnotiz: Was eine Klasse ist, muss noch in einer eigenen Artikelserie behandelt werden!), ein ganzes Modul oder auch um einen funktionell zusammengehörigen Verbund von kleineren Komponenten handeln. Für den weiteren Verlauf des Artikels soll gelten, dass mit einer Komponente eine einzelne Methode gemeint ist.
Komponententests testen also (zum Beispiel!) Methoden automatisiert. Doch wie genau läuft das ab? Stellen wir uns einmal vor, wir haben eine einfache Funktion normalize, die einen Vektor normiert, ihn also auf eine Länge von genau 1 bei Beibehaltung der Richtung transformiert; dies wird erreicht, indem jede Koordinate des Vektors durch seine Länge geteilt wird (sqrt ist die Funktion zur Berechnung der Quadratwurzel):
(2) l ∈ R, l ← sqrt( v02 + v12 + v22 )
(3) return [v0/l, v1/l, v2/l]
Auf den ersten Blick ganz einfach. Diese Funktion kann getestet werden, indem für sie ein Testfall geschrieben wird. Einfach gesagt ist ein Testfall wiederum eine Funktion, welche die zu testende Komponente mit einer bestimmten Eingabe aufruft und prüft, ob das gelieferte Ergebnis den Erwartungen entspricht. Ein Testfall für die Funktion normalize könnte zum Beispiel so aussehen:
(2) assert normalize( [1, 0, 0] ) = [1, 0, 0]
(3) assert normalize( [0, 2, 0] ) = [0, 1, 0]
(4) assert normalize( [3, 0, 4] ) = [0.6, 0, 0.8]
Das Schlüsselwort normalize demzufolge anhand von drei Werten. Schlägt keine der drei Überprüfungen fehl, muss normalize also korrekt, das heißt ohne Fehler, sein…
Wirklich?
Nein, natürlich nicht. Ein Testfall kann nämlich nur überprüfen, ob eine Methode Fehler enthält – er kann nicht prüfen, ob sie fehlerfrei ist! Unsere normalize-Methode ist ein wunderbares Beispiel hierfür, denn sie enthält einen Fehler (der dem aufmerksamen Leser natürlich schon längst aufgefallen ist): Wird als Eingabe der Nullvektor, also der Vektor [0, 0, 0] mit der Länge 0, verwendet, findet eine Division durch 0 statt und produziert damit einen Fehler. Der Nullvektor ist eigentlich nicht normierbar; da Computer aber dennoch mit diesem Fall umgehen können müssen, wird üblicherweise vereinbart, dass der normierte Nullvektor wieder der Nullvektor ist. Die Funktion normalize müsste demzufolge folgendermaßen aussehen:
(2) l ∈ R, l ← sqrt( v02 + v12 + v22 )
(3) if l = 0:
(4) return [0, 0, 0]
(5) else:
(6) return [v0/l, v1/l, v2/l]
Um dieses Versäumnis als Fehler zu entdecken, muss der Testfall auch entsprechend angepasst werden:
(2) assert normalize( [1, 0, 0] ) = [1, 0, 0]
(3) assert normalize( [0, 2, 0] ) = [0, 1, 0]
(4) assert normalize( [3, 0, -4] ) = [0.6, 0, -0.8]
(5) assert normalize( [0, 0, 0] ) = [0, 0, 0]
Wünschenswert wäre natürlich, wenn ein Test gleich alle möglichen Eingaben überprüfen würde. Dem steht allerdings entgegen, dass es davon in der Regel ziemlich viele gibt; allein die Anzahl der möglichen dreidimensionalen Vektoren, die ein Computer darstellen kann, ist viel zu groß, um sie in vertretbarer Zeit zu überprüfen. Man kann sich also nur einige wichtige Werte in Grenzbereichen (im Falle der dreidimensionalen Vektoren sind das zum Beispiel der Nullvektor, Vektoren mit nur einer nichtleeren Koordinate, mit zwei nichtleeren Koordinaten) und einige weitere Testwerte heraussuchen und die Korrektheit der zu testenden Komponente mit diesen Werten überprüfen. Schlagen derartige Tests nicht fehl, ist das zumindest ein Hinweis darauf, dass keine allzu groben Fehler in der Komponente vorhanden sind – Fehlerfreiheit beweist das jedoch wie gesagt nicht!
Die gesamte Funktionalität eines Programms lässt sich mit Komponententests natürlich nicht überprüfen, da jene erst durch das Zusammenspiel vieler Komponenten entsteht. Komponententests können demzufolge nur benutzt werden, um die Basisfunktionalitäten eines Programms (etwa in Form von Methoden) zu testen – aber das ist immerhin besser als nichts und führt in Kombination mit weiteren Testverfahren (Stichworte: Integrationstests, Systemtests) dazu, dass immerhin die gröbsten Fehler gefunden werden können.
Die Eigenschaft von Komponententests, dass sie lediglich Fehler finden, aber keine Fehlerfreiheit nachweisen können, gilt für sämtliche Testverfahren, egal ob manuell oder automatisiert. Das ist auch einer der Gründe, warum selbst in kommerziell vertriebener und viel getesteter Software Fehler enthalten sind: Es ist schlicht nicht möglich, sämtliche Fehler in einem Programm im Voraus zu entdecken (außer, die Korrektheit des Codes wird formal bewiesen – aber das ist ein ganz anderes Kapitel…). Wenn also das nächste mal ein Programm ein Fehlverhalten aufweist, welches doch eigentlich vorher schon hätte bemerkt und beseitigt werden müssen, immer daran denken: Programmierer sind auch nur Menschen. Und machen wie alle anderen auch Fehler.
Im nächsten Teil der Artikelserie soll es darum gehen, was zu tun ist, wenn ein Test fehlschlägt und wie ein Programmierer aus dem Fehlschlagen mehrerer Tests den möglichen Ort des Fehlers im Programmcode lokalisieren kann.
Kommentare (12)