Lors du développement d'un logiciel, plusieurs phases de test sont mises en oeuvre. Dans cette thèse, nous nous intéressons particulièrement à deux d'entre elles : les test unitaire et le test d'intégration. Dans le test unitaire, les entités du logiciel sont testées individuellement. Elles sont ensuite intégrée au sein d'un agrégat qui est soumis à un test d'intégration. Lors de cette phase, on cherche traditionnellement à tester les interactions entre ces entités. Nous nous intéressons plus particulièrement dans cette thèse au test structurel unitaire. Lors de cette phase de test, si l'entité contient des app rers d'autres entités, elles sont remplacées par des bouchons simples qui facilitent le test. Ces bouchons ne sont pas exempts de défauts. En particulier, ils sont généralement pas représentatifs des entités qu'ils remplacent. Les taux de couverture obtenus pendant le test ne représentent donc pas l'utilisatin éelle de la fonction testée. Dans cette thèse, nous proposons d'étendre la phase de test unitaire aux agrégats de fonctions. Tous les bouchons nécessaires sont produits automatiquement à partir du code des fonctions appelées. Pour cela, on se base sur une analyse et un découpage du flot de ontrôle de la fonction appelée en approximations, ainsi que sur la détermination de l'environnement particulier de chaque appel. Cet environnement ontient les informations sur les conditions d'appel à la fonction et sur l'impact de cet appel sur le flot de contrôle de la fonction appelante. On crée inalement le bouchon spécifique à un appel par filtrage des approximations par le contexte d'appel. On sélectionne ensuite une approximation pour chaque objectif de génération. L'ensemble de cette technique a été implanté au sein d'un prototype basé sur l'outil de test Inka.

Au cours des dernières années, les tests unitaires sont devenus un élément essentiel de tout projetlogiciel sérieux afin de vérifier son bon fonctionnement.Cependant, les tests sont fastidieux et coûteux pour l'industrie: il est difficile d'évaluer le retour surinvestissement.Pour surmonter ce problème, la recherche étudie l'automatisation de la création de tests.Même si ces suites de tests générées automatiquement ont une très bonne qualité, il existe toujours desobstacles à l'adoption de telles techniques par l'industrie.Cela s'explique par les difficultés à comprendre, intégrer et gérer la suite de tests générée.L'objectif de cette thèse est de remédier à ces difficultés en proposant une nouvelle technique quiproduit des nouveaux tests basés sur les tests existants. Cette technique s'appelle "amplification detests". Par construction, ces nouveaux tests sont donc proches des tests écrits par des humains, et doncsont faciles à comprendre, à intégrer et à gérer. Cette approche est implémentée sous forme d'un outilappelé DSpot. / In recent years, unit testing has become an essential part of any serious software project to verify itsproper functioning.However, the tests are tedious and expensive for the industry: it is difficult to evaluate the return oninvestment.To overcome this problem, the research is investigating the automation of test creation.Although these automatically generated test suites are of high quality, there are still barriers to theindustry adoption of such techniques.This is because of the difficulty in understanding, integrating, and managing the generated test suite.The objective of this thesis is to overcome these difficulties by proposing a new technique thatproduces new tests based on existing tests. This technique is called "test amplification". Byconstruction, these new tests are close to the tests written by humans, and therefore are easy tounderstand, integrate and manage. This approach is implemented as a tool called DSpot.

Le logiciel est devenu omniprésent dans nos vies de sorte qu'on le retrouve dans plusieurs domaines de la vie courante. Cependant cette omniprésence, n'est pas sans conséquences. Les bogues de logiciel peuvent causer de vrais désastres, économiques, écologiques voire sanitaires. Vu la forte omniprésente du logiciel dans nos vies, le fonctionnement de nos sociétés dépend fortement de sa qualité. La programmation par contrat a pour but de produire des logiciels fiables, c'est-à-dire corrects et robustes. En effet, ce paradigme de programmation vise à introduire des assertions qui sont des spécifications de services. Ces spécifications représentent une forme de contrat. Les contrats définissent les responsabilités entre le client et le fournisseur. Le respect des contrats permet de garantir que le logiciel ne fait ni plus ni moins que ce que l'on attend de lui qu'il fasse. Le test unitaire est un test qui permet de s'assurer du bon fonctionnement d'une partie précise d'un logiciel. C'est un test dont la vérification se fait en exécutant une petite unité de code. En somme, un test unitaire est un code qui exécute de manière indirecte le code d'une classe pour vérifier que le code fonctionne bien. L'outil Génération de Squelettes des Contrats de classes et des tests unitaires (GACTUS) permet la génération automatique de squelettes de contrats de classes et celles des classes des tests unitaires d'un projet Java. La génération automatique du code source permet d'obtenir un code uniforme. GACTUS est un plug-in pour l'environnement de développement Eclipse écrit en Java. L'objectif principal de GACTUS est de faciliter la réalisation de logiciel de qualité grâce à la génération automatique des squelettes de contrats de classe et celui des tests unitaires et aussi d'accroître la productivité des développeurs. Pour faciliter son utilisation, GACTUS dispose d'une interface graphique permettant de guider l'utilisateur.

Actuellement, le développement d’un logiciel de taille industriel repose généralement surdes tests ou des preuves unitaires pour garantir rigoureusement ses exigences. En outre, il adéjà été montré que l’utilisation combinée du test et de la preuve unitaires est plus efficaceque l’utilisation d’une seule de ces deux techniques. Néanmoins, un ingénieur en vérificationhésite encore à utiliser ces deux techniques conjointement, faute d’une notion de couverturecommune au test et à la preuve. Définir une telle notion est l’objet de cette thèse.En effet, nous introduisons une nouvelle couverture, appelée « couverture label-mutant ».Elle permet de représenter les critères de couverture structurelle habituels du test, comme lacouverture des instructions, la couverture des branches ou la couverture MC/DC et de décidersi le critère choisi est satisfait en utilisant une technique de vérification formelle, qu’elle soitpar test, par preuve ou par une combinaison des deux. Elle permet également de représenterles critères de couverture fonctionnelle. Nous introduisons aussi dans cette thèse une méthodereposant sur des outils automatiques de test et de preuve pour réduire l’effort de vérificationtout en satisfaisant le critère de couverture choisi. Cette méthode est mise en oeuvre au seinde la plateforme d’analyse de code C (Frama-C), fournissant ainsi à un ingénieur un moyenopérationnel pour contrôler et réaliser la vérification qu’il souhaite. / Currently, industrial-strength software development usually relies on unit testing or unitproof in order to ensure high-level requirements. Combining these techniques has already beendemonstrated more effective than using one of them alone. The verification engineer is yetnot been to combine these techniques because of the lack of a common notion of coverage fortesting and proving. Defining such a notion is the main objective of this thesis.We introduce here a new notion of coverage, named « label-mutant coverage ». It subsumesmost existing structural coverage criteria for unit testing, including statement coverage,branch coverage or MC/DC coverage, while allowing to decide whether the chosen criterionis satisfied by relying on a formal verification technique, either testing or proving or both.It also subsumes functional coverage criteria. Furthermore, we also introduce a method thatmakes use of automatic tools for testing or proving in order to reduce the verification costwhile satisfying the chosen coverage criterion. This method is implemented inside Frama-C, aframework for verification of C code (Frama-C). This way, it offers to the engineer a way tocontrol and to perform the expected verifications.