De nos jours, les logiciels sont de plus en plus complexes. La complexité des logiciels augmente avec leur taille et de ce fait, parfois la bonne structure originale est perdue. En conséquence, la vérification continue de la qualité du développement de ces logiciels est devenue indispensable. Elle nécessite un contrôle continu de la qualité du code tout au long du processus de développement. Plusieurs métriques ont été proposées afin de quantifier cette qualité, dans beaucoup de cas, ces métriques interviennent une fois le logiciel fini, or le contrôle de qualité serait plus efficace s'il intervenait tout au long de la phase de codage. Les métriques logicielles renseignent sur la qualité du code. Elles sont généralement présentées sous forme de tableau de données et sont donc difficilement exploitables. L'objectif général en développement de logiciels est de maintenir un produit de bonne qualité, qui soit extensible, d'une maintenance facile et réutilisable. Un grand problème en logiciel est constitué par les dépendances entre classes et paquets: c'est le couplage. On parlera d'architecture à couplage faible, lorsqu'elle est flexible, les changements sont simples et leurs coûts ne sont pas très élevés. Par contre, l'architecture devient rigide lorsque le ``couplage fort'' rend l'ajout de nouvelles fonctionnalités et la maintenance d'un logiciel très difficile. Les coûts de cette maintenance deviennent donc très élevés. Un autre problème connu est le manque de cohésion d'une classe, une classe est dite de bonne cohésion, si tous ses attributs sont utilisés par toutes ses méthodes. Dans le cas contraire, les méthodes et attributs ne communiquent pas suffisamment pour se retrouver dans une seule classe, et devrait être subdivisés en plusieurs classes. L'objectif de notre projet est de visualiser des indicateurs capables de distinguer une architecture flexible d'une architecture rigide. Pour mener à bien notre projet, une étude des différentes métriques déjà proposées est nécessaire, en considérant les métriques ayant un impact sur l'architecture, telle que les métriques de couplage entre classes et paquets. Pour ensuite proposer une visualisation, afin de faciliter l'interprétation des résultats obtenus par les métriques facilitant ainsi le travail du développeur. Au final, cette visualisation devrait permettre d'identifier les problèmes d'architecture. Ces zones critiques seront donc affichées à l'écran. Ainsi cette visualisation permettra de mieux guider le développeur dans sa maintenance.

Dans cette thèse nous nous intéressons à intégrer dans la distribution Linux produite par Mandriva une assurance qualité permettant de proposer des garanties de propriétés sur le code exécuté. Le processus de création d’une distribution implique l’utilisation de logiciels de provenances diverses pour proposer un assemblage cohérent et présentant une valeur ajoutée pour l’utilisateur. Ceci engendre une moindre maîtrise potentielle sur le code. Un audit manuel permet de s’assurer que celui-Ci présente de bonnes propriétés, par exemple, en matière de sécurité. Le nombre croissant de composants à intégrer, et la croissance de la quantité de code de chacun amènent à avoir besoin d’outils pour permettre une assurance qualité. Après une étude de la distribution nous choisissons de nous concentrer sur un paquet critique, le noyau Linux : nous proposons un état de l’art des méthodes de vérifications appliquées à ce contexte particulier, et identifions le besoin d’améliorer la compréhension de la structure du code source, la question de l’explosion combinatoire et le manque d’intégration des outils d’analyse de l’état de l’art. Pour répondre à ces besoins nous proposons une représentation du code source sous la forme d’un graphe, et l’utilisons pour aider à la documentation et à la compréhension de l’architecture du code. Des méthodes de détection de communautés sont évaluées sur ce cas pour répondre au besoin de l’explosion combinatoire. Enfin nous proposons une architecture intégrée dans le système de construction de la distribution permettant d’intégrer des outils d’analyse et de vérification de code. / In this thesis we are interested in integrating to the Linux distribution produced by Mandriva quality assurance level that allows ensuring user-Defined properties on the source code used. The core work of a distribution and its producer is to create a meaningful aggregate from software available. Those softwares are free and open source, hence it is possible to adapt it to improve end user’s experience. Hence, there is less control over the source code. Manual audit can of course be used to make sure it has good properties. Examples of such properties are often referring to security, but one could think of others. However, more and more software are getting integrated into distributions and each is showing an increase in source code volume: tools are needed to make quality assurance achievable. We start by providing a study of the distribution itself to document the current status. We use it to select some packages that we consider critical, and for which we can improve things with the condition that packages which are similar enough to the rest of the distribution will be considered first. This leads us to concentrating on the Linux kernel: we provide a state of the art overview of code verification applied to this piece of the distribution. We identify a need for a better understanding of the structure of the source code. To address those needs we propose to use a graph as a representation of the source code and use it to help document and understand its structure. Specifically we study applying some state of the art community detection algorithm to help handle the combinatory explosion. We also propose a distribution’s build system-Integrated architecture for executing, collecting and handling the analysis of data produced by verifications tools.

L'électronique dans les voitures devient de plus en plus complexe et représente plus de 30% du coût global d'une voiture. Par exemple, dans une BMW série 5 modèle 2008, on peut trouver jusqu'à 80 calculateurs électroniques communiquant ensemble et représentant aux alentours de 10 millions de lignes de code logiciel. Face à cette montée en complexité, les constructeurs et équipementiers électroniques de l'automobile s'intéressent de plus en plus à des méthodes efficaces de développement, vérification et validation de modules électroniques. Plus précisément, ils focalisent leurs efforts sur la partie logicielle de ces modules puisqu'elle est à l'origine de plus de 80% des problèmes détectés sur ces produits. Dans ce contexte, nous avons mené un travail de recherche dont l'objectif est de proposer une approche globale d'amélioration de la qualité des logiciels embarqués dans les véhicules. Notre recherche part d'un audit des processus et outils actuellement utilisés dans l'industrie électronique automobile. Cet audit a permis d'identifier des leviers potentiels d'amélioration de la qualité logicielle. En se basant sur les résultats de l'audit et en tenant compte de la littérature dans le domaine de la qualité logicielle, nous avons proposé une approche globale de conception de cas de test pour les produits logiciels. En effet, nous avons développé une plateforme de génération automatique de tests pour un produit logiciel. Cette plateforme consiste à modéliser les spécifications du produit logiciel pour le simuler lors de tests, à se focaliser sur les tests critiques (ayant une forte probabilité de détecter des défauts) et à piloter la génération automatique des tests par des critères de qualité ; telles que la couverture du code et de la spécification mais aussi le coût des tests. La génération de tests critiques est rendue possible par la définition de profils d'utilisation réelle par produit logiciel, ainsi que par la réutilisation des défauts et des tests capitalisés sur des anciens projets. En plus des aspects algorithmiques du test logiciel, notre approche prend en compte des aspects organisationnels tels que la gestion des connaissances et des compétences et la gestion de projet logiciel. Notre approche a été mise en œuvre sur deux cas d'étude réels d'un équipementier électronique automobile, disposant de données de tests historiques. Les résultats de nos expérimentations révèlent des gains de qualité significatifs : plus de défauts sont trouvés plus tôt et en moins de temps.

L’électronique dans les voitures devient de plus en plus complexe et représente plus de 30% du coût global d’une voiture. Par exemple, dans une BMW série 5 modèle 2008, on peut trouver jusqu’à 80 calculateurs électroniques communiquant ensemble et représentant aux alentours de 10 millions de lignes de code logiciel. Face à cette montée en complexité, les constructeurs et équipementiers électroniques de l’automobile s’intéressent de plus en plus à des méthodes efficaces de développement, vérification et validation de modules électroniques. Plus précisément, ils focalisent leurs efforts sur la partie logicielle de ces modules puisqu’elle est à l’origine de plus de 80% des problèmes détectés sur ces produits. Dans ce contexte, nous avons mené un travail de recherche dont l’objectif est de proposer une approche globale d’amélioration de la qualité des logiciels embarqués dans les véhicules. Notre recherche part d’un audit des processus et outils actuellement utilisés dans l’industrie électronique automobile. Cet audit a permis d’identifier des leviers potentiels d’amélioration de la qualité logicielle. En se basant sur les résultats de l’audit et en tenant compte de la littérature dans le domaine de la qualité logicielle, nous avons proposé une approche globale de conception de cas de test pour les produits logiciels. En effet, nous avons développé une plateforme de génération automatique de tests pour un produit logiciel. Cette plateforme consiste à modéliser les spécifications du produit logiciel pour le simuler lors de tests, à se focaliser sur les tests critiques (ayant une forte probabilité de détecter des défauts) et à piloter la génération automatique des tests par des critères de qualité ; telles que la couverture du code et de la spécification mais aussi le coût des tests. La génération de tests critiques est rendue possible par la définition de profils d’utilisation réelle par produit logiciel, ainsi que par la réutilisation des défauts et des tests capitalisés sur des anciens projets. En plus des aspects algorithmiques du test logiciel, notre approche prend en compte des aspects organisationnels tels que la gestion des connaissances et des compétences et la gestion de projet logiciel. Notre approche a été mise en œuvre sur deux cas d’étude réels d’un équipementier électronique automobile, disposant de données de tests historiques. Les résultats de nos expérimentations révèlent des gains de qualité significatifs : plus de défauts sont trouvés plus tôt et en moins de temps. / Nowadays, car electronics become more and more complex and represents more than 30% of the total cost of a car. For instance, in a 2008 BMW 5 series model, one can find up to 80 electronic modules communicating together and representing 10 million lines of software code. Facing this growing complexity, carmakers and automotive electronic suppliers are looking for efficient methods to develop, verify and validate electronic modules. In fact, they focus on the software part of these modules since it accounts for more than 80% of the total number of problems detected on these modules. In this context, we achieved our research project with the aim of proposing a global approach able to improve the quality of automotive embedded software. We started with an audit of the software practices currently used in automotive industry and we pinpointed potential levers to improve the global software quality. Based on the results of the audit and the literature review related to software quality, we developed a global approach to improve the design of test cases for software products. In fact, we developed a test generation platform to automatically generate test cases for a software product. It is mainly based on modeling the software functional requirements in order to be simulated when testing the software, focusing on critical tests to be done (because of their higher probability to detect a bug) and monitoring the automatic generation of tests by quality indicators such as the structural and functional coverage but also the tests cost. The generation of critical tests is based on the definition of real use profiles by software product and on the reuse of bugs and test cases capitalized on previous projects. Besides the computational aspects of software testing, our approach takes into account organizational matters such as knowledge management, competency management and project management. Our approach have been implemented in a computer platform and experimented on two typical case studies of an automotive electronic supplier, with historical test data. The results of our experiments reveal significant improvement in software quality: more bugs are detected earlier and in less time.

Les techniques émergentes de l’ingénierie dirigée par les modèles et de la programmation générative ont permis la création de plusieurs générateurs (générateurs de code et compilateurs). Ceux-ci sont souvent utilisés afin de faciliter le développement logiciel et automatiser le processus de génération de code à partir des spécifications abstraites. De plus, les générateurs modernes comme les compilateurs C, sont devenus hautement configurables, offrant de nombreuses options de configuration à l'utilisateur de manière à personnaliser facilement le code généré pour la plateforme matérielle cible. Par conséquent, la qualité logicielle est devenue fortement corrélée aux paramètres de configuration ainsi qu'au générateur lui-même. Dans ce contexte, il est devenu indispensable de vérifier le bon comportement des générateurs. Cette thèse établit trois contributions principales : Contribution I: détection automatique des inconsistances dans les familles de générateurs de code : Dans cette contribution, nous abordons le problème de l'oracle dans le domaine du test non-fonctionnel des générateurs de code. La disponibilité de multiples générateurs de code avec des fonctionnalités comparables (c.-à-d. familles de générateurs de code) nous permet d'appliquer l'idée du test métamorphique en définissant des oracles de test de haut-niveau (c.-à-d. relation métamorphique) pour détecter des inconsistances. Une inconsistance est détectée lorsque le code généré présente un comportement inattendu par rapport à toutes les implémentations équivalentes de la même famille. Nous évaluons notre approche en analysant la performance de Haxe, un langage de programmation de haut niveau impliquant un ensemble de générateurs de code multi-plateformes. Les résultats expérimentaux montrent que notre approche est capable de détecter plusieurs inconsistances qui révèlent des problèmes réels dans cette famille de générateurs de code. Contribution II: une approche pour l'auto-configuration des compilateurs. Le grand nombre d'options de compilation des compilateurs nécessite une méthode efficace pour explorer l'espace d’optimisation. Ainsi, nous appliquons, dans cette contribution, une méta-heuristique appelée Novelty Search pour l'exploration de cet espace de recherche. Cette approche aide les utilisateurs à paramétrer automatiquement les compilateurs pour une architecture matérielle cible et pour une métrique non-fonctionnelle spécifique tel que la performance et l'utilisation des ressources. Nous évaluons l'efficacité de notre approche en vérifiant les optimisations fournies par le compilateur GCC. Nos résultats expérimentaux montrent que notre approche permet d'auto-configurer les compilateurs en fonction des besoins de l'utilisateur et de construire des optimisations qui surpassent les niveaux d'optimisation standard. Nous démontrons également que notre approche peut être utilisée pour construire automatiquement des niveaux d'optimisation qui représentent des compromis optimaux entre plusieurs propriétés non-fonctionnelles telles que le temps d'exécution et la consommation des ressources. Contribution III: Un environnement d'exécution léger pour le test et la surveillance de la consommation des ressources des logiciels. Enfin, nous proposons une infrastructure basée sur les micro-services pour assurer le déploiement et la surveillance de la consommation des ressources des différentes variantes du code généré. Cette contribution traite le problème de l'hétérogénéité des plateformes logicielles et matérielles. Nous décrivons une approche qui automatise le processus de génération, compilation, et exécution du code dans le but de faciliter le test et l'auto-configuration des générateurs. Cet environnement isolé repose sur des conteneurs système, comme plateformes d'exécution, pour une surveillance et analyse fine des propriétés liées à l'utilisation des ressources (CPU et mémoire). / Generative software development has paved the way for the creation of multiple generators (code generators and compilers) that serve as a basis for automatically producing code to a broad range of software and hardware platforms. With full automatic code generation, users are able to rapidly synthesize software artifacts for various software platforms. In addition, they can easily customize the generated code for the target hardware platform since modern generators (i.e., C compilers) become highly configurable, offering numerous configuration options that the user can apply. Consequently, the quality of generated software becomes highly correlated to the configuration settings as well as to the generator itself. In this context, it is crucial to verify the correct behavior of generators. Numerous approaches have been proposed to verify the functional outcome of generated code but few of them evaluate the non-functional properties of automatically generated code, namely the performance and resource usage properties. This thesis addresses three problems : (1) Non-functional testing of generators: We benefit from the existence of multiple code generators with comparable functionality (i.e., code generator families) to automatically test the generated code. We leverage the metamorphic testing approach to detect non-functional inconsistencies in code generator families by defining metamorphic relations as test oracles. We define the metamorphic relation as a comparison between the variations of performance and resource usage of code, generated from the same code generator family. We evaluate our approach by analyzing the performance of HAXE, a popular code generator family. Experimental results show that our approach is able to automatically detect several inconsistencies that reveal real issues in this family of code generators. (2) Generators auto-tuning: We exploit the recent advances in search-based software engineering in order to provide an effective approach to tune generators (i.e., through optimizations) according to user's non-functional requirements (i.e., performance and resource usage). We also demonstrate that our approach can be used to automatically construct optimization levels that represent optimal trade-offs between multiple non-functional properties such as execution time and resource usage requirements. We evaluate our approach by verifying the optimizations performed by the GCC compiler. Our experimental results show that our approach is able to auto-tune compilers and construct optimizations that yield to better performance results than standard optimization levels. (3) Handling the diversity of software and hardware platforms in software testing: Running tests and evaluating the resource usage in heterogeneous environments is tedious. To handle this problem, we benefit from the recent advances in lightweight system virtualization, in particular container-based virtualization, in order to offer effective support for automatically deploying, executing, and monitoring code in heterogeneous environment, and collect non-functional metrics (e.g., memory and CPU consumptions). This testing infrastructure serves as a basis for evaluating the experiments conducted in the two first contributions.