Application Verifier - Aplicativos de teste

O Application Verifier (AppVerifier) é uma ferramenta de verificação de tempo de execução para código não gerenciado que ajuda a encontrar erros sutis de programação, problemas de segurança e problemas de privilégio de conta de usuário limitado que podem ser difíceis de identificar com técnicas normais de teste de aplicativos.

Para fornecer aplicativos confiáveis do Windows:

1. Teste aplicativos escritos em código não gerenciado (nativo) com o Application Verifier sob o depurador e com heap de página inteira antes de liberá-lo para os clientes.
2. Siga as etapas fornecidas pelo Application Verifier para resolver condições errantes.
3. Depois que o aplicativo for lançado, monitore regularmente os relatórios de falhas do aplicativo coletados, por exemplo, pelo Relatório de Erros do Windows, se disponível.

As verificações do pool de threads são habilitadas por padrão no título de verificação "Noções básicas". Como isso está incluído na configuração padrão, os usuários precisam apenas executar o Application Verifier em seu código com as configurações padrão para aproveitar essas e outras verificações importantes.

Configurando o Application Verifier

Configuração do depurador

O aplicativo que está sendo verificado deve ser executado sob um depurador de modo de usuário ou o sistema deve ser executado sob um depurador de kernel, pois ele irá invadir um depurador quando ocorrer um erro. Consulte Application Verifier - Debugging Application Verifier Stops para obter mais detalhes do depurador.

Configurações

O Application Verifier não pode ser habilitado para um processo em execução. Como resultado, você precisa fazer as configurações conforme descrito abaixo e, em seguida, iniciar o aplicativo. As configurações são persistentes até serem excluídas explicitamente. Portanto, não importa quantas vezes você inicie um aplicativo, ele começará com o AppVerifier ativado até que as configurações sejam excluídas.

Usando o teste básico do Application Verifier

Os cenários abaixo ilustram as opções recomendadas de linha de comando e interface do usuário. Estes devem ser executados durante todos os testes que exercem o código para garantir uma cobertura completa. A expectativa para esses cenários é que o aplicativo não entre no depurador e todos os testes passem com a mesma taxa de aprovação que quando executados sem o AppVerifier habilitado.

Habilite o verificador para o(s) aplicativo(s) que você deseja testar usando. Na linha de comando: appverif /verify MyApp.exe.

Na interface do usuário: adicione seu aplicativo clicando com o botão direito do mouse na área Aplicativos e selecionando Adicionar aplicativo. Selecione o Noções básicas na área Testes. Clique no botão Guardar.

Observações:

/verify habilitará os testes básicos

Se você estiver testando uma DLL, o Application Verifier deve ser habilitado para o executável de teste que está exercendo a DLL.

Execute as camadas de verificação separadamente. Por exemplo, em uma sessão habilite todos os Basics e em outra habilite todas as verificações LuaPriv.

Execute TODOS os seus testes exercendo o aplicativo.

Analise qualquer quebra(s) de depurador encontrada(s). Se ocorrer uma rutura, você precisará entendê-la e corrigi-la. NOTA: O conteúdo da ajuda fornece detalhes sobre as pausas e como investigá-las.

Quando terminar, exclua todas as configurações. Na linha de comando: appverif /n MyApp.exe.

Na interface do usuário, remova seu aplicativo clicando com o botão direito do mouse na área Aplicativos e selecionando Excluir aplicativo. Em seguida, clique no botão Salvar.

Corrupção de pilha

Quase 10% de falhas de aplicativos em sistemas Windows são devido à corrupção de pilha. Essas falhas são quase impossíveis de depurar após o fato. A melhor maneira de evitar esses problemas é testar com os recursos de heap de página encontrados no Application Verifier. Existem dois sabores de Page Heap: "Full" e "Light". Completo é o padrão; ele forçará uma parada do depurador instantaneamente ao detetar corrupção. Este recurso DEVE ser executado enquanto estiver sob o depurador. No entanto, é também o mais exigente em termos de recursos. Se um usuário estiver tendo problemas de tempo e já tiver executado um cenário em "Full" Page Heap, defini-lo como "Light" provavelmente resolverá esses problemas. Além disso, Light Page Heap não falha até que o processo saia. Ele fornece um rastreamento de pilha para a alocação, mas pode levar consideravelmente mais tempo para diagnosticar do que alavancar sua contraparte completa.

Usando o AppVerifier Low Resource Simulation (injeção de falhas)

A expectativa para esse cenário é que o aplicativo não entre no depurador. Ao não invadir o depurador significa que você não tem erros que precisam ser resolvidos.

A taxa de aprovação nos testes pode diminuir significativamente, uma vez que injeções aleatórias de falhas são introduzidas no funcionamento normal.

Habilite o Application Verifier Low Resource Simulation (injeção de falhas) para o(s) aplicativo(s). Na linha de comando: Appverif /verify MyApp.exe /faults. Na interface do usuário: adicione seu aplicativo clicando com o botão direito do mouse na área Aplicativos e selecionando Adicionar aplicativo . Selecione a Simulação de Baixo Recurso na área Testes. Clique no botão Guardar.

Nota: Se você estiver testando uma DLL, você pode aplicar simulação de baixo recurso (injeção de falha) em uma determinada DLL em vez de todo o processo. O formato da linha de comando seria:

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

Exemplo:

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

Execute TODOS os seus testes exercendo o aplicativo

Analise qualquer quebra(s) de depurador encontrada(s). Se ocorrer uma rutura, você precisará entendê-la e corrigi-la.

Quando terminar, exclua todas as configurações. A partir da linha de comando: appverif /n MyApp.exe. A partir da interface do utilizador: remova a sua aplicação clicando com o botão direito do rato na área Aplicações e selecionando Eliminar Aplicação , clicando no botão Guardar.

Nota: A execução com e sem injeção de falhas exerce caminhos de código muito diferentes em um aplicativo e, portanto, ambos os cenários devem ser executados para obter todos os benefícios do AppVerifier.

Usando o Application Verifier com o WOW64

Você pode usar a versão de 32 bits ou a versão de 64 bits do Application Verifier para verificar um aplicativo de 32 bits em execução no WOW64.

Analisando dados do AppVerifier

Todos os dados criados durante a análise do AppVerifier são armazenados na pasta %USERPROFILE%\AppVerifierLogs em um formato binário. Esses logs podem ser convertidos em XML através da interface do usuário ou linha de comando para análise posterior.

Para exibir os arquivos XML, você pode usar qualquer ferramenta para exibir o XML, por exemplo, importando para o Microsoft Excel - Importe o arquivo XML para o Excel e use filtros ou tabelas dinâmicas para reorganizar e analisar os dados coletados.

Usando a linha de comando

O Application Verifier pode ser usado por meio da interface do usuário ou usando opções de linha de comando.

A seguir estão exemplos de como usar a linha de comando (abaixo estão os detalhes):

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}

Para habilitar o Application Verifier para uma camada de verificação específica para dois aplicativos:

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

Para habilitar duas camadas chamadas X e Y para test.exe de destino com as propriedades X.DebugLevel e Y.DebugLevel:

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

Para desativar todas as verificações executadas em um aplicativo:

appverif -disable * -for notepad.exe

OU

appverif -delete settings -for notepad.exe

Para habilitar ou desabilitar globalmente o log do Application Verifier para todos os processos:

appverif –logtofile enable

appverif –logtofile disable

O registro em log é habilitado por padrão para todos os processos.

Sintaxe da linha de comando do Application Verifier

Uso da linha de comando do Application Verifier:

-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]

A sintaxe da linha de comando aceita uma ou mais camadas e as aplica a um ou mais destinos com especificadores de propriedade opcionais para camadas.

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] …]

onde:

LAYER é um nome padrão para uma camada de verificação. Se um novo provedor de verificador estiver instalado, isso exporá um novo nome de camada de verificação a ser usado na linha de comando. Exemplos de camadas são Heap, Handles ou Locks.

Você pode definir LAYER como * para especificar que o comando se aplica a todas as camadas.

TARGET é um nome binário (por exemplo, notepad.exe). Esta é uma configuração estática que persiste no registro e será levada em consideração sempre que o aplicativo for iniciado. Para o comando appverif –disable, você pode definir TARGET como * para especificar que todos os destinos devem ser desativados.

PROPERTY é o nome da propriedade específica para a LAYER mencionada na linha de comando. Por exemplo, a camada Handles tem rastreamentos como propriedade.

VALUE é um valor para a propriedade. O tipo do valor depende do tipo associado à propriedade e será aplicado. Os tipos suportados por enquanto são: booleano (verdadeiro/falso), inteiro (decimal/octal/hexadecimal em notação C), string e multi-string (contendo \0’ between strings and being terminated by \0\0'). Se VALUE não for especificado, isso significa que o usuário deseja excluir essa propriedade e reverter o comportamento para o valor padrão da propriedade.

STOP é o número (decimal ou hexadecimal na notação C) do problema de parada do verificador a ser configurado. Os códigos de parada devem ser exclusivos (não há duas camadas que possam usar o mesmo código de parada, portanto, a própria ferramenta determinará a qual camada a parada pertence)

STOPPROPERTY é um nome de propriedade aceitável para paradas do verificador. Se o valor não for especificado, presume-se que a propriedade deve ser excluída. As propriedades permitidas para paradas são (Consulte Configurando paradas do verificador abaixo para obter mais detalhes):

• Relatório de erros
• Gravidade
• Sabor

As propriedades podem ser qualificadas opcionalmente pela camada a que pertencem. No entanto, isso não é necessário se a linha de comando permitir apenas uma camada. Por exemplo, para habilitar duas camadas chamadas X e Y para test.exe de destino com as propriedades X.DebugLevel e Y.DebugLevel o comando é:

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

No entanto, se a camada X estiver habilitada, um nome de propriedade não qualificado poderá ser usado:

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

O caractere separador entre o nome da propriedade e o valor pode ser = (sinal de igual) ou : (dois pontos).

Comandos diversos

appverif –query providers

appverif –delete logs –for TARGET ...

appverif –delete settings –for TARGET ...

Apague completamente o TARGET do registro.

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

Este comando carimbará o log com LOG_STAMP. Esse carimbo é útil para identificar apenas uma seção de um log como relevante ao exibir o log no formato XML.

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

O comando acima exportará um log binário para um arquivo xml. A propriedade opcional Stamp é usada para identificar qual parte do log deve ser exportada para XML. Se não for especificado, todo o log será convertido. A propriedade Log tem um inteiro negativo como valor possível e significa qual arquivo de log deve ser convertido a partir do último (assumido se a propriedade não estiver presente). Por exemplo, inicie notepad.exe três vezes seguidas. Para acessar o primeiro log criado, especifique Log=-2 na linha de comando.

Atalhos para linha de comando

Seguem-se os atalhos:

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

onde:

O TARGET tem o mesmo significado que o acima descrito.

PROBABILIDADE é a probabilidade de injetar falhas. Deve ser um valor no intervalo 0..1000000. Se não for especificado, o valor padrão será 5%.

TIMEOUT é o intervalo de tempo em milissegundos durante a inicialização do processo quando a injeção de falha não acontece. Isso é feito para permitir que o processo seja iniciado corretamente antes que as falhas aconteçam. Se não for especificado, o valor será 500 msegs.

DLL é o nome do módulo que é carregado no processo. Normalmente, este é o nome de uma biblioteca dinâmica (extensão .dll), mas pode ser um ActiveX (extensão .ocx) ou algum outro módulo carregável.

Exemplos:

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

Habilite a injeção de falhas para notepad.exe (sempre que ela for iniciada). As falhas devem acontecer com probabilidade de 10%, apenas 1000 msegs após o processo ter sido iniciado e apenas para operações iniciadas a partir de msvcrt.dll.

Ativando detalhes de injeção de falhas

Usar a linha de comando /faults permitirá a injeção de falhas apenas para OLE_ALLOC e HEAP_ALLOC. No entanto, você pode usar a linha de comando para configurar qual tipo de injeção de falha deseja ativar. Por exemplo, se você quiser injetar falha em um registro ou arquivo API como 2%, use a linha de comando:

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

Outro exemplo:

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

Configurando paradas do verificador

Usando a linha de comando (ou interface do usuário), você pode configurar paradas do verificador. Seguem-se exemplos para alavancar:

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

STOP é um código de parada, como 0x200 0x201

TARGET é o nome do aplicativo, como foo.exe

PROPERTY pode ser um dos "ErrorReport", "Severity" e "Flavor"

Para o ErrorReport , VALUE pode ser a combinação dos seguintes valores.

0x00000001 significa que a parada está ativa. (Se este bit for zero, significa que a paragem está desativada)

0x00000020 significa que a parada será quebrada no depurador usando um ponto de interrupção.

0x00000040 significa a quebra de parada no depurador gerando uma exceção de verificador.

0x00000080 significa que a parada será registrada no arquivo de log.

0x00000100 significa que o rastreamento de pilha para essa parada será registrado no arquivo de log.

Para a gravidade, VALUE pode ser um dos seguintes.

0x00000003 Parada informativa.

0x0000000F Aviso.

0x0000003F Erro.

Para o Flavor, Value pode ser a combinação dos seguintes valores.

0x00000002 Paragem não continuável.

0x00000010 Esta paragem só aparecerá uma vez. Ele será ignorado na seguinte vez dentro da execução de teste.

Por exemplo, desativar paradas 0x2700 0x2701 para foo.exe

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

Configure o código de parada 0x2700 como invadir o depurador (ele está desativado por padrão), salvar um log sem rastreamento de pilha e torná-lo não contínuo

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

Opções de parada do verificador - Configurações avançadas

O Application Verifier tem configurações avançadas, como Inactivate, que você pode alterar por parada do verificador.

Opções de parada do verificador de acesso - As opções de parada do verificador são alteradas em uma caixa de diálogo que lista as opções disponíveis. Para acessar as opções de parada do verificador:

1. Selecione o nome de um teste no painel Testes.
2. No menu Editar, selecione Opções de parada do verificador ou clique com o botão direito do mouse no teste e selecione Opções de parada do verificador.

Opções de parada do verificador

Você pode alterar os seguintes elementos por parada do verificador listados clicando no código de parada (observe que uma descrição da parada aparecerá quando clicado).

Inativo é uma caixa de seleção que, quando selecionada, desativará a execução do código de parada do verificador.

A severidade determina como a parada do verificador deve ser sinalizada:

• Ignorar
• Informação
• Advertência
• Erro

O Relatório de Erros determina como você gostaria que a parada específica do verificador fosse relatada/registrada:

Log to File - uma caixa de seleção que, quando selecionada, registrará no arquivo designado.

Log Stack Trace - uma caixa de seleção que, quando selecionada, registrará os rastreamentos de pilha quando estiverem disponíveis.

No Break - uma opção para não quebrar no depurador.

Exceção - uma opção sem quebra e ponto de interrupção

Ponto de interrupção - uma opção sem quebra ou exceção.

Miscelânea oferece duas opções

Parar uma vez - uma caixa de seleção que, quando selecionada, só irá parar nesse erro uma vez ao testar um aplicativo.

Não Contínuo - uma caixa de seleção que, quando selecionada, não permitirá que você continue sem investigar.

Ver também

Application Verifier - Visão geral

Application Verifier - Recursos

Application Verifier - Testes dentro do Application Verifier

Application Verifier - Códigos de parada e definições

Application Verifier - Debugging Application Verifier para

Application Verifier - Perguntas Frequentes