Découvrez GoogleTest certifié TÜV avec Agentic AI pour les tests C/C++ !
Plus de détails »
Aller à la section
Blog Parasoft
Découvrez comment créer des scénarios de test robustes pour valider les systèmes embarqués et garantir leur conformité aux normes de sécurité. Notre guide propose des méthodes pratiques pour les tests unitaires, d'intégration et système afin d'améliorer la qualité et d'accélérer le développement.
Aller à la section
La rédaction de cas de test efficaces est essentielle pour valider les fonctionnalités des systèmes embarqués, détecter rapidement les défauts et garantir la conformité aux normes de sécurité.
Ce guide fournit des conseils pratiques sur la rédaction de tests unitaires , de tests d'intégration et de cas de tests système pour les systèmes embarqués, vous aidant ainsi à améliorer la qualité des logiciels et à accélérer les cycles de développement.
Les tests unitaires en C/C++ embarqué consistent à valider individuellement les fonctions et les modules. Les cas de tests unitaires efficaces suivent une structure cohérente :
La rédaction de tests unitaires complets pour du code embarqué nécessite de gérer les dépendances matérielles à l'aide de techniques de simulation et de stubbing. Lors du test des fonctions de contrôle GPIO, des routines de lecture de capteurs ou des algorithmes de traitement de données, il convient d'isoler les interactions matérielles afin de pouvoir effectuer des tests sans dispositifs physiques.
Les solutions de test de logiciels embarqués offrent des fonctionnalités spécialisées permettant de gérer efficacement ces abstractions matérielles. Étant donné que de nombreux systèmes embarqués sont critiques pour la sûreté et la sécurité, ces tests rigoureux doivent vérifier les exigences fonctionnelles et les exigences de qualité de service telles que la synchronisation, la fiabilité et l'utilisation des ressources.
L'organisation des cas de test améliore la maintenabilité.
Regroupez les cas de test apparentés en suites de tests, utilisez des conventions de nommage descriptives indiquant clairement ce qui est testé et structurez les assertions pour valider à la fois la correction fonctionnelle et les cas limites. Par exemple, lors du test d'une fonction de conversion de température, créez des cas de test distincts pour les plages normales, les valeurs limites et les conditions d'erreur.
Les défis propres aux systèmes embarqués incluent les contraintes de mémoire et les exigences de synchronisation en temps réel. Par conséquent, il convient de concevoir des cas de test respectant les budgets de mémoire cibles et de vérifier que les opérations critiques en termes de temps respectent les délais.
Les tests des gestionnaires d'interruptions et des opérations concurrentes exigent une attention particulière afin de garantir la sécurité des threads et une synchronisation correcte. Les tests automatisés pour les systèmes embarqués contribuent à relever ces défis grâce à une génération et une exécution intelligentes des tests.
Les grands modèles de langage comme ChatGPT accélèrent la création de tests unitaires en générant du code de test, en suggérant des scénarios et en identifiant les cas limites potentiels. Cependant, pour le C et le C++ embarqués, les tests générés par l'IA peuvent manquer d'informations essentielles concernant les dépendances matérielles, les contraintes temps réel, les API de la plateforme, les exigences et les considérations de sûreté et de sécurité.
Les tests générés doivent encore être examinés et vérifiés par des ingénieurs.
Parasoft combine des capacités éprouvées de vérification logicielle avec l'IA dans les tests de logiciels embarqués afin d'améliorer la productivité tout en maintenant la qualité des tests grâce à la supervision humaine et à la connaissance du domaine embarqué.
Parasoft C/C++test, pour la génération automatisée de tests, utilise l'analyse statique pour identifier :
La correction assistée par l'IA aide les développeurs à comprendre les résultats et à générer des solutions proposées.
De plus, la création de tests unitaires assistée par l'IA aide les développeurs à créer des tests et à améliorer la couverture.
Pour les équipes utilisant des frameworks de test C et C++ existants tels que GoogleTest, C/C++test CT étend l'assistance de l'IA à l'analyse de couverture. Les flux de travail assistés par l'IA analysent les lacunes de couverture, notamment MC/DC, et aident à identifier les conditions de test supplémentaires nécessaires pour explorer les chemins manquants.
L'intégration du protocole MCP (Model Context Protocol) connecte les assistants et agents IA aux capacités de vérification et aux données de Parasoft, offrant un accès à l'analyse, aux tests et aux informations de couverture spécifiques au projet.
Approfondissez
Découvrez comment les serveurs MCP optimisent le développement d'agents pour des flux de travail de test avancés assistés par l'IA.
L'IA apporte une aide précieuse. Elle ne remplace pas le processus de vérification.
L'IA aide les ingénieurs à exploiter plus rapidement ces données probantes tout en leur permettant de garder le contrôle des résultats.
La conception efficace de cas de test embarqués suit des principes fondamentaux qui répondent aux défis uniques des systèmes critiques pour la sécurité et aux ressources limitées.
Les principes clés comprennent :
Les problématiques spécifiques aux systèmes embarqués influencent la conception des cas de test.
Mettez en place une base solide de nombreux tests unitaires qui valident rapidement et en profondeur chaque fonction. Ajoutez des tests d'intégration qui vérifient les interactions et les interfaces entre les composants. Complétez la vérification et la validation par des tests système ciblés qui valident le comportement de bout en bout dans des scénarios réalistes. Cette approche équilibrée optimise la détection des défauts tout en préservant l'efficacité de l'exécution des tests.
Les tests automatisés pour les systèmes embarqués et les méthodes de test de conformité logicielle contribuent à mettre en œuvre efficacement ces principes tout au long du cycle de vie du développement.
La conception de cas de test basée sur les exigences dérive les cas de test directement des exigences du système et du logiciel, garantissant une validation complète du comportement spécifié.
Analyser les documents d'exigences pour identifier les conditions testables, créer des cas de test qui valident chaque exigence et établir une traçabilité bidirectionnelle entre les exigences et les tests afin de démontrer une couverture complète.
Rédigez des cas de test qui vérifient à la fois les exigences fonctionnelles (ce que le système doit faire) et les exigences non fonctionnelles (performance, temps d'exécution, utilisation des ressources).
Pour les exigences fonctionnelles, créez des cas de test positifs qui valident le comportement attendu dans des conditions normales et des cas de test négatifs qui vérifient la bonne gestion des erreurs, la validation des entrées et la gestion des conditions limites.
Les indicateurs de couverture des exigences garantissent des tests approfondis.
Cette approche systématique réduit le risque de défaillance de fonctionnalités critiques et favorise la conformité aux normes de sûreté et de sécurité.
Les solutions de traçabilité des exigences assurent un suivi automatisé entre les exigences et les cas de test, ce qui est essentiel pour les secteurs réglementés comme le médical, le ferroviaire, l'énergie et autres.
Pour les logiciels aéronautiques, les tests basés sur les exigences de conformité à la norme DO-178C garantissent une couverture complète des exigences de navigabilité. De même, les tests basés sur les exigences de conformité à la norme ISO 26262 soutiennent la validation de la sécurité fonctionnelle automobile.
L'analyse des valeurs limites et le partitionnement par équivalence sont des techniques systématiques pour concevoir des cas de test efficaces qui maximisent la détection des défauts.
Identifiez les limites d'entrée (valeurs minimales, valeurs maximales, valeurs limites) où les défauts se produisent le plus souvent, et créez des cas de test qui exploitent ces limites ainsi que des valeurs représentatives des plages valides.
Les classes d'équivalence regroupent les entrées similaires qui devraient produire un comportement similaire. Il est préférable de sélectionner des cas de test représentatifs de chaque classe d'équivalence plutôt que de tester exhaustivement toutes les valeurs d'entrée possibles. Cette approche garantit une couverture complète tout en préservant des temps d'exécution raisonnables.
Les systèmes embarqués présentent des scénarios de limites spécifiques :
Appliquez ces techniques à la vérification des résultats. Lorsqu'une fonction produit des résultats calculés, vérifiez les sorties aux limites attendues et assurez-vous du bon comportement des sorties lorsqu'elles s'en approchent. L'analyse statique du code pour la vérification des limites permet d'identifier les défauts potentiels liés aux limites avant l'exécution des tests.
Les métriques de couverture de code mesurent l'exhaustivité des cas de test et identifient les lacunes dans les tests.
Les systèmes embarqués nécessitent la prise en charge de code spécialisé.
Ces chemins de code, souvent négligés, sont essentiels à la fiabilité des systèmes embarqués.
Les objectifs de couverture varient selon le niveau de criticité. Les fonctions critiques pour la sécurité peuvent nécessiter une couverture à 100 % des déclarations et des branches, avec une couverture complète des conditions/décisions modifiées (MC/DC), pour obtenir la certification.
Les fonctions moins critiques peuvent accepter des seuils de couverture inférieurs. Définissez des objectifs appropriés en fonction de l'évaluation des risques et des exigences réglementaires.
Apprenez-en davantage sur la façon d'obtenir une couverture à 100 % des codes de structure pour les systèmes critiques pour la sécurité.
Les rapports de couverture guident la création des cas de test. Examinez le code non couvert pour déterminer si des cas de test supplémentaires sont nécessaires ou si l'utilisation de code défensif inaccessible peut être justifiée.
Il est préférable de créer des cas de test pour les chemins critiques non couverts plutôt que de tester exhaustivement le code moins important. Les solutions de couverture de code pour systèmes embarqués fournissent une analyse et un rapport détaillés, tandis que la mesure des indicateurs de couverture permet de suivre l'avancement des tests et d'identifier les lacunes.
Les tests des systèmes embarqués se déroulent par étapes distinctes, chacune ayant une portée et des objectifs spécifiques.
Les cas de test diffèrent selon les niveaux en termes de granularité et d'objectif.
Le passage des tests unitaires aux tests système assure une validation par couches.
Cette approche par étapes améliore l'efficacité en détectant différents types de défauts au niveau approprié.
La compréhension des méthodes de test de conformité logicielle permet de choisir l'approche de test la plus adaptée à chaque niveau. De plus, les stratégies de tests de régression garantissent que les modifications n'altèrent pas les fonctionnalités existantes à tous les niveaux de test.
Les tests unitaires valident individuellement les fonctions et modules C/C++. Chaque test doit être structuré en quatre phases distinctes : initialisation, exécution, assertion et nettoyage.
La fonction setup initialise les variables, prépare les données de test et configure les simulations pour les dépendances matérielles. Pour le code embarqué qui accède aux broches GPIO ou aux capteurs, simulez ces interactions matérielles afin de permettre les tests sans périphériques physiques.
L'exécution appelle la fonction testée avec des entrées spécifiques. Veillez à ce que la phase d'exécution se concentre sur le test d'un seul aspect de la fonctionnalité par cas de test.
Les assertions vérifient les résultats attendus, les effets de bord et les changements d'état. Elles contrôlent les valeurs de retour, valident les variables modifiées et confirment que les fonctions simulées ont été appelées correctement. En cas d'échec des tests, rédigez des assertions qui indiquent clairement la cause du problème.
La suppression des ressources libère les ressources, réinitialise l'état global et garantit l'isolation des tests. Un nettoyage approprié empêche les cas de test d'interférer entre eux. Le respect des bonnes pratiques de tests unitaires assure des suites de tests cohérentes et maintenables.
Les tests unitaires automatisés avec C/C++test simplifient la création et l'exécution des cas de test, tandis que l'analyse de la couverture du code permet de visualiser les chemins de code qui ont été validés.
Les cas de tests d'intégration valident les interactions entre les composants des systèmes embarqués. Ils portent principalement sur les interfaces entre les modules logiciels, les points d'intégration matériel-logiciel, les protocoles de communication et les interactions entre sous-systèmes.
Concevez des cas de test vérifiant le flux de données entre les composants. Assurez-vous que les données échangées entre les modules conservent leur intégrité et leur format correct. Testez l'utilisation de l'API pour garantir que les composants utilisent correctement les interfaces et gèrent correctement les valeurs de retour.
La synchronisation est essentielle lors des tests d'intégration de systèmes embarqués. Vérifiez que les composants se synchronisent correctement, notamment dans les architectures multithread ou pilotées par interruptions. Testez la communication et la gestion des événements entre les composants afin de garantir un séquencement correct.
La propagation des erreurs mérite une attention particulière. Il est essentiel de vérifier que les erreurs détectées dans un composant se propagent correctement aux composants dépendants et que les systèmes gèrent les erreurs de manière appropriée, sans provoquer de défaillances en cascade. L'utilisation de stubs lors des tests d'intégration permet d'isoler les composants et de simuler différents scénarios d'intégration.
Pour les industries réglementées, des approches de test d'intégration spécifiques sont essentielles. Les tests d'intégration conformes à la norme DO-178C répondent aux exigences des logiciels aéronautiques, tandis que les tests d'intégration conformes à la norme ISO 26262 garantissent la conformité en matière de sécurité fonctionnelle pour le secteur automobile.
Les cas de test système valident le comportement complet du système embarqué dans des scénarios opérationnels simulés ou réalistes. Concevez des cas de test exhaustifs qui vérifient les exigences système, valident les cas d'utilisation et les scénarios utilisateurs, et confirment la fonctionnalité de bout en bout.
Les tests complets du flux de travail valident l'intégralité des séquences. Testez les procédures de démarrage, de la mise sous tension à l'état opérationnel, en passant par l'initialisation. Vérifiez le fonctionnement normal dans des conditions d'utilisation typiques. Validez les séquences d'arrêt et de gestion de l'alimentation.
Les exigences de performance au niveau du système nécessitent une validation approfondie :
Les scénarios critiques pour la sécurité exigent une conception rigoureuse des cas de test. Il convient de vérifier le bon déclenchement des mécanismes de détection des pannes, de tester les procédures de récupération d'erreurs pour rétablir le fonctionnement du système, de s'assurer de l'activation des comportements de sécurité en cas de défaillance critique et de confirmer le bon fonctionnement des temporisateurs de surveillance et du système de contrôle d'état.
L'intégration des tests système dans les pipelines de livraison continue accélère le retour d'information. L'automatisation des tests CI/CD pour les systèmes embarqués permet une validation fréquente, tandis que la mise en œuvre de l'assurance qualité dans les pipelines CI/CD garantit que les points de contrôle qualité détectent les problèmes avant le déploiement. La traçabilité des exigences , des tests système jusqu'aux exigences de validation, assure une couverture de validation complète.
L'élaboration de cas de test efficaces est fondamentale pour la qualité des systèmes embarqués. Ce guide aborde la rédaction de cas de test unitaires en C/C++ embarqué, les principes d'une conception efficace de cas de test (approches basées sur les exigences, les valeurs limites, les classes d'équivalence et la couverture de code) et les stratégies de rédaction de cas de test à différents niveaux (tests unitaires, d'intégration et système).
Parasoft propose des solutions complètes pour le développement et l'exécution de tests embarqués. Parasoft C/C++test offre la génération automatisée de tests, les tests unitaires et l'analyse de couverture de code, spécialement conçus pour les applications C/C++ embarquées, afin d'aider les équipes à :
L'IA ajoute une couche d'automatisation supplémentaire aux capacités de vérification établies, allant de la correction assistée et de la création de tests unitaires à l'analyse de couverture et à l'intégration MCP.
Cependant, l'analyse statique, l'exécution des tests, l'analyse de couverture et la traçabilité des exigences demeurent les fondements objectifs de la vérification. L'IA aide les ingénieurs à exploiter plus rapidement ces résultats sans pour autant remplacer le processus de vérification lui-même.
Les solutions de test embarquées de Parasoft prennent en charge l'intégralité du cycle de vie des tests, de l'analyse statique et la création de cas de test à l'exécution, la couverture de code, la traçabilité des exigences et la production de rapports.
Les solutions de tests automatisés aident les équipes à réduire les tâches manuelles répétitives, à améliorer la couverture et à fournir des systèmes embarqués fiables en toute confiance.
Prêt à améliorer vos tests embarqués ?
Blog
6 min de lecture
Blog
6 min de lecture
Étude de Cas
