Im ersten Teil der Artikelserie wurde das Konzept von Komponententests ganz allgemein vorgestellt und im zweiten Teil wurde erklärt, wie mit Hilfe von Komponententests und Fehlerlokatoren eine teilautomatische Fehlersuche durchgeführt werden kann. Am Ende des zweiten Artikels habe ich auf ein generelles Problem von Fehlerlokatoren hingewiesen: Diese funktionieren in der Regel nur für einen einzelnen Fehler gut und führen im Mehrfehlerfall – also der Situation, dass sich in einem Programm mehr als ein Fehler befindet, welcher durch Komponententests ausgeführt wird – zu eher unbrauchbaren Ergebnissen. Warum das so ist und was man dagegen tun kann, möchte ich in diesem Artikel darlegen.

Zur Erinnerung: Lokatoren helfen bei der Fehlersuche, indem sie die aufgerufenen Komponenten (Methoden, Statements, …) nach ihrer Wahrscheinlichkeit, einen Fehler zu enthalten, sortieren. Ein bekannter Lokator ist der Tarantula-Lokator mit folgender Formel:

rT(mi) =
f(mi)
f
p(mi)
p
 + 
f(mi)
f

Die Bezeichnungen in der Formel hatten die folgenden Bedeutungen (man möge mir den kopierten Textbaustein verzeihen): Der Ausdruck f(mi) bezeichnet die Menge an fehlgeschlagenen Tests, welche die Methode mi aufrufen; f bezeichnet dagegen die Menge aller Tests, die fehlschlagen. Der Term f(mi) / f bezeichnet damit das Verhältnis zwischen den fehlschlagenden Tests, die mi aufrufen, und allen fehlschlagenden Tests. Analog dazu bezeichnet p(mi) die Menge an erfolgreichen Tests, die mi aufrufen und p die Menge aller erfolgreichen Tests.

Die Formel offenbart auch schon das erste Problem von Fehlerlokatoren: Sie sortieren die aufgerufenen Komponenten in Abhängigkeit davon, von wie vielen fehlschlagenden Testfällen in Relation zu allen fehlschlagenden Testfällen sie aufgerufen werden. Mit anderen Worten: Die Komponenten werden danach beurteilt, wie gut sie das Fehlschlagen aller Testfälle erklären. Und wo ist hier das Problem?

Ganz einfach: Die fehlschlagenden Testfälle müssen nicht alle aufgrund desselben Fehlers fehlschlagen! Es ist durchaus denkbar, dass einige Testfälle wegen Fehler A fehlschlagen, wohingegen andere aufgrund Fehlers B fehlschlagen und so weiter. Wenn nun einige wenige Testfälle ausschließlich wegen eines Fehlers in einer Methode m1 fehlschlagen, viele andere Testfälle aber aufgrund eines Fehlers in m2 und keiner der Testfälle die jeweils andere Methode aufruft, so wird m2 durch Tarantula (und auch durch andere Lokatoren) dementsprechend als sehr wahrscheinlich fehlerbehaftet eingestuft, da die Methode eben durch viel mehr fehlschlagende Testfälle als m1 aufgerufen wird. Das ist aber natürlich ein Trugschluss!

Daneben existiert noch eine weitere Problematik: Die Sortierung durch einen Fehlerlokator gibt keinen Hinweis darauf, wie viele Fehler sich eigentlich (beziehungsweise mindestens) im Programm befinden. Wenn die durch einen Lokator vorgeschlagenen Methoden durchsucht und ein Fehler gefunden wurde – woher soll der Programmierer wissen, ob er weiter suchen soll oder nicht? Tarantula gibt hierauf keine Antwort – die Forschung zum Glück aber schon. Und auch ich habe mich in meiner Dissertation mit genau dieser Frage beschäftigt und möchte sie hier beantworten.

Zwei Informationen sind somit interessant: Wie viele Fehler befinden sich (mindestens) in einem Programm und an welchen Stellen sollte nach ihnen gesucht werden. In der akademischen Welt existieren einige teilweise relativ komplizierte, da sehr spezialisierte Algorithmen, um diese Informationen zu sammeln. Glücklicherweise kann man sich jedoch auch mit einigen relativ einfachen Algorithmen aus der Mathematik behelfen, um die gewünschten Informationen zu besorgen.

Betrachten wir zum Beispiel einmal die folgende Abdeckungsmatrix (alle Tests sollen als fehlgeschlagen gelten):

t1 t2 t3 t4 t5 t6
m1 1 1
m2 1 1
m3 1 1
m4 1 1
m5 1 1

1 / 2 / 3 / Auf einer Seite lesen

Kommentare (9)

  1. #1 Karl Mistelberger
    August 6, 2017

    Ein Beispiel sagt mehr als tausend Worte. Neben theoretischen Überlegungen wäre auch Fälle aus der Praxis ein lohnenswertes Thema.

    Nach gut vier Jahrzehnten einschlägiger Erfahrung bin ich bei openSUSE Tumbleweed gelandet. Die Leute tun ungefähr das, was ich mir immer vorgestellt habe und es funktioniert auch sehr gut.

    Ich habe immer die aktuelle Software und brauche mich um keine Updates kümmern.

    Momentan benutze ich Snapshot 20170802 vom vergangenen Mittwoch. Der ist nicht fehlerfrei, aber ausreichend getestet: Overall Summary of openSUSE Tumbleweed build 20170802.

    Falls es doch einmal haken sollte gibt es schnelle Abhilfe, denn die Programmierer arbeiten sowie daran und ich muss auf keine Backports warten. Ich bin selten so positiv überrascht worden.

    Last Builds for openSUSE Tumbleweed

    • #2 Marcus Frenkel
      August 6, 2017

      Wie genau steht der Kommentar jetzt in Zusammenhang mit dem Thema des Blog-Artikels?

  2. #3 Karl Mistelberger
    August 6, 2017

    Mein Kommentar nimmt Bezug auf alle 3 Teile zum Thema Fehlerlokalisierung, Komponententests, Softwaretests.

    Diese sind ziemlich theoretisch gehalten. Ein Praxisbezug wäre schon nett. Ich habe mir erlaubt ein auf real existierendes und funktionierendes Beispiel hinzuweisen.

    • #4 Marcus Frenkel
      August 6, 2017

      Dass sie theoretisch gehalten sind, ist mir klar. Darum geht es ja auch in den Artikeln – sie sollen die theoretischen Grundlagen erläutern. Was genau hat openSUSE Tumbleweed damit zu tun, wie man theoretisch die Fehlersuche auf Grundlage von Abdeckungsmatrizen parallelisieren kann?

  3. #5 Karl Mistelberger
    August 6, 2017

    > #4 Marcus Frenkel, August 6, 2017
    > Dass sie theoretisch gehalten sind, ist mir klar. Darum geht es ja auch in den Artikeln – sie sollen die theoretischen Grundlagen erläutern.

    Von jeder Theorie erwartet man, dass sie nützlich ist. Darum sollte, wenn die Stichworte Fehlerlokalisierung, Komponententests, Softwaretests auftauchen etwas zum Praxisbezug der Theorie gesagt werden. Im zitierten Artikel schreiben die Autoren:

    Localizing SQL Faults in Database Applications

    The results are encouraging and demonstrate the improvement that can be achieved with our new database-aware technique. There are, however, many areas of future work that can be explored. We performed our studies on three projects. To fully evaluate our technique, and guide additional research, we must identify other suitable subjects for our research.

    Da stellt sich natürlich die Frage, wie sieht es im richtigen Leben aus? Müssen diese Leute noch weiter forschen oder wo genau gibt es bereits Produkte, die auf dieser Basis entwickelt werden und davon auch tatsächlich profitieren? Ich erwarte ja kein selbst geschriebenes White Paper, aber Links auf solche wären schön.

    Apropos: Seit auf meinem Rechner MariaDB läuft gibt es diesbezüglich keine Probleme mehr.

    > Was genau hat openSUSE Tumbleweed damit zu tun, wie man theoretisch die Fehlersuche auf Grundlage von Abdeckungsmatrizen parallelisieren kann?

    Dass Tumbleweed damit zu tun hat habe ich nie behauptet. Anderseits scheinen die Leute die durch die Stichworte angesprochenen Probleme für ihr eigenes Produkt in den Griff gekriegt zu haben, womit sie sich bei mir beliebt gemacht haben.

  4. #6 Robert
    August 10, 2017

    Karl Mistelberger,
    danke für den Mut, praktische Beispiele zu fordern.
    Für Herrn Frenkel ist wahrscheinlich alles sonnenklar, für Außenstehende überhaupt nicht.
    Ich habe früher auch Programme selbst geschrieben und mehr durch Versuch und Irrtum die Fehler zu finden versucht.
    Ich wäre also auch an einer Systematik interessiert. Und das kann man doch auch an einem praktischen Beispiel demonstrieren.

  5. #7 Marcus Frenkel
    August 10, 2017

    Man darf bei der Diskussion nicht vergessen, dass es sich um ein akademisches Thema handelt – praktische Beispiele hierfür bedürfen einer gewissen Größe, wodurch ihre Behandlung im Rahmen dieses Blogs ungeeignet ist. Wenn es allerdings generell Interesse am Thema Unit-Tests (im ersten Teil dieser Serie nur kurz angeschnitten) gibt, kann ich dazu natürlich auch noch einen Beitrag schreiben.

  6. #8 Robert
    August 11, 2017

    Markus Frenkel,
    …….Interesse,
    das besteht. Sie scheinen da wirklich etwas sehr Praktisches konstruiert zu haben.
    Auch ein akademisches Thema kann man an einem Beispiel abarbeiten.
    Das Problem mit solchen mathematischen Modellen ist, dass man nicht sicher weiß, ob man das gleiche meint verstanden zu haben, wie der Autor es gemeint hat.

  7. #9 fherb
    August 14, 2017

    Die Frage nach dem praktischen Beispiel würde ich so nicht direkt auf Markus Frenkel abwälzen. Es ist eher ein allgemeines Problem, dass wissenschaftliche Ergebniss aus der Informatik kaum in den Werkzeugen der Softwareentwickler landen. Statt dessen muss sich ein Entwicklerteam außen rum ein organisatorisches Framework schaffen, um Qualität zu liefern.

    Ich finde, dass dabei aber die Informatiker mit ihren Ideologien sich selbst im Weg stehe: Statt Grabenkämpfe auszutragen mit welcher Programmiersprache nun am besten ein Problem gelöst werden kann, Open Source sozusagen die gesunde, natürlich und selbstverständliche vegane Ernährung des Programmierers ist und Programmiersprachen oft wie Ersatzrelegionen betrachtet werden, fällt alles, was über die Sprache hinaus geht, hinten runter. Zu einem Softwareentwicklungssystem gehört meiner Meinung nach sehr viel mehr als ein Compiler, Debuger und eine IDE mit Syntaxhervorhebung und weiteren Dingen, um überhaupt noch den Überblick zu behalten.

    Aus meiner Sicht gehört ein hochentwickeltes Testwerkzeug dazu. Asserts sind in so fern kontraproduktuktiv, weil hier ja wieder der Entwickler sich selbst prüft: Eine im Programm vergessene Division durch Null, wird ihm beim Schreiben des Test auch nur durch Zufall einfallen. Und dann kann er das Programm gleich korrigieren.

    Ein hoch entwickeltes Testsystem mit künstlicher Intelligenz produziert aber kein Hersteller. Denn dann müssten Informatiker (so wie alle anderen Ingenieure auch) mal Geld in die Hand nehmen und ein teures Entwicklungssystem erwerben. Im Maschinbau und Elektronikentwicklung sind da schnell mal 50.000 Euro weg. Da aber Informatiker sowas nie tun würden, findet sich auch keine Softwareschmiede, die Interesse daran hat, so ein hoch spezialisiertes Produkt zu entwickeln. Mir ist zumindest Keines bekannt.