Avanzare il Mutation Testing con i Modelli Linguistici
Usare i LLM per migliorare l'efficacia del testing delle mutazioni e la qualità del software.
― 6 leggere min
Indice
Il Mutation Testing è un metodo usato per controllare la qualità di un test suite. Funziona aggiungendo piccoli errori, chiamati mutazioni, a un programma e vedendo se il test suite riesce a beccare questi errori. Facendo così, aiuta a migliorare il processo di testing.
Tradizionalmente, il mutation testing utilizza un insieme limitato di modifiche per creare questi errori. Ad esempio, potrebbe sostituire un segno più con un segno meno o rimuovere il contenuto di una funzione. Tuttavia, questo approccio può perderci alcuni bug del mondo reale perché non copre ogni possibile errore. Alcuni errori, come chiamare il metodo sbagliato su un oggetto, non verranno beccati perché gli strumenti attuali non tengono conto di tali errori.
Questo metodo parla di un nuovo modo di generare mutazioni usando un Large Language Model (LLM). Il modello viene stimolato a suggerire diversi errori da fare nel codice. Questo strumento può essere applicato al codice JavaScript e valutato su vari progetti.
Cos'è il Mutation Testing?
Il mutation testing si basa sull'idea che molti programmi con bug sono simili a quelli corretti. Il concetto suggerisce che se un test può rilevare un errore semplice, probabilmente può rilevare problemi più grandi e complessi.
Nel tipico mutation testing:
- Vengono fatte piccole modifiche al codice.
- Il codice modificato viene eseguito attraverso il test suite.
- Lo strumento verifica se i test passano o falliscono.
Se i test falliscono, significa che la mutazione è stata rilevata, il che è positivo. Se passano, significa che la modifica non è stata beccata, il che indica una debolezza nel test suite.
Limitazioni del Mutation Testing Tradizionale
La maggior parte degli strumenti di mutazione attuali si basa su un piccolo insieme di operatori per creare mutazioni. Anche se questi strumenti sono stati efficaci, non tengono conto della complessità del codice reale. Ad esempio, alcune modifiche che portano a bug, come alterare le chiamate ai metodi o cambiare i riferimenti alle variabili, non sono incluse.
Aggiungere più tipi di mutazione potrebbe rendere il testing più approfondito. Tuttavia, farlo può anche aumentare il tempo e le risorse necessarie per eseguire i test. Questo è significativo perché i progetti software del mondo reale affrontano già sfide con l'efficienza in fase di esecuzione.
Introduzione ai Large Language Models
Il nuovo approccio sfrutta gli LLM per generare mutazioni più diverse senza bisogno di un ampio training. L'idea è di sostituire parti del codice sorgente con un segnaposto e chiedere al modello di proporre vari frammenti di codice per sostituire il segnaposto. Questo metodo capitalizza sulla vasta quantità di conoscenza di programmazione su cui gli LLM sono stati addestrati.
Come Funziona
Il nuovo strumento di mutation testing funziona in pochi passaggi chiave:
Stimolare l'LLM: Lo strumento genera prompt che consistono in codice sorgente, dove frammenti specifici sono sostituiti con un segnaposto. Il prompt include anche informazioni di base sul mutation testing.
Generare Mutanti: Si chiede all'LLM di suggerire variazioni per il segnaposto, creando potenziali modifiche al codice. Ogni suggerimento viene accompagnato da una spiegazione di come influisce sul comportamento del programma.
Valutare i Mutanti: Le modifiche suggerite vengono poi elaborate da uno strumento di mutation testing modificato. Questo strumento può applicare le modifiche generate e classificarle come rilevate (uccise), non rilevate (sopravvissute) o in scadenza durante i test.
Interfacciare i Risultati: Infine, i risultati vengono presentati in un formato interattivo che consente agli utenti di ispezionare le mutazioni generate.
Sperimentare con Mutazioni Diverse
Per testare l'efficacia dell'uso degli LLM, sono stati condotti esperimenti su applicazioni JavaScript del mondo reale. L'obiettivo era vedere quanti nuovi tipi di mutazioni potevano essere creati e quanto efficacemente venivano rilevati dai test esistenti.
Domande Chiave Affrontate
Diverse domande importanti guidano il processo di valutazione:
- Quanti mutanti crea lo strumento?
- Quanti dei mutanti sopravvissuti sono equivalenti al codice originale?
- Qual è l'effetto di diverse impostazioni di temperatura sull'output dell'LLM?
- Come influisce la strategia di prompting sul numero di mutazioni generate?
- Qual è il costo di eseguire lo strumento su diverse applicazioni?
Risultati dagli Esperimenti
Numero di Mutazioni Create
Lo strumento è riuscito a generare un numero sostanziale di mutanti su vari progetti. Ogni esecuzione dello strumento ha prodotto una gamma di suggerimenti, con molti risultati in nuovi mutanti. Tuttavia, è importante sapere che non tutte le modifiche generate erano sintatticamente valide.
Equivalenza dei Mutanti
Valutare l'Una sfida significativa nel mutation testing è determinare se un mutante si comporta allo stesso modo del codice originale. Alcune mutazioni potrebbero sembrare diverse ma svolgono gli stessi compiti in determinate condizioni. Nella valutazione, è stata fatta un'analisi manuale dei mutanti sopravvissuti per classificarli come equivalenti, quasi equivalenti o non equivalenti.
Comprendere le Impostazioni di Temperatura
L'LLM ha un'impostazione chiamata temperatura che influisce su quanto sia creativo il suo output. Una temperatura più bassa porta generalmente a output più prevedibili e stabili, mentre una temperatura più alta può produrre risultati altamente variati. Gli esperimenti hanno rivelato che, all'aumentare della temperatura, il numero di mutanti distinti aumenta anche, ma allo stesso tempo, alcuni mutanti possono essere sintatticamente non validi.
Impatto della Strategia di Prompting
Il modo in cui sono strutturati i prompt può influenzare significativamente il numero di mutanti generati. Diverse varianti di prompt sono state testate per vedere come influenzano i risultati. L'uso di prompt dettagliati tende a produrre risultati migliori rispetto a quelli minimi.
Confrontare le Prestazioni di Diversi LLM
La scelta dell'LLM influisce anche sulla generazione di mutazioni. Sono stati testati vari modelli e, mentre uno potrebbe generare costantemente più mutanti di un altro, il numero di mutanti sopravvissuti può variare tra i modelli.
Costo di Esecuzione dello Strumento
Infine, il costo e l'efficacia dello strumento sono considerazioni essenziali. Le spese sostenute per l'uso della versione commerciale dell'LLM sono state calcolate in base al numero di token usati sia per i prompt che per gli output. Il costo totale per eseguire lo strumento su diversi progetti si è rivelato ragionevole rispetto ai metodi tradizionali.
Conclusione
In sintesi, sfruttare gli LLM per il mutation testing rappresenta un avanzamento promettente nelle pratiche di testing software. La capacità di generare mutanti diversi e pertinenti potrebbe portare a processi di testing migliori e software di qualità superiore. Nonostante le sfide affrontate, come determinare l'equivalenza dei mutanti e gestire l'efficienza in fase di esecuzione, questo metodo apre nuove porte per il miglioramento nel campo del testing software. I lavori futuri si concentreranno sul perfezionamento della capacità del modello di generare mutazioni significative e sull'esplorazione delle sue applicazioni pratiche in vari ambienti di programmazione.
Direzioni Future
La ricerca futura si concentrerà su:
- Ridurre il numero di mutanti equivalenti creati dal modello.
- Trovare modi per generare test che possano rilevare i mutanti sopravvissuti.
- Valutare quanto bene i mutanti creati si accoppiano con i difetti del mondo reale.
Questo approccio ha il potenziale per migliorare significativamente le pratiche di mutation testing e aumentare l'affidabilità del software nel suo complesso.
Titolo: LLMorpheus: Mutation Testing using Large Language Models
Estratto: 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.
Autori: Frank Tip, Jonathan Bell, Max Schäfer
Ultimo aggiornamento: 2024-04-15 00:00:00
Lingua: English
URL di origine: https://arxiv.org/abs/2404.09952
Fonte PDF: https://arxiv.org/pdf/2404.09952
Licenza: https://creativecommons.org/licenses/by/4.0/
Modifiche: Questa sintesi è stata creata con l'assistenza di AI e potrebbe presentare delle imprecisioni. Per informazioni accurate, consultare i documenti originali collegati qui.
Si ringrazia arxiv per l'utilizzo della sua interoperabilità ad accesso aperto.
Link di riferimento
- 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