Vérificateur d’application - Test d’applications

Application Verifier (AppVerifier) est un outil de vérification du runtime pour le code non managé qui aide à trouver des erreurs de programmation subtiles, des problèmes de sécurité et des problèmes de privilèges de compte d’utilisateur limités qui peuvent être difficiles à identifier avec des techniques de test d’application normales.

Pour fournir des applications Windows fiables :

1. Testez les applications écrites en code non managé (natif) avec le vérificateur d’application sous le débogueur et avec un tas de pages complètes avant de les distribuer aux clients.
2. Suivez les étapes fournies par Application Verifier pour résoudre les conditions errantes.
3. Une fois votre application publiée, surveillez régulièrement les rapports d’échec d’application collectés, par exemple par Rapport d'erreurs Windows s’ils sont disponibles.

Les vérifications de pool de threads sont activées par défaut sous l’en-tête « Informations de base » case activée. Étant donné que ce paramètre est inclus dans le paramètre par défaut, les utilisateurs doivent uniquement exécuter Application Verifier sur leur code avec les paramètres par défaut pour tirer parti de ces vérifications et d’autres vérifications importantes.

Configuration du vérificateur d’application

Configuration du débogueur

L’application en cours de vérification doit s’exécuter sous un débogueur en mode utilisateur ou le système doit s’exécuter sous un débogueur de noyau, car il se décompose en débogueur lorsqu’une erreur se produit. Pour plus d’informations sur le débogueur, consultez Vérificateur d’application - Débogage des arrêts du vérificateur d’application.

Paramètres

Application Verifier ne peut pas être activé pour un processus en cours d’exécution. Par conséquent, vous devez définir les paramètres comme décrit ci-dessous, puis démarrer l’application. Les paramètres sont persistants jusqu’à ce qu’ils soient supprimés explicitement. Par conséquent, quel que soit le nombre de fois où vous lancez une application, appVerifier est activé jusqu’à ce que les paramètres soient supprimés.

Utilisation du test de base du vérificateur d’application

Les scénarios ci-dessous illustrent les options de ligne de commande et d’interface utilisateur recommandées. Celles-ci doivent être exécutées pendant tous les tests qui exécutent le code pour garantir une couverture complète. L’attente pour ces scénarios est que l’application ne s’interrompt pas dans le débogueur et que tous les tests réussissent avec le même taux de réussite que lorsqu’AppVerifier est activé.

Activez le vérificateur pour la ou les applications que vous souhaitez tester. À partir de la ligne de commande : appverif /verify MyApp.exe.

À partir de l’interface utilisateur : ajoutez votre application en cliquant avec le bouton droit dans la zone Applications et en sélectionnant Ajouter une application. Sélectionnez l’élément De base dans la zone Tests. Cliquez sur le bouton Enregistrer.

Remarques :

/verify active les tests de base

Si vous testez une DLL, le vérificateur d’application doit être activé pour l’exécutable de test qui exerce la DLL.

Exécutez les couches de vérification séparément. Par exemple, dans une session, activez toutes les informations de base et, sur une autre, activez toutes les vérifications LuaPriv.

Exécutez TOUS vos tests avec l’application.

Analysez les interruptions de débogueur rencontrées. Si une rupture se produit, vous devez la comprendre et la corriger. REMARQUE : Le contenu de l’aide fournit des détails sur les pauses et comment les examiner.

Lorsque vous avez terminé, supprimez tous les paramètres. À partir de la ligne de commande : appverif /n MyApp.exe.

Dans l’interface utilisateur, supprimez votre application en cliquant avec le bouton droit dans la zone Applications et en sélectionnant Supprimer l’application. Cliquez ensuite sur le bouton Enregistrer.

Corruption du tas

Près de 10 % des incidents d’application sur les systèmes Windows sont dus à une altération du tas. Ces incidents sont presque impossibles à déboguer après coup. La meilleure façon d’éviter ces problèmes consiste à tester les fonctionnalités de tas de pages trouvées dans Application Verifier. Il existe deux saveurs de Tas de pages : « Full » et « Light ». Full est la valeur par défaut ; elle force l’arrêt instantané d’un débogueur lors de la détection d’un endommagement. Cette fonctionnalité DOIT être exécutée sous le débogueur. Toutefois, il s’agit également de la ressource la plus exigeante. Si un utilisateur rencontre des problèmes de minutage et qu’il a déjà exécuté un scénario sous tas de page « plein », sa définition sur « Light » permettra probablement de résoudre ces problèmes. En outre, le tas de pages légères ne se bloque pas tant que le processus n’est pas arrêté. Il fournit une trace de pile à l’allocation, mais peut prendre beaucoup plus de temps à diagnostiquer que l’exploitation de son équivalent complet.

Utilisation d’AppVerifier Low Resource Simulation (injection d’erreur)

Ce scénario s’attend à ce que l’application ne se décompose pas dans le débogueur. Le fait de ne pas s’introduire dans le débogueur signifie que vous n’avez aucune erreur à résoudre.

Le taux de réussite des tests peut diminuer considérablement depuis que des injections d’erreurs aléatoires sont introduites dans le fonctionnement normal.

Activez la simulation à faible niveau de ressources du vérificateur d’application (injection d’erreur) pour les applications. À partir de la ligne de commande : Appverif /verify MyApp.exe /faults. À partir de l’interface utilisateur : ajoutez votre application en cliquant avec le bouton droit dans la zone Applications et en sélectionnant Ajouter une application . Sélectionnez La simulation de ressources faibles dans la zone Tests. Cliquez sur le bouton Enregistrer.

Remarque : Si vous testez une DLL, vous pouvez appliquer une simulation de ressources faibles (injection d’erreur) à une CERTAINE DLL au lieu de l’ensemble du processus. Le format de ligne de commande est le suivant :

appverif /verify TARGET [/faults [PROBABILITY [TIMEOUT [DLL …]]]]

Exemple :

appverif /verify mytest.exe /faults 50000 1000 d3d9.dll

Exécuter TOUS vos tests en faisant l’exercice de l’application

Analysez les interruptions de débogueur rencontrées. Si une rupture se produit, vous devez la comprendre et la corriger.

Lorsque vous avez terminé, supprimez tous les paramètres. À partir de la ligne de commande : appverif /n MyApp.exe. À partir de l’interface utilisateur : supprimez votre application en cliquant avec le bouton droit dans la zone Applications et en sélectionnant Supprimer l’application , en cliquant sur le bouton Enregistrer.

Remarque : L’exécution avec et sans injection d’erreurs entraîne des exercices de code largement différents dans une application et, par conséquent, les deux scénarios doivent être exécutés pour tirer pleinement parti d’AppVerifier.

Utilisation du vérificateur d’application avec WOW64

Vous pouvez utiliser la version 32 bits ou 64 bits d’Application Verifier pour vérifier une application 32 bits s’exécutant sous WOW64.

Analyse des données AppVerifier

Toutes les données créées pendant l’analyse AppVerifier sont stockées dans le dossier %USERPROFILE%\AppVerifierLogs dans un format binaire. Ces journaux peuvent ensuite être convertis en XML via l’interface utilisateur ou la ligne de commande pour une analyse plus approfondie.

Pour afficher les fichiers XML, vous pouvez utiliser n’importe quel outil pour afficher le code XML, par exemple l’importation dans Microsoft Excel - Importer le fichier XML dans Excel et utiliser des filtres ou des tableaux croisés dynamiques pour réorganiser et analyser les données collectées.

Utilisation de la ligne de commande

Le vérificateur d’application peut être utilisé via l’interface utilisateur ou à l’aide des options de ligne de commande.

Voici des exemples d’utilisation de la ligne de commande (vous trouverez ci-dessous les détails) :

appverif /verify TARGET [/faults [PROBABILITY [TIMEOUT [DLL …]]]]

appverif /verify notepad

appverif -enable LAYER … -for TARGET ... [-with [LAYER].PROPERTY=[VALUE] …] 

appverif -disable LAYER ... -for TARGET ...

appverif -query LAYER ... -for TARGET ...

appverif –configure STOP ... -for TARGET ... [-with STOPPROPERTY=[VALUE] …]

appverif –logtofile {enable|disable}

Pour activer le vérificateur d’application pour une couche de vérification spécifique pour deux applications :

appverif –enable Heaps Locks –for notepad.exe iexplore.exe

Pour activer deux couches nommées X et Y pour les test.exe cibles avec les propriétés X.DebugLevel et Y.DebugLevel :

appverif –enable X Y –for test.exe –with X.DebugLevel=1 Y.DebugLevel=2

Pour désactiver toutes les vérifications exécutées sur une application :

appverif -disable * -for notepad.exe

OR

appverif -delete settings -for notepad.exe

Pour activer ou désactiver globalement la journalisation du vérificateur d’application pour tous les processus :

appverif –logtofile enable

appverif –logtofile disable

La journalisation est activée par défaut pour tous les processus.

Syntaxe de ligne de commande du vérificateur d’application

Utilisation de la ligne de commande du vérificateur d’application :

-enable TEST ... -for TARGET ... [-with [TEST.]PROPERTY=VALUE ...]
-disable TEST ... -for TARGET ...
-query TEST ... -for TARGET ...
-configure STOP ... -for TARGET ... -with PROPERTY=VALUE...
-verify TARGET [-faults [PROBABILITY [TIMEOUT [DLL ...]]]]
-export log -for TARGET -with To=XML_FILE [Symbols=SYMBOL_PATH] [StampFrom=LOG_STAMP] [StampTo=LOG_STAMP] [Log=RELATIVE_TO_LAST_INDEX]
-delete {logs|settings} -for TARGET ...
-stamp log -for TARGET -with Stamp=LOG_STAMP [Log=RELATIVE_TO_LAST_INDEX]
-logtoxml LOGFILE XMLFILE
-installprovider PROVIDERBINARY
-sppath [PROTECTED_PROCESS_LOG_PATH]
-cppath
-logtofile [enable | disable]

La syntaxe de ligne de commande accepte une ou plusieurs couches et les applique à une ou plusieurs cibles avec des spécificateurs de propriétés facultatifs pour les couches.

appverif -enable LAYER ... -for TARGET ... [-with [LAYER].PROPERTY=[VALUE] …] appverif -disable LAYER ... -for TARGET ... appverif -query LAYER ... -for TARGET ... appverif –configure STOP ... -for TARGET ... [-with STOPPROPERTY=[VALUE] …]

où :

LAYER est un nom standard pour une couche de vérification. Si un nouveau fournisseur de vérificateur est installé, cela expose un nouveau nom de couche de vérification à utiliser dans la ligne de commande. Les exemples de couches sont Tas, Handles ou Locks.

Vous pouvez définir LAYER sur * pour spécifier que la commande s’applique à toutes les couches.

TARGET est un nom binaire (par exemple, notepad.exe). Il s’agit d’un paramètre statique qui est conservé dans le Registre et qui sera pris en considération chaque fois que l’application est démarrée. Pour la commande appverif –disable, vous pouvez définir TARGET sur * pour spécifier que toutes les cibles doivent être désactivées.

PROPERTY est un nom de propriété spécifique à la couche mentionnée dans la ligne de commande. Par exemple, la couche Handles a des traces en tant que propriété .

VALUE est une valeur de la propriété . Le type de la valeur dépend du type associé à la propriété et il sera appliqué. Les types pris en charge pour l’instant sont : booléen (true/false), entier (décimal/octal/hex en notation C), chaîne et multi-chaîne (contenant \0’ between strings and being terminated by \0\0'). Si VALUE n’est pas spécifié, cela signifie que l’utilisateur souhaite supprimer cette propriété et rétablir la valeur par défaut de la propriété.

STOP est le nombre (décimal ou hexadécimal en notation C) du problème d’arrêt du vérificateur à configurer. Les codes d’arrêt doivent être uniques (deux couches ne peuvent pas utiliser le même code d’arrêt. Par conséquent, l’outil lui-même déterminera à quelle couche appartient l’arrêt)

STOPPROPERTY est un nom de propriété acceptable pour les arrêts du vérificateur. Si la valeur n’est pas spécifiée, il est supposé que la propriété doit être supprimée. Les propriétés autorisées pour les arrêts sont (pour plus d’informations, consultez Configuration des arrêts du vérificateur ci-dessous) :

• ErrorReport
• severity
• Saveur

Les propriétés peuvent éventuellement être qualifiées par la couche à laquelle elles appartiennent. Toutefois, cela n’est pas nécessaire si la ligne de commande n’active qu’une seule couche. Par exemple, pour activer deux couches nommées X et Y pour les test.exe cibles avec les propriétés X.DebugLevel et Y.DebugLevel, la commande est :

appverif –enable X Y –for test.exe –with X.DebugLevel=1 Y.DebugLevel=2

Toutefois, si la couche X est activée, un nom de propriété non qualifié peut être utilisé :

appverif –enable X –for test.exe –with DebugLevel=1

Le caractère de séparation entre le nom de la propriété et la valeur peut être = (signe égal) ou : (deux-points).

Commandes diverses

appverif –query providers

appverif –delete logs –for TARGET ...

appverif –delete settings –for TARGET ...

Effacez complètement TARGET du Registre.

appverif –stamp log –for Target –with Stamp=”LOG_STAMP”[Log= RELATIVE_TO_LAST_INDEX]

Cette commande marque le journal avec LOG_STAMP. Ce tampon est utile pour identifier uniquement une section d’un journal comme pertinente lors de l’affichage du journal dans un formulaire XML.

appverif –export log –for TARGET –with To=XML_FILE[Symbols=SYMBOL_PATH][Stamp=LOG_STAMP][StampTo=LOG_STAMP][Log=RELATIVE_TO_LAST_INDEX]

La commande ci-dessus exporte un journal binaire vers un fichier xml. La propriété facultative Stamp est utilisée pour identifier la partie du journal qui doit être exportée vers XML. S’il n’est pas spécifié, l’intégralité du journal est convertie. La propriété Log a un entier négatif comme valeur possible et indique quel fichier journal doit être converti à partir du dernier (supposé si la propriété n’est pas présente). Par exemple, lancez notepad.exe trois fois de suite. Pour accéder au premier journal créé, spécifiez Log=-2 dans la ligne de commande.

Raccourcis pour la ligne de commande

Voici les raccourcis :

appverif /verify TARGET [/faults [PROBABILITY [TIMEOUT [DLL …]]]]

où :

TARGET a la même signification que celle décrite ci-dessus.

PROBABILITÉ est la probabilité d’injecter des erreurs. Doit être une valeur dans la plage 0..1000000. Si elle n’est pas spécifiée, la valeur par défaut est 5 %.

TIMEOUT est l’intervalle de temps en millisecondes pendant le démarrage du processus lorsque l’injection d’erreur ne se produit pas. Cette opération permet au processus de démarrer correctement avant que des erreurs ne se produisent. Si elle n’est pas spécifiée, la valeur est de 500 msecs.

DLL est le nom du module qui est chargé dans le processus. Il s’agit généralement du nom d’une bibliothèque dynamique (extension .dll), mais il peut s’agir d’un module ActiveX (extension .ocx) ou d’un autre module chargeable.

Exemples :

appverif /verify notepad.exe /faults 100000 1000 msvcrt.dll

Activez l’injection d’erreur pour notepad.exe (chaque fois qu’il sera lancé). Les erreurs doivent se produire avec une probabilité de 10 %, seulement 1 000 msecs après le lancement du processus et uniquement pour les opérations lancées à partir de msvcrt.dll.

Activation des détails de l’injection d’erreur

L’utilisation de la ligne de commande /faults permet l’injection d’erreurs uniquement pour OLE_ALLOC et HEAP_ALLOC. Toutefois, vous pouvez utiliser la ligne de commande pour configurer le type d’injection d’erreur que vous souhaitez activer. Par exemple, si vous souhaitez injecter une erreur dans un registre ou une API de fichier sous la forme de 2 %, utilisez la ligne de commande :

appverif -enable lowres -for hello.exe -with registry=20000 file=20000

Autre exemple :

appverif -query lowres -for hello.exe

Settings for hello.exe:
Test [lowres] enabled.

Include = *
Exclude =
TimeOut = 2000 (0x7D0)
WAIT = 0 (0x0)
HEAP_ALLOC = 20000 (0x4E20)
VIRTUAL_ALLOC = 0 (0x0)
REGISTRY = 20000 (0x4E20)
FILE = 20000 (0x4E20)
EVENT = 0 (0x0)
MAP_VIEW = 0 (0x0)
OLE_ALLOC = 20000 (0x4E20)
STACKS = false

Configuration des arrêts du vérificateur

À l’aide de la ligne de commande (ou de l’interface utilisateur), vous pouvez configurer des arrêts de vérificateur. Voici quelques exemples à tirer parti :

Appverif -configure STOP ... -for TARGET ... -with PROPERTY=VALUE ...

STOP est un code d’arrêt tel que 0x200 0x201

TARGET est le nom de l’application, par exemple foo.exe

PROPERTY peut être l’un des éléments « ErrorReport », « Severity » et « Flavor »

Pour ErrorReport , VALUE peut être la combinaison des valeurs suivantes.

0x00000001 signifie que l’arrêt est actif. (Si ce bit est égal à zéro, cela signifie que l’arrêt est désactivé)

0x00000020 signifie que l’arrêt s’arrête dans le débogueur à l’aide d’un point d’arrêt.

0x00000040 signifie l’arrêt du débogueur en générant une exception de vérificateur.

0x00000080 signifie que l’arrêt sera enregistré dans le fichier journal.

0x00000100 signifie que la trace de pile de cet arrêt sera journalisée dans le fichier journal.

Pour la gravité , LA VALEUR peut être l’une des suivantes.

0x00000003 Arrêt informatif.

0x0000000F Avertissement.

erreur 0x0000003F.

Pour l’objet Flavor , Value peut être la combinaison des valeurs suivantes.

0x00000002 arrêt non continuable.

0x00000010 Cet arrêt n’apparaîtra qu’une seule fois. Elle sera ignorée la fois suivante dans la série de tests.

Par exemple, désactiver les arrêts 0x2700, 0x2701 pour foo.exe

Appverif –configure 0x2700 0x2701 –for foo.exe –with ErrorReport=0

Configurer le code d’arrêt 0x2700 comme cassant dans le débogueur (il est désactivé par défaut), en enregistrant un journal sans trace de pile et en le rendant non continuable

Appverif –configure 0x2700 –for foo.exe –with ErrorReport=0xA1 Flavor=0x2

Options d’arrêt du vérificateur - Paramètres avancés

Application Verifier a des paramètres avancés, tels que Inactiver, que vous pouvez modifier par arrêt du vérificateur.

Options d’arrêt du vérificateur d’accès : les options d’arrêt du vérificateur sont modifiées dans une boîte de dialogue qui répertorie les options disponibles. Pour accéder aux options d’arrêt du vérificateur :

1. Sélectionnez le nom d’un test dans le volet Tests.
2. Dans le menu Edition, sélectionnez Options d’arrêt du vérificateur ou cliquez avec le bouton droit sur le test, puis sélectionnez Options d’arrêt du vérificateur.

Options d’arrêt du vérificateur

Vous pouvez modifier les éléments suivants par arrêt de vérificateur répertorié en cliquant sur le code d’arrêt (notez qu’une description de l’arrêt s’affiche lorsque vous cliquez dessus).

Inactif est une case à cocher qui, lorsqu’elle est sélectionnée, désactive l’exécution du code du vérificateur.

La gravité détermine la façon dont l’arrêt du vérificateur doit être marqué :

• Ignorer
• Information
• Avertissement
• Error

Le rapport d’erreurs détermine la façon dont vous souhaitez que l’arrêt du vérificateur spécifique soit signalé/journalisé :

Journaliser dans le fichier : case à cocher qui, une fois sélectionnée, journalisera le fichier désigné.

Trace de la pile des journaux : case à cocher qui, lorsqu’elle est sélectionnée, enregistre les traces de pile lorsqu’elles sont disponibles.

Aucun arrêt : option permettant de ne pas arrêter le débogueur.

Exception : une option avec aucun point d’arrêt et point d’arrêt

Point d’arrêt : option sans interruption ni exception.

Divers offre deux options

Arrêter une fois : case à cocher qui, lorsqu’elle est sélectionnée, ne s’arrête sur cette erreur qu’une seule fois lors du test d’une application.

Non continuable : case à cocher qui, lorsqu’elle est sélectionnée, ne vous permet pas de continuer sans enquête.

Voir aussi

Vérificateur d’application - Vue d’ensemble

Vérificateur d’application - Fonctionnalités

Vérificateur d’application - Tests dans Application Verifier

Vérificateur d’application - Codes et définitions d’arrêt

Vérificateur d’application - Débogage des arrêts du vérificateur d’application

Vérificateur d’application - Forum aux questions