Découvrez comment la solution Parasoft Continuous Quality permet de contrôler et de gérer les environnements de test pour fournir des logiciels de haute qualité en toute confiance. Inscrivez-vous pour la démo >>

BLOG

Préparation du portage vers des plates-formes 64 bits

Préparation du portage vers des plates-formes 64 bits Temps de lecture : 3 minutes
En recherchant et en corrigeant les erreurs de mémoire C / C ++ avant le portage en 64 bits, vous pouvez réduire le risque d'échec sur la nouvelle plate-forme et la nouvelle architecture, rationaliser le processus de portage et rendre l'application d'origine plus robuste et plus fiable.

Voici un processus que vous pouvez appliquer pour préparer votre application au processus de portage 64 bits:

  1. Effectuer test de mutation via la détection d'erreur de la mémoire d'exécution
  2. Utiliser l'analyse statique pour identifier le code sujet aux erreurs et non portable
  3. Répéter la détection des erreurs de mémoire d'exécution
  4. Effectuer des tests unitaires (Facultatif)

Étape 1: Effectuez un test de mutation via la détection d'erreur de mémoire d'exécution

Avant de commencer le portage, vous devez débarrasser votre code d'origine des problèmes qui vous affligeront sur le processeur 64 bits; par exemple, la corruption de la mémoire et les fuites de mémoire. L'un des moyens les plus efficaces d'exposer les types de problèmes de pointeur et d'entier qui causeront des problèmes sur les processeurs 64 bits consiste à tirer parti du test de mutation pour la détection des erreurs de mémoire d'exécution.

Technologies de détection des erreurs de mémoire d'exécution telles que Parasoft Insure ++ vous permettent d'exploiter les techniques des tests de mutation traditionnels pour découvrir les ambiguïtés difficiles à détecter par d'autres méthodes ou outils. Alors que les tests de mutation traditionnels tentent de créer des mutants «défectueux» pour créer une suite de tests plus efficace, les tests de mutation pour la détection des erreurs de mémoire d'exécution créent et exécutent ce qui devrait être des mutants fonctionnellement équivalents du code source testé.

Lorsque l'un de ces mutants fonctionne différemment du programme d'origine, cela indique que la fonctionnalité du code repose sur des hypothèses implicites qui peuvent ne pas toujours être satisfaites lors de l'exécution. Si un mutant fait planter le programme ou rencontre d'autres problèmes graves, c'est un signe que lorsque les hypothèses ne sont pas satisfaites, des erreurs graves se produiront au moment de l'exécution.

En C ++, ce processus de création et d'exécution de mutants équivalents peut découvrir:

  • Manque de constructeurs de copie ou de mauvais constructeurs de copie.
  • Constructeurs manquants ou incorrects.
  • Mauvais ordre d'initialisation du code.
  • Problèmes avec les opérations des pointeurs.
  • Dépendance à un comportement indéfini tel que l'ordre d'évaluation.

Étape 2: Utilisez l'analyse statique pour identifier le code sujet aux erreurs et non portable

Après avoir nettoyé les erreurs les plus critiques exposées par les tests de mutation, utiliser aussi une analyse statiquel pour identifier le code susceptible de causer des problèmes lorsqu'il est porté sur la nouvelle plate-forme/architecture. Les analyseurs de code statiques utilisent une interface de type compilateur pour créer un modèle syntaxique et sémantique du logiciel. Le modèle syntaxique est ensuite analysé par rapport à un ensemble de règles ou "vérificateurs" pour voir si le code est en violation. Ces vérificateurs utilisent des algorithmes de correspondance de modèles pour détecter des erreurs telles qu'une mauvaise utilisation des constructions de langage, l'utilisation de fonctions non sécurisées et détecter les mauvaises pratiques de codage qui entravent la portabilité (à couvrir dans mon prochain post) et d'autres violations des directives de codage.

Des vérificateurs plus sophistiqués utilisent une analyse sémantique qui utilise les données et le flux de contrôle pour détecter les bogues complexes et les vulnérabilités de sécurité. Pour ce faire, l'analyseur statique construit un modèle d'exécution du logiciel, considère les chemins possibles à travers le code et évalue l'utilisation des données à mesure qu'elles circulent de la source (par exemple, entrée utilisateur) à sa destination (par exemple, un appel API tel qu'un appel système. ). L'analyse de chaque condition et chemin possible prendrait trop de temps, de sorte que l'analyseur utilise l'heuristique pour détecter les chemins les plus probables pour l'évaluation. Les types d'erreurs détectées par ces vérificateurs incluent la déférence de pointeur nulle, les débordements de tampon et les vulnérabilités de sécurité telles que les injections de commandes et SQL.

Il y a deux tâches principales sur lesquelles se concentrer lors de l'analyse statique:

  1. Identifiez et corrigez le code susceptible d'entraîner une erreur sur n'importe quelle plate-forme ou architecture.
  2. Identifiez et corrigez le code qui pourrait ne pas être correctement porté.

Tout d'abord, vérifiez les normes de codage C / C ++ respectées par l'industrie qui identifient les constructions de codage, qui sont susceptibles de conduire à des problèmes sur n'importe quelle plate-forme ou architecture. En vous assurant que le code est conforme à ces normes de codage, vous évitez les erreurs. Cela se traduit par moins de débogage sur la nouvelle plate-forme ou architecture et réduit le risque d'avoir des bogues qui échappent aux tests et se retrouvent dans la version.

Étape 3: Répétez la détection des erreurs de mémoire d'exécution

Répétez la détection des erreurs de mémoire d'exécution pour vérifier que les modifications que vous avez apportées lors de la correction analyse statique les violations n'ont introduit aucune erreur d'exécution.

Étape 4: Effectuer des tests unitaires (facultatif)

À ce stade, vous souhaiterez peut-être effectuer une étape supplémentaire pour vous assurer que votre code est aussi exempt d'erreurs que possible avant de le porter. Cette étape supplémentaire est le test unitaire. Les tests unitaires sont traditionnellement utilisés pour trouver des erreurs dès que chaque unité d'application est terminée. Cela peut également être bénéfique plus tard dans le processus de développement car, au niveau de l'unité, il est plus facile de concevoir des intrants qui atteignent toutes les fonctions. À son tour, cela vous aide à trouver les erreurs plus rapidement et à exposer les erreurs que vous pourriez ne pas découvrir avec les tests au niveau de l'application.

Dans le prochain post Je couvre l'utilisation de l'analyse statique pour aider à préparer le code pour le portage sur des plates-formes 64 bits.

Obtenez le débogueur de mémoire ultime pour C et C ++

Écrit par

Parasoft

Les outils de test de logiciels automatisés de pointe de Parasoft prennent en charge l'ensemble du processus de développement logiciel, depuis le moment où le développeur écrit la première ligne de code jusqu'aux tests unitaires et fonctionnels, jusqu'aux tests de performance et de sécurité, en exploitant des environnements de test simulés en cours de route.

Recevez les dernières nouvelles et ressources sur les tests de logiciels dans votre boîte de réception.