Exploiter les LLMs pour améliorer la génération d'oracles de test

Le test de logiciels est super important pour dénicher les bugs dans les programmes. Une partie clé de ce process, c'est l'oracle de test, qui aide à vérifier si le logiciel fonctionne comme il faut. Même s'il existe des méthodes automatiques pour créer ces oracles de test, beaucoup d'entre elles donnent trop de résultats incorrects. Les grands modèles de langage (LLM) ont montré qu'ils peuvent être utiles dans différentes tâches liées aux logiciels comme écrire du code, créer des cas de test, et corriger des bugs, mais il n'y a pas eu beaucoup de recherches sur leur efficacité pour générer des oracles de test fiables.

Dans cette étude, on examine si les LLM peuvent produire des oracles de test corrects, variés et solides qui peuvent repérer des bugs uniques. On a entraîné sept LLM différents avec divers prompts sur un dataset appelé SF110. En identifiant la combinaison de modèle et de prompt la plus efficace, on a développé une nouvelle méthode pour générer des oracles de test. Pour voir comment cette méthode fonctionne, on l'a testée sur 25 grands projets Java. On a pris en compte non seulement la justesse mais aussi la diversité et la force des oracles générés, en comparant nos résultats avec d'autres méthodes comme EvoSuite et TOGA.

#Importance des Oracles de Test

Les oracles de test sont cruciaux dans les tests de logiciels parce qu'ils définissent le comportement attendu du logiciel. Une suite de test est composée de cas de test, où chaque cas teste une partie spécifique du programme. L'oracle de test vérifie si le programme a agi comme prévu. Il y a deux types principaux d'oracles de test:

1. Oracles d'Assertion : Ils vérifient si la sortie du programme est correcte.
2. Oracles d'Exception : Ils vérifient si le programme identifie correctement les erreurs.

Pour que les oracles de test soient efficaces, ils doivent non seulement être corrects mais aussi solides. Un oracle correct signifie qu'il correspond au comportement attendu sans fausses alertes. Un oracle solide peut détecter quand le programme fait quelque chose de faux. C'est important d'avoir ces deux qualités pour garantir une détection précise des bugs.

Bien que créer manuellement des oracles de test soit plus efficace, ça prend beaucoup de temps et d'efforts. Pour répondre à ce problème, des chercheurs ont cherché des moyens d'automatiser ce processus.

#Méthodes Utilisées pour la Génération d'Oracles

Il y a eu plusieurs approches pour créer des oracles de test automatiquement, en utilisant des techniques de traitement du langage naturel et de reconnaissance de motifs. Certaines méthodes génèrent des oracles basés sur des commentaires et de la documentation. Celles-ci peuvent produire à la fois des oracles d'assertion et d'exception.

Récemment, des réseaux de neurones ont été appliqués à la génération d'oracles. La méthode TOGA a montré de meilleures performances que les méthodes précédentes. Cependant, elle a encore des limites, générant des oracles d'assertion corrects seulement 38% du temps, avec un taux élevé de faux positifs pour les oracles d'assertion et d'exception. Cela souligne la nécessité d'avancées supplémentaires dans la création d'oracles de test automatiques fiables.

#Exploration des LLMs pour la Génération d'Oracles de Test

Les LLM gagnent en attention pour diverses tâches en ingénierie logicielle, y compris les tests. Les premières tentatives d'utiliser des LLM pour générer des cas de test ont rencontré des défis pour atteindre une bonne couverture de test. Certaines études ont montré un succès limité dans la génération de préfixes de test pour de grands programmes Java. D'autres ont essayé d'utiliser des LLM pour produire à la fois des préfixes de test et des oracles de test, mais n'ont pas évalué la qualité des oracles générés pour la détection des bugs.

Dans notre recherche, on a séparé la tâche. On a utilisé des méthodes bien établies comme EvoSuite pour créer des préfixes de test et on s'est concentré uniquement sur l'utilisation des LLM pour générer des oracles de test. On a affiné sept LLM de code différents en utilisant divers prompts qui fournissaient différentes quantités de contexte sur le logiciel testé.

#Les Modèles Utilisés

On a exploré plusieurs LLM pré-entraînés, chacun avec des tailles et des capacités variées. Les modèles examinés incluent :

1. CodeGPT : Un modèle plus petit qui a montré de bons résultats en Java.
2. CodeParrot : Ce modèle performe bien malgré sa légèreté.
3. CodeGen : Disponible en plusieurs tailles, ces modèles sont bons pour comprendre le code.
4. PolyCoder : Une autre famille de modèles entraînés sur une large gamme de langages de programmation.
5. Phi-1 : Bien qu'entraîné principalement sur Python, ce modèle a bien fonctionné dans nos évaluations pour Java.

#Préparation des Données d'Entraînement

Pour entraîner nos modèles, on a utilisé le dataset SF110, qui contient de nombreux projets Java avec des cas de test générés par EvoSuite. On a traité ces données pour créer des tuples qui incluaient le préfixe de test, la méthode à tester, et l'oracle correspondant. Ce dataset a ensuite été divisé en sous-ensembles d'entraînement, de test et de validation pour garantir une évaluation équitable de nos méthodes.

#Conception de Prompts Efficaces

On a créé six prompts différents pour affiner les LLM, en ajoutant progressivement plus de contexte :

1. P1 : Seulement le préfixe de test.
2. P2 : Préfixe de test et documentation de la méthode.
3. P3 : Préfixe de test et signature de la méthode.
4. P4 : Préfixe de test, documentation, et signature de la méthode.
5. P5 : Préfixe de test et tout le code de la méthode.
6. P6 : Préfixe de test, documentation, et tout le code de la méthode.

On a trouvé que fournir plus d'infos en arrière-plan améliorait la précision, mais parfois les modèles plus grands ne performaient pas mieux que les plus petits quand ils étaient correctement affinés.

#Évaluation des Modèles

Une fois qu'on a affiné les modèles, on a testé leur performance sur 25 projets Java qui étaient nouveaux pour eux. On a généré des oracles de test pour chaque projet et on les a validés en exécutant les tests. La précision a été mesurée en fonction de combien d'oracles générés ont passé les tests.

#Comparaison avec D'autres Méthodes

On a comparé nos oracles générés par les LLM avec ceux générés par TOGA et EvoSuite. L'objectif était de voir combien d'oracles corrects chaque méthode pouvait générer et comment elles pouvaient bien détecter les bugs.

#Résultats et Découvertes

#Efficacité des LLMs

Nos résultats suggèrent que les LLM peuvent vraiment produire des oracles de test solides et corrects. En fait, le meilleur LLM a généré beaucoup plus d'oracles d'assertion et d'exception corrects par rapport à TOGA. Ça veut dire qu'utiliser des LLM améliore le processus de génération d'oracles de test fiables.

#Diversité des Oracles Générés

Un autre aspect important qu'on a regardé, c'est la diversité. Les oracles générés par les LLM ont montré une large gamme de styles d'assertion, les rendant adaptés à compléter les oracles écrits par des développeurs traditionnels. Cette diversité est cruciale pour détecter des bugs qui pourraient être ratés par des approches plus uniformes.

#Force des Oracles dans la Détection des Bugs

La force des oracles créés par les LLM a été évaluée par des tests de mutation. Ce processus consiste à faire de petits changements dans le code pour créer des "mutants" et voir si les oracles de test peuvent détecter ces changements. Nos résultats ont indiqué que les oracles générés par les LLM pouvaient identifier de nombreux bugs uniques que d'autres ne pouvaient pas.

#Défis et Limitations

Malgré les résultats prometteurs, certains défis restent. Par exemple, environ 5% des assertions générées n'ont pas pu se compiler à cause de petites erreurs de syntaxe. De plus, une petite fraction des sorties générées était des faux positifs - des assertions qui indiquaient un problème quand il n'y en avait pas.

#Directions Futures

Pour aller de l'avant, affiner les modèles pour réduire les erreurs de compilation et les faux positifs sera une priorité. Un autre domaine d'accent sera de trouver des moyens d'utiliser une meilleure documentation de qualité, ce qui pourrait améliorer les oracles générés.

#Conclusion

Les LLM ont un grand potentiel pour améliorer la génération d'oracles de test dans les tests de logiciels. Notre recherche montre qu'ils peuvent produire plus d'oracles de test corrects, divers et solides que les méthodes précédentes. En s'attaquant aux défis existants et en continuant à affiner ces techniques, on peut faire des avancées significatives vers des processus de test de logiciels plus fiables. Ce travail prépare le terrain pour de futures avancées dans la génération automatique d'oracles de test.