Mutationstests mit Sprachmodellen voranbringen
LLMs nutzen, um die Effektivität von Mutationstests und die Softwarequalität zu verbessern.
― 6 min Lesedauer
Inhaltsverzeichnis
Mutationstests sind eine Methode, um die Qualität einer Test-Suite zu überprüfen. Dabei werden kleine Fehler, genannt Mutationen, in ein Programm eingefügt und geschaut, ob die Test-Suite diese Fehler erkennt. So wird der Testprozess verbessert.
Traditionell verwendet das Mutationstesting eine begrenzte Menge an Änderungen, um diese Fehler zu generieren. Zum Beispiel könnte ein Pluszeichen durch ein Minuszeichen ersetzt oder der Inhalt einer Funktion entfernt werden. Diese Methode kann jedoch einige reale Bugs übersehen, weil sie nicht alle möglichen Fehler abdeckt. Einige Fehler, wie das Aufrufen der falschen Methode auf einem Objekt, werden nicht erkannt, da die aktuellen Tools solche Fehler nicht berücksichtigen.
Diese Methode bespricht einen neuen Ansatz zur Generierung von Mutationen mit Hilfe eines grossen Sprachmodells (LLM). Das Modell wird aufgefordert, verschiedene Fehler vorzuschlagen, die im Code gemacht werden können. Dieses Tool kann auf JavaScript-Code angewendet und in verschiedenen Projekten bewertet werden.
Was ist Mutationstesting?
Mutationstests basieren auf der Idee, dass viele fehlerhafte Programme ähnlichen wie die korrekten sind. Das Konzept besagt, dass, wenn ein Test einen einfachen Fehler erkennen kann, er wahrscheinlich auch grössere, komplexere Probleme erkennen kann.
Beim typischen Mutationstesting:
- Es werden kleine Änderungen am Code vorgenommen.
- Der modifizierte Code wird durch die Test-Suite getestet.
- Das Tool prüft, ob die Tests bestehen oder fehlschlagen.
Wenn Tests fehlschlagen, bedeutet das, dass die Mutation erkannt wurde, was gut ist. Wenn sie bestehen, bedeutet das, dass die Änderung nicht erkannt wurde, was auf eine Schwäche in der Test-Suite hinweist.
Einschränkungen des traditionellen Mutationstests
Die meisten aktuellen Mutationstools basieren auf einer kleinen Anzahl von Operatoren zur Erstellung von Mutationen. Obwohl diese Tools effektiv waren, berücksichtigen sie nicht die Komplexität realer Codes. Einige Änderungen, die zu Bugs führen, wie das Ändern von Methodenaufrufen oder das Ändern von Variablenreferenzen, sind nicht enthalten.
Das Hinzufügen von mehr Mutationstypen könnte das Testen gründlicher machen. Allerdings kann dies auch die Zeit und Ressourcen erhöhen, die benötigt werden, um die Tests durchzuführen. Das ist wichtig, weil reale Softwareprojekte bereits mit Herausforderungen in Bezug auf die Laufzeiteffizienz zu kämpfen haben.
Einführung grosser Sprachmodelle
Der neue Ansatz nutzt LLMs, um vielfältigere Mutationen zu generieren, ohne umfangreiche Schulungen. Die Idee ist, Teile des Quellcodes durch einen Platzhalter zu ersetzen und das Modell zu bitten, verschiedene Code-Snippets vorzuschlagen, um den Platzhalter zu ersetzen. Diese Methode nutzt das grosse Wissen, auf dem LLMs trainiert wurden.
Wie es funktioniert
Das neue Tool für Mutationstests funktioniert in ein paar entscheidenden Schritten:
Das LLM ansprechen: Das Tool generiert Aufforderungen, die aus Quellcode bestehen, wobei bestimmte Fragmente durch einen Platzhalter ersetzt werden. Die Aufforderung enthält auch Hintergrundinformationen zum Mutationstesting.
Mutanten generieren: Das LLM wird gebeten, Variationen für den Platzhalter vorzuschlagen und potenzielle Codeänderungen zu erstellen. Jeder Vorschlag kommt auch mit einer Erklärung, wie er sich auf das Verhalten des Programms auswirkt.
Mutanten bewerten: Die vorgeschlagenen Änderungen werden dann von einem modifizierten Tool für Mutationstests verarbeitet. Dieses Tool kann die generierten Änderungen anwenden und sie als erkannt (getötet), nicht erkannt (überlebt) oder zeitlich abgelaufen während der Tests klassifizieren.
Ergebnisse aufbereiten: Schliesslich werden die Ergebnisse in einem interaktiven Format präsentiert, das es den Nutzern ermöglicht, die generierten Mutationen zu inspizieren.
Experimentieren mit vielfältigen Mutationen
Um die Effektivität der Nutzung von LLMs zu testen, wurden Experimente an realen JavaScript-Anwendungen durchgeführt. Ziel war es zu sehen, wie viele neue Mutationsarten erstellt werden konnten und wie effektiv sie von bestehenden Tests erkannt wurden.
Wichtige Fragen
Mehrere wichtige Fragen leiten den Bewertungsprozess:
- Wie viele Mutanten erstellt das Tool?
- Wie viele der überlebenden Mutanten sind äquivalent zum Originalcode?
- Welche Auswirkungen haben verschiedene Temperatureinstellungen auf die Ausgabe des LLM?
- Wie beeinflusst die Aufforderungsstrategie die Anzahl der generierten Mutationen?
- Wie hoch sind die Kosten für die Ausführung des Tools auf verschiedenen Anwendungen?
Ergebnisse aus den Experimenten
Anzahl der erstellten Mutationen
Das Tool konnte eine beträchtliche Anzahl von Mutanten über verschiedene Projekte hinweg generieren. Jeder Durchlauf des Tools produzierte eine Reihe von Vorschlägen, von denen viele zu neuen Mutanten führten. Es ist jedoch wichtig zu wissen, dass nicht alle generierten Änderungen syntaktisch gültig waren.
Äquivalenz der Mutanten bewerten
Eine grosse Herausforderung beim Mutationstesting besteht darin, festzustellen, ob ein Mutant sich genauso verhält wie der Originalcode. Einige Mutationen können unterschiedlich erscheinen, aber unter bestimmten Bedingungen die gleichen Aufgaben ausführen. Bei der Bewertung wurde eine manuelle Analyse der überlebenden Mutanten durchgeführt, um sie als äquivalent, nahezu äquivalent oder nicht äquivalent zu klassifizieren.
Temperatureinstellungen verstehen
Das LLM hat eine Einstellung namens Temperatur, die beeinflusst, wie kreativ die Ausgabe ist. Eine niedrigere Temperatur führt im Allgemeinen zu vorhersehbareren und stabileren Ausgaben, während eine höhere Temperatur sehr unterschiedliche Ergebnisse erzeugen kann. Experimente zeigten, dass mit steigender Temperatur auch die Anzahl der unterschiedlichen Mutanten zunimmt, aber gleichzeitig einige Mutanten syntaktisch ungültig sein können.
Einfluss der Aufforderungsstrategie
Die Struktur der Aufforderungen kann die Anzahl der generierten Mutanten erheblich beeinflussen. Verschiedene Variationen von Aufforderungen wurden getestet, um zu sehen, wie sich das auf die Ergebnisse auswirkt. Umfassende Aufforderungen führten tendenziell zu besseren Ergebnissen im Vergleich zu minimalen.
Vergleich der Leistung verschiedener LLMs
Die Auswahl des LLM hat ebenfalls Einfluss auf die Mutationsgenerierung. Verschiedene Modelle wurden getestet, und während eines möglicherweise konstant mehr Mutanten als ein anderes generiert, kann die Anzahl der überlebenden Mutanten zwischen den Modellen variieren.
Kosten für die Nutzung des Tools
Schliesslich ist die Kosten-Nutzen-Analyse des Tools ein wichtiges Kriterium. Die Ausgaben für die Nutzung der kommerziellen Version des LLM wurden anhand der Anzahl der verwendeten Tokens für sowohl Aufforderungen als auch Ausgaben berechnet. Die Gesamtkosten für die Ausführung des Tools über mehrere Projekte erwiesen sich als angemessen im Vergleich zu traditionellen Methoden.
Fazit
Zusammenfassend lässt sich sagen, dass die Nutzung von LLMs für Mutationstests einen vielversprechenden Fortschritt in den Software-Testpraktiken darstellt. Die Möglichkeit, vielfältige und relevante Mutanten zu generieren, könnte zu besseren Testprozessen und höherer Softwarequalität führen. Trotz der Herausforderungen, wie der Bestimmung der Mutantenaequivalenz und der Verwaltung der Laufzeiteffizienz, eröffnet diese Methode neue Möglichkeiten zur Verbesserung im Bereich Softwaretesting. Zukünftige Arbeiten werden sich darauf konzentrieren, die Fähigkeit des Modells zur Generierung bedeutungsvoller Mutationen zu verfeinern und seine praktischen Anwendungen in verschiedenen Programmierumgebungen weiter zu erkunden.
Zukunftsperspektiven
Z künftige Forschung wird sich mit folgendem befassen:
- Reduzierung der Anzahl äquivalenter Mutanten, die vom Modell erstellt werden.
- Möglichkeiten zur Generierung von Tests finden, die überlebende Mutanten erkennen können.
- Bewertung, wie gut die erstellten Mutanten mit realen Fehlern zusammenpassen.
Dieser Ansatz hat das Potenzial, die Praktiken des Mutationstests erheblich zu verbessern und die Zuverlässigkeit von Software insgesamt zu steigern.
Titel: LLMorpheus: Mutation Testing using Large Language Models
Zusammenfassung: In mutation testing, the quality of a test suite is evaluated by introducing faults into a program and determining whether the program's tests detect them. Most existing approaches for mutation testing involve the application of a fixed set of mutation operators, e.g., replacing a "+" with a "-" or removing a function's body. However, certain types of real-world bugs cannot easily be simulated by such approaches, limiting their effectiveness. This paper presents a technique where a Large Language Model (LLM) is prompted to suggest mutations by asking it what placeholders that have been inserted in source code could be replaced with. The technique is implemented in LLMorpheus, a mutation testing tool for JavaScript, and evaluated on 13 subject packages, considering several variations on the prompting strategy, and using several LLMs. We find LLMorpheus to be capable of producing mutants that resemble existing bugs that cannot be produced by StrykerJS, a state-of-the-art mutation testing tool. Moreover, we report on the running time, cost, and number of mutants produced by LLMorpheus, demonstrating its practicality.
Autoren: Frank Tip, Jonathan Bell, Max Schäfer
Letzte Aktualisierung: 2024-04-15 00:00:00
Sprache: English
Quell-URL: https://arxiv.org/abs/2404.09952
Quell-PDF: https://arxiv.org/pdf/2404.09952
Lizenz: https://creativecommons.org/licenses/by/4.0/
Änderungen: Diese Zusammenfassung wurde mit Unterstützung von AI erstellt und kann Ungenauigkeiten enthalten. Genaue Informationen entnehmen Sie bitte den hier verlinkten Originaldokumenten.
Vielen Dank an arxiv für die Nutzung seiner Open-Access-Interoperabilität.
Referenz Links
- https://github.com/githubnext/llmorpheus
- https://stryker-mutator.io/docs/mutation-testing-elements/supported-mutators/
- https://stryker-mutator.io/docs/General/faq/
- https://openai.com/pricing
- https://docs.arcmutate.com/docs/extended-operators.html
- https://github.com/infusion/Complex.js/tree/d995ca105e8adef4c38d0ace50643daf84e0dd1c
- https://github.com/manuelmhtr/countries-and-timezones/tree/241dd0f56dfc527bcd87779ae14ed67bd25c1c0e
- https://gitlab.com/autokent/crawler-url-parser/tree/202c5b25ad693d284804261e2b3815fe66e0723e
- https://github.com/quilljs/delta/tree/5ffb853d645aa5b4c93e42aa52697e2824afc869
- https://gitlab.com/demsking/image-downloader/tree/19a53f652824bd0c612cc5bcd3a2eb173a16f938
- https://github.com/felixge/node-dirty/tree/d7fb4d4ecf0cce144efa21b674965631a7955e61
- https://github.com/rainder/node-geo-point/tree/c839d477ff7a48d1fc6574495cbbc6196161f494
- https://github.com/jprichardson/node-jsonfile/tree/9c6478a85899a9318547a6e9514b0403166d8c5c
- https://github.com/swang/plural/tree/f0027d66ecb37ce0108c8bcb4a6a448d1bf64047
- https://github.com/pull-stream/pull-stream/tree/29b4868bb3864c427c3988855c5d65ad5cb2cb1c
- https://github.com/kriskowal/q/tree/6bc7f524eb104aca8bffde95f180b5210eb8dd4b
- https://gitlab.com/cptpackrat/spacl-core/tree/fcb8511a0d01bdc206582cfacb3e2b01a0288f6a
- https://github.com/maugenst/zip-a-folder/tree/d2ea465b20dc33cf8c98c58a7acaf875c586c3e1