Tests dans le développement de logiciels C++ embarqués

Jeudi 20 mars 2025
9 h à 16 h 30, pauses incluses

Code propre et C++ moderne :
Le code propre se réfère à un code lisible, bien structuré et facile à maintenir. Cela inclut des pratiques telles que l’adhésion aux conventions de nommage, la réduction de la complexité, l’organisation logique du code, et une documentation claire. Un code propre est également testable et modifiable sans introduire de bugs.
Le C++ moderne fait référence à l’utilisation des fonctionnalités récentes du langage, telles que les lambda expressions, les pointeurs intelligents, le RAII (Resource Acquisition Is Initialization), et les nouvelles bibliothèques standard. Ce style encourage une meilleure gestion de la mémoire, la sécurité des types, et la lisibilité du code.

Principes d’un bon test et défis dans l’environnement embarqué :
Un bon test est celui qui est automatisé, répétable, isolé (ne dépend pas d’autres tests) et prédit les résultats attendus. Les défis dans l’environnement des logiciels embarqués incluent la gestion des dépendances matérielles, la limitation des ressources (mémoire, processeur), et l’absence de disponibilité des outils de test standards (ex. frameworks de tests intégrés). Le test d’une application embarquée peut également être compliqué par le besoin de simuler le matériel ou de tester dans des conditions réelles limitées.

Faux, simulations, tests unitaires, tests d’intégration :

• Faux (Mocks) : Objets ou composants simulés qui imitent le comportement d’éléments réels dans un environnement de test, permettant de tester des modules sans dépendre des autres parties du système.
• Simulations : Représentations virtuelles du matériel ou de l’environnement dans lequel le logiciel s’exécute, permettant de tester des scénarios sans avoir un matériel physique.
• Tests unitaires : Tests qui vérifient des fonctions ou des unités individuelles de code en isolation. L’objectif est de s’assurer que chaque composant fonctionne indépendamment de l’ensemble du système.
• Tests d’intégration : Tests qui vérifient que différentes parties du système fonctionnent correctement ensemble. L’objectif est de tester les interactions entre les modules ou composants.

Mettre en place, structurer et nommer des tests pour établir une suite de tests complète :
Une suite de tests complète inclut les tests unitaires, les tests d’intégration, et les tests fonctionnels. Pour cela, il faut structurer les tests selon une hiérarchie logique, en organisant les tests par modules ou fonctionnalités, et en leur donnant des noms descriptifs qui clarifient l’objectif de chaque test.

Structuration et conception de logiciels testables : Utilisation de l’abstraction et des interfaces :
Pour rendre un logiciel testable, il est important d’abstraire les dépendances matérielles ou externes en utilisant des interfaces. Cela permet de simuler ces composants dans les tests sans avoir besoin d’un matériel réel. La conception orientée objet et l’utilisation de principes tels que l’injection de dépendance rendent le code plus modulaire et donc plus facile à tester.

Séparation des composants logiciels dépendants du matériel et indépendants :
Il est essentiel de séparer les composants qui dépendent directement du matériel (ex. pilotes, interactions avec les périphériques) des autres parties du logiciel qui peuvent être testées indépendamment du matériel. Cette séparation rend les tests plus faciles, car les composants non matériels peuvent être testés sans l’implication du matériel réel.

Implémentation du modèle de conception « Injection de dépendance » dans Modern C++ comme élément central pour isoler les composants :
L’injection de dépendance (DI) permet d’injecter des objets nécessaires au fonctionnement d’un module sans les créer à l’intérieur du module. En C++ moderne, cela se fait généralement par des interfaces et des constructeurs ou des pointeurs intelligents, facilitant ainsi l’isolation des modules pour les tests.

Approches d’exécution et de compilation pour injecter des faux :
Les faux peuvent être injectés de différentes manières. L’injection à l’exécution permet de remplacer les objets ou services pendant l’exécution du test, alors que l’injection à la compilation est réalisée au moment de la construction du code, souvent via des mocks ou des stubs définis dans le code source.

Introduction et utilisation de frameworks de tests (Google Test, GMock) :
Google Test et GMock sont des frameworks populaires en C++ pour effectuer des tests unitaires et des tests de simulation (mocks). Ils offrent des outils pour vérifier les attentes sur les objets simulés, valider les résultats de tests et automatiser les scénarios de tests.

CMake comme outil pour décrire le processus de construction du code de production et de test :
CMake est un système de génération de builds qui permet de décrire de manière flexible le processus de compilation et d’intégration de logiciels. Il est utilisé pour organiser à la fois le code de production et les tests dans un projet C++, en définissant des règles pour compiler et lier le code ainsi que pour exécuter les tests.

Intégration des activités de tests dans le processus de développement logiciel (CI/CD) :
L’intégration des tests dans le processus CI/CD (Intégration Continue/Déploiement Continu) permet de valider automatiquement le code à chaque modification, ce qui assure une meilleure qualité du logiciel à chaque étape du développement. Cela inclut l’exécution des tests unitaires à chaque commit et leur validation avant de déployer le code en production.

Outils d’analyse de la couverture des tests dans un contexte C++ :
Les outils de couverture de tests, comme GCov ou LCOV, permettent de mesurer quel pourcentage du code est couvert par les tests. Ces outils fournissent des rapports détaillés sur les parties du code qui n’ont pas été testées, permettant ainsi de cibler les zones du code nécessitant plus de tests.

Mesures de qualité et analyse de code statique :
L’analyse de code statique consiste à examiner le code sans l’exécuter pour détecter des erreurs potentielles, des violations de normes ou des problèmes de performance. Des outils comme Cppcheck ou Clang Static Analyzer permettent d’analyser le code source C++ pour en garantir la qualité et la conformité aux bonnes pratiques.