Conformité logicielle DO-178C pour l'aérospatiale et la défense

La vérification des logiciels fait partie intégrante du développement de logiciels critiques pour la sécurité. Les tests, par le biais de l'exécution, sont un moyen essentiel de démontrer la mise en œuvre des exigences et la livraison de logiciels de qualité. Tests unitaires Il s'agit de la vérification des exigences de bas niveau. Elle garantit que chaque unité logicielle fait ce qu'elle doit faire dans le cadre des exigences de qualité de service attendues : sûreté, sécurité et fiabilité. Les exigences de sûreté et de sécurité indiquent que les unités logicielles ne se comportent pas de manière imprévue lorsque le système n'est pas susceptible d'être piraté, manipulé, volé ou corrompu.

En termes de processus de développement classique en V, l'exécution de tests unitaires est une pratique de vérification visant à garantir que le module est conçu correctement. La norme DO-178C n'impose pas spécifiquement de tests unitaires par leur nom, mais utilise plutôt les termes tests basés sur les exigences de haut et de bas niveau.

Les tests de bas niveau sont généralement considérés comme des tests unitaires. En particulier, les exigences pour ce type de tests basés sur les exigences incluent les éléments suivants.

DO-178C La norme ne prescrit pas de méthodologies ou d'outils de test spécifiques, mais souligne la nécessité de procéder à des tests approfondis pour garantir la sécurité et la fiabilité des logiciels embarqués. Les tests doivent être effectués à tous les niveaux du système, ainsi qu'une traçabilité entre les exigences, la conception, le code source et les tests. De plus, les plans de test, les cas de test et les résultats doivent être documentés pour la certification.

Méthodes de test unitaire

Tests basés sur les exigences

Ces tests testent directement la fonctionnalité et la qualité de service comme spécifié dans chaque exigence. Les outils d'automatisation des tests doivent prendre en charge la traçabilité bidirectionnelle des exigences vers leurs tests et les rapports de couverture des tests des exigences pour démontrer la conformité.

Les exigences de haut niveau sont dérivées des exigences système de niveau supérieur. Elles décomposent une exigence système en diverses exigences fonctionnelles et non fonctionnelles de haut niveau. Cette phase de décomposition des exigences aide à la conception architecturale du système en cours de développement.

Les exigences de haut niveau clarifient et aident à définir le comportement attendu ainsi que les tolérances de sécurité, les attentes en matière de sécurité, la fiabilité, les performances, la portabilité, la disponibilité, l'évolutivité, etc. Chaque exigence de haut niveau est liée à l'exigence système qu'elle satisfait. De plus, des cas de test de haut niveau sont créés et liés à chaque exigence de haut niveau à des fins de vérification et de validation. Ce processus d'analyse des exigences logicielles se poursuit à mesure que chaque exigence de haut niveau est décomposée en exigences de bas niveau.

Les exigences de bas niveau sont des exigences logicielles dérivées des exigences de haut niveau. Elles décomposent et affinent davantage la spécification du comportement et de la qualité de service du logiciel.

Ces exigences se situent à un autre niveau d'abstraction. Elles correspondent à des unités logicielles individuelles et sont rédigées de manière à faciliter la conception et la mise en œuvre des détails du logiciel. La traçabilité est établie à partir de chaque exigence de bas niveau jusqu'à son exigence de haut niveau et jusqu'aux tests de bas niveau ou aux cas de test unitaires qui la vérifient et la valident.

Les tests unitaires consistent à isoler la fonction, la méthode ou la procédure. Ils sont effectués en stubbing et en simulant les dépendances et en imposant des chemins d'exécution spécifiques. Les stubs remplacent le code de l'unité qui dépend du code extérieur à l'unité. Ils offrent également au développeur ou au testeur la possibilité de manipuler la réponse ou le résultat afin que l'unité puisse être utilisée de différentes manières et à diverses fins, par exemple pour garantir que l'unité fonctionne de manière fiable, qu'elle est sûre et qu'elle est également exempte de vulnérabilités de sécurité.

Tests d'interface

Les tests d'interface garantissent que les interfaces de programmation se comportent et fonctionnent comme spécifié. Les outils de test doivent créer des stubs de fonction et des sources de données pour émuler le comportement des composants externes pour l'exécution automatique des tests unitaires.

Tests d'injection de défauts

Les tests d'injection de défauts utilisent des entrées inattendues et introduisent des échecs dans l'exécution du code pour examiner la gestion des échecs ou son absence. Les outils d'automatisation des tests doivent prendre en charge l'injection de conditions d'erreur à l'aide de stubs de fonction et la génération automatique de tests unitaires à l'aide d'un ensemble diversifié de conditions préalables, telles que les tests de valeurs minimales, moyennes, maximales et heuristiques.

Évaluation de l'utilisation des ressources

Ces tests évaluent la quantité de mémoire, d’espace de fichier, d’exécution du processeur ou d’autres ressources matérielles cibles utilisées par l’application.

Exécution de tests automatisés et génération de cas de test

L'automatisation des tests présente de nombreux avantages pour les logiciels embarqués critiques en matière de sécurité. L'abandon des suites de tests qui nécessitent de nombreuses interventions manuelles signifie que les tests peuvent être effectués plus rapidement, plus facilement et plus souvent.

Le fait de décharger ces efforts de test manuel permet de libérer du temps pour une meilleure couverture des tests et d'autres objectifs de sécurité et de qualité. Une exigence importante pour l'exécution automatisée des suites de tests est de pouvoir exécuter ces tests à la fois sur les environnements hôte et cible.

Tests basés sur des objectifs

L’automatisation des tests de logiciels embarqués est plus difficile en raison de la complexité du lancement et de l’observation des tests sur des cibles embarquées, sans parler de l’accès limité au matériel cible dont disposent les équipes logicielles.

La norme DO-178C exige que les logiciels soient testés dans un environnement représentatif qui reflète les conditions de déploiement réelles. Cela comprend les tests sur le matériel cible ou l'utilisation d'un environnement logiciel qui ressemble étroitement à l'environnement cible final. Cette approche est nécessaire pour garantir que le logiciel fonctionne correctement et de manière fiable dans l'avion ou le système embarqué réel.

L'automatisation des tests logiciels est essentielle pour rendre les tests intégrés réalisables en continu, du système de développement hôte au système cible. Les tests de logiciels intégrés prennent particulièrement du temps. L'automatisation de la suite de tests de régression permet de réaliser des économies de temps et d'argent considérables. De plus, Test C/C++ CT et test C/C++ effectuer la collecte de données de couverture de code à partir du système cible, ce qui est essentiel pour la validation et la conformité aux normes.

La traçabilité entre les cas de test, les résultats des tests, le code source et les exigences doit être enregistrée et conservée. Pour ces raisons, la collecte de données est essentielle dans l'exécution des tests.

Parasoft C/C++test est proposé avec son harnais de test optimisé pour prendre en charge une surcharge supplémentaire minimale pour l'empreinte binaire et le fournit sous forme de code source, où il peut être personnalisé si des modifications spécifiques à la plate-forme sont nécessaires.

L'un des principaux avantages de la solution de test Parasoft C/C++ réside dans ses intégrations dédiées avec des IDE et des débogueurs intégrés qui rendent le processus d'exécution des cas de test fluide et automatisé. Les environnements IDE pris en charge incluent :

Génération de cas de test automatisée

Les outils d'automatisation des tests unitaires prennent universellement en charge une sorte de cadre de test, qui fournit l'infrastructure de harnais pour exécuter des unités de manière isolée tout en satisfaisant les dépendances via des stubs. Parasoft C/C++test ne fait pas exception. Une partie de sa capacité de test unitaire est la génération automatisée de harnais de test et des composants exécutables nécessaires aux tests basés sur l'hôte et la cible.

La génération et la gestion des données de test constituent de loin le plus grand défi des tests unitaires. Les cas de test sont particulièrement importants dans le développement de logiciels critiques pour la sécurité, car ils doivent garantir les exigences fonctionnelles et tester les comportements imprévisibles, la sécurité et les exigences de sûreté. Tout cela tout en satisfaisant les critères de couverture des tests.

Parasoft C/C++test génère automatiquement des cas de test comme le format populaire CppUnit. Par défaut, C/C++test génère une suite de tests par fichier source/en-tête. Il peut également être configuré pour générer une suite de tests par fonction ou une suite de tests par fichier source.

Des définitions de stub sûres sont générées automatiquement pour remplacer les fonctions « dangereuses », qui incluent les routines d'E/S système telles que rmdir(), remove(), rename(), etc. De plus, des stubs peuvent être générés automatiquement pour les définitions de fonctions et de variables manquantes. Des stubs définis par l'utilisateur peuvent être ajoutés selon les besoins.