Verificador de Aplicativos – Testando aplicativos

O Verificador de Aplicativos (AppVerifier) é uma ferramenta de verificação de runtime para código não gerenciado que auxilia na localização de erros de programação sutis, problemas de segurança e problemas limitados de privilégios de conta de usuário que podem ser difíceis de identificar com técnicas normais de teste de aplicativo.

Para fornecer aplicativos confiáveis do Windows:

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

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

Configurando o Verificador de Aplicativos

Configuração do depurador

O aplicativo que está sendo verificado deve ser executado em um depurador no modo de usuário ou o sistema deve ser executado em um depurador de kernel, pois ele será dividido em um depurador quando ocorrer um erro. Confira Verificador de Aplicativos – Depuração de Paradas do Verificador de Aplicativo para obter mais detalhes do depurador.

Configurações

O Verificador de Aplicativos não pode ser habilitado para um processo em execução. Como resultado, você precisa fazer 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 habilitado até que as configurações sejam excluídas.

Usando o teste de noções básicas do verificador de aplicativos

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

Habilite o verificador para os aplicativos 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 Básico na área Testes. Clique no botão Salvar.

Observações:

/verify habilitará os testes básicos

Se você estiver testando uma DLL, o Verificador de Aplicativo deverá 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 todas as noções básicas e, em outra, habilite todas as verificações LuaPriv.

Execute TODOS os testes que executam o aplicativo.

Analise as quebras de depurador encontradas. Se ocorrer uma interrupção, você precisará entendê-la e corrigi-la. OBSERVAÇÃO: o conteúdo da ajuda fornece detalhes sobre as quebras 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 o 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 heap

Quase 10% das falhas de aplicativo em sistemas Windows ocorrem devido à corrupção de heap. Essas falhas são quase impossíveis de depurar após o fato. A melhor maneira de evitar esses problemas é testar com os recursos do Heap de Página encontrados no Verificador de Aplicativos. Há dois tipos de Page Heap: "Full" e "Light". Full é o padrão; isso forçará um depurador a parar instantaneamente ao detectar corrupção. Esse recurso DEVE ser executado no depurador. No entanto, também é o recurso mais exigente. Se um usuário estiver tendo problemas de tempo e já tiver executado um cenário em Heap de Página "Completo", defini-lo como "Light" provavelmente resolverá esses problemas. Além disso, o Heap de Páginas Leves não falha até que o processo seja encerrado. Ele fornece um rastreamento de pilha para a alocação, mas pode levar consideravelmente mais tempo para diagnosticar do que aproveitar seu equivalente Completo.

Usando a Simulação de Pouco Recurso do AppVerifier (injeção de falha)

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

A taxa de aprovação para os testes pode diminuir significativamente, pois as injeções de falha aleatórias são introduzidas na operação normal.

Habilite a Simulação de Pouco Recurso do Verificador de Aplicativo (injeção de falha) para os aplicativos. 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 Pouco Recurso na área Testes. Clique no botão Salvar.

Observação: se você estiver testando uma DLL, poderá aplicar simulação de pouco 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

Executar TODOS os testes que executam o aplicativo

Analise as quebras de depurador encontradas. Se ocorrer uma interrupção, você precisará entendê-la e corrigi-la.

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 , clicando no botão Salvar.

Observação: a execução com e sem exercícios de injeção de falhas é em grande parte caminhos de código diferentes em um aplicativo e, portanto, ambos os cenários devem ser executados para obter o benefício completo do AppVerifier.

Usando o Verificador de Aplicativos com WOW64

Você pode usar a versão de 32 bits ou de 64 bits do Verificador de Aplicativos para verificar um aplicativo de 32 bits em execução em 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 então ser convertidos em XML por meio da interface do usuário ou da linha de comando para análise posterior.

Para exibir os arquivos XML, você pode usar qualquer ferramenta para exibir o XML, por exemplo, importar para o Microsoft Excel – Importar o arquivo XML para o Excel e usar filtros ou Tabelas Dinâmicas para reorganizar e analisar os dados coletados.

Usando a linha de comando

O Verificador de Aplicativos 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 Verificador de Aplicativos 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 desabilitar 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 Verificador de Aplicativos para todos os processos:

appverif –logtofile enable

appverif –logtofile disable

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

Sintaxe de linha de comando do verificador de aplicativo

Uso da linha de comando do verificador de aplicativos:

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

em que:

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

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). Essa é uma configuração estática que é persistente 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 desabilitados.

PROPERTY é o nome da propriedade específico 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 ele será imposto. Os tipos com suporte por enquanto são: booliano (verdadeiro/falso), inteiro (decimal/octal/hex em notação C), cadeia de caracteres e várias cadeias de caracteres (contendo \0’ between strings and being terminated by \0\0'). Se VALUE não for especificado, significa que o usuário deseja excluir essa propriedade e reverter 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 (nenhuma duas camadas pode 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 de verificador. Se o valor não for especificado, supõe-se que a propriedade deve ser excluída. As propriedades permitidas para paradas são (consulte Configurando paradas de verificador abaixo para obter mais detalhes):

• ErrorReport
• Severidade
• Sabor

As propriedades podem ser opcionalmente qualificadas pela camada à qual pertencem. No entanto, isso não será necessário se a linha de comando habilitar 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 variados

appverif –query providers

appverif –delete logs –for TARGET ...

appverif –delete settings –for TARGET ...

Elimine completamente o DESTINO do Registro.

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

Esse 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 formulário 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 Stamp opcional é usada para identificar qual parte do log deve ser exportada para XML. Se não for especificado, o log inteiro será convertido. A propriedade Log tem um inteiro negativo como valor possível e significa qual arquivo de log deve ser convertido começando do último (presumido 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 a linha de comando

A seguir estão os atalhos:

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

em que:

TARGET tem o mesmo significado descrito acima.

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 inicializado corretamente antes que ocorram falhas. Se não for especificado, o valor será 500 msecs.

DLL é o nome do módulo que é carregado no processo. Normalmente, esse é o nome de uma biblioteca dinâmica (.dll de extensão), 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 falha para notepad.exe (sempre que ela for iniciada). As falhas devem ocorrer com probabilidade de 10%, apenas 1000 msecs após a inicialização do processo e somente para operações iniciadas a partir de msvcrt.dll.

Habilitando detalhes de injeção de falha

O uso da linha de comando /faults habilitará a injeção de falha 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 você deseja ativar. Por exemplo, se você quiser injetar falha em um registro ou API de arquivo 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 de verificador

Usando a linha de comando (ou interface do usuário), você pode configurar paradas de verificador. A seguir estão exemplos para aproveitar:

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

STOP é o 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 ErrorReport , VALUE pode ser a combinação dos valores a seguir.

0x00000001 significa que a parada está ativa. (Se esse bit for zero, significa que a parada está desabilitada)

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

0x00000040 significa que a interrupção é interrompida no depurador gerando uma Exceção do 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 Severidade , VALUE pode ser um dos seguintes.

0x00000003 parada informativa.

aviso 0x0000000F.

erro 0x0000003F.

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

0x00000002 parada não contínua.

0x00000010 Esta parada será exibida apenas uma vez. Ele será ignorado no momento seguinte dentro da execução do teste.

Por exemplo, desabilitar 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), salvando um log sem rastreamento de pilha e tornando-o incompanável

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

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

O Verificador de Aplicativos tem configurações avançadas, como Inactivate, que você pode alterar por parada de 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 de verificador listados clicando no código de parada (observe que uma descrição da parada será exibida quando clicado).

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

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

• Ignorar
• Informações do
• Aviso
• Erro

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

Fazer logon no arquivo – uma caixa de seleção que, quando selecionada, fará logon no arquivo designado.

Rastreamento de Pilha de Log – uma caixa de seleção que, quando selecionada, registrará os rastreamentos de pilha quando eles estiverem disponíveis.

Sem Interrupção – uma opção para não interromper o depurador.

Exceção – uma opção sem interrupção e ponto de interrupção

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

Diversos fornece duas opções

Parar uma vez – uma caixa de seleção que, quando selecionada, só será interrompida nesse erro uma vez ao testar um aplicativo.

Não Continuable – uma caixa de seleção que, quando selecionada, não permitirá que você continue sem investigar.

Consulte Também

Verificador de Aplicativos – Visão geral

Verificador de Aplicativos – Recursos

Verificador de Aplicativos – Testes no Verificador de Aplicativos

Verificador de Aplicativos – Parar códigos e definições

Verificador de Aplicativos – Depuração de Paradas do Verificador de Aplicativo

Verificador de Aplicativos – Perguntas frequentes