Vérificateur d’application - Test d’applications

Application Verificationr (AppVerifier) est un outil de vérification d’exécution pour le code non managé qui permet de 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 dans du code non managé (natif) avec Application Verifier sous le débogueur et avec un tas de page entier avant de le publier 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 de l’application collectés, par exemple par rapport d’erreurs Windows si disponible.

Les vérifications de pool de threads sont activées par défaut sous l’en-tête de vérification « De base ». Comme cela est inclus dans le paramètre par défaut, les utilisateurs doivent uniquement exécuter le vérificateur d’application sur leur code avec les paramètres par défaut pour tirer parti de ces contrôles 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 d’un vérificateur d’application s’arrête.

Paramètres

Application Verifier ne peut pas être activé pour un processus en cours d’exécution. Par conséquent, vous devez définir des 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, peu importe le nombre de fois où vous lancez une application, elle démarre avec AppVerifier activée 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 exercicent le code pour garantir une couverture complète. L’attente de ces scénarios est que l’application ne se décompose pas en débogueur et que tous les tests réussissent avec le même taux de réussite que lors de l’exécution sans AppVerifier activé.

Activez le vérificateur pour les applications que vous souhaitez tester à l’aide de. À 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 les concepts de base dans la zone Tests. Cliquez sur le bouton Enregistrer.

Remarques :

/verify active les tests de base

Si vous testez une DLL, Application Verifier 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 bases et sur une autre activez toutes les vérifications LuaPriv.

Exécutez tous vos tests en faisant l’exercice de l’application.

Analysez les sauts de débogueur rencontrés. Si une rupture se produit, vous devrez la comprendre et la corriger. REMARQUE : Le contenu de l’aide fournit des détails sur les sauts et la façon de les examiner.

Une fois 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 à un endommagement du tas. Ces incidents sont presque impossibles à déboguer après le fait. La meilleure façon d’éviter ces problèmes consiste à tester les fonctionnalités du tas de pages trouvées dans Application Verifier. Il existe deux types de tas de pages : « entier » et « léger ». Entier est la valeur par défaut ; il force un débogueur à s’arrêter instantanément lors de la détection de la corruption. 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 le tas de pages « entier », le définir à la valeur « léger » va probablement résoudre ces problèmes. En outre, le tas de page entier ne se bloque pas tant que le processus n’est pas arrêté. Il fournit une arborescence des appels de procédure à l’allocation, mais peut prendre beaucoup plus de temps pour diagnostiquer que de tirer parti de son équivalent entier.

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

L’attente de ce scénario est que l’application ne se décompose pas en débogueur. En ne cassant pas dans le débogueur, cela signifie que vous n’avez pas d’erreurs à résoudre.

Le taux de réussite des tests peut diminuer considérablement, car les injections de pannes aléatoires sont introduites dans l’opération normale.

Activez application Verifier Low Resource Simulation (injection d’erreurs) pour la ou 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 ressource faible dans la zone Tests. Cliquez sur le bouton Enregistrer.

Remarque : Si vous testez une DLL, vous pouvez appliquer une simulation de ressource faible (injection d’erreurs) sur une certaine DLL au lieu de l’ensemble du processus. Le format de ligne de commande est :

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 sauts de débogueur rencontrés. Si une rupture se produit, vous devrez la comprendre et la corriger.

Une fois 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, en cliquant sur le bouton Enregistrer.

Remarque : L’exécution avec et sans injection d’erreurs effectue des exercices de code largement différents dans une application. 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 la version 64 bits de Application Verifyr pour vérifier qu’une application 32 bits s’exécute sous WOW64.

Analyse des données AppVerifier

Toutes les données créées lors de 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

Application Verifier peut être utilisé via l’interface utilisateur ou à l’aide d’options de ligne de commande.

Voici des exemples d’utilisation de la ligne de commande (voici 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 application Verificationr 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 la test.exe cible 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

OU

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érificateurs est installé, cela expose un nouveau nom de couche de vérification à utiliser dans la ligne de commande. Les exemples de couches sont des segments de mémoire, des poignées ou des verrous.

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 persistant dans le Registre et pris en compte 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 pour 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 le comportement à 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 (aucune couche ne peut 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, elle est supposée que la propriété doit être supprimée. Les propriétés autorisées pour les arrêts sont (voir Configuration des arrêts de vérificateur ci-dessous pour plus d’informations) :

• Rapport d'erreur
• Sévérité
• 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 active une seule couche. Par exemple, pour activer deux couches nommées X et Y pour la test.exe cible 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 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 à partir 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 au format 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é Stamp facultative est utilisée pour identifier la partie du journal à exporter au format XML. S’il n’est pas spécifié, l’intégralité du journal sera convertie. La propriété Log a un entier négatif comme valeur possible et indique ce que le 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 dans une ligne. 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 suivants :

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

où:

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

PROBABILITY est la probabilité d’injecter des erreurs. Doit être une valeur dans la plage 0..10000000. S’il n’est pas spécifié, 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’erreurs ne se produit pas. Cela permet de permettre au processus de démarrer correctement avant que les erreurs ne se produisent. S’il n’est pas spécifié, la valeur est de 500 msecs.

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

Exemples:

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

Activez l’injection d’erreurs pour notepad.exe (chaque fois qu’elle sera lancée). 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’erreurs

L’utilisation de la ligne de commande /faults active l’injection de pannes 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 comme 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 les arrêts du vérificateur. Voici des exemples à tirer parti des éléments suivants :

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

STOP est un code stop tel que 0x200 0x201

TARGET est un nom d’application tel que foo.exe

PROPERTY peut être l’un des « ErrorReport », « Gravité » 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 se décompose en débogueur à l’aide d’un point d’arrêt.

0x00000040 signifie que l’arrêt s’arrête dans le 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 pour cet arrêt est journalisée dans le fichier journal.

Pour la gravité, VALUE peut être l’un des éléments suivants.

0x00000003 arrêt informatif.

0x0000000F Avertissement.

erreur 0x0000003F.

Pour la saveur, la valeur peut être la combinaison des valeurs suivantes.

0x00000002 arrêt non continuable.

0x00000010 Cet arrêt n’apparaît qu’une seule fois. Elle sera ignorée l’heure suivante au cours de l’exécution du test.

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

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

Configurez 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, comme Inactivate, 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 Modifier, 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 le code d’arrêt du vérificateur d’être exécuté.

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

• Ignorer
• Informations
• Avertissement
• Erreur

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 le fichier : case à cocher qui, lorsqu’elle est sélectionnée, se connecte au fichier désigné.

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

Pas d’arrêt : option ne pas arrêter dans le débogueur.

Exception : option sans arrêt et point d’arrêt

Point d’arrêt : option sans arrêt ou exception.

Divers propose deux options

Arrêter une fois : case à cocher qui, lorsqu’elle est sélectionnée, ne s’arrête 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 examiner.

Voir aussi

Application Verifier - Vue d’ensemble

vérificateur d’applications - Fonctionnalités

Application Verifier - Tests au sein du vérificateur d’application

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

Vérificateur d’applications - Débogage de l’vérificateur d’application s’arrête

Application Verifier - Forum aux questions