Verificando código pela Automação da Interface do Usuário

Artigo
06/08/2015

Os testes automatizados que orientam o aplicativo por meio da interface do usuário são conhecidos como testes de IU codificados (CUITs).Entre esses testes estão testes funcionais dos controles de interface de usuário.Eles permitem verificar se todo o aplicativo, inclusive sua interface do usuário, está funcionando corretamente.Os testes de IU codificados são especialmente úteis quando há validação ou outra lógica na interface do usuário, como em uma página da Web.Eles também costumam ser usados para automatizar um teste manual existente.

Conforme mostrado na ilustração a seguir, uma experiência de desenvolvimento típica pode ser uma em que, inicialmente, você só compila o aplicativo (F5) e clica nos controles de interface de usuário para verificar se as coisas estão funcionando corretamente.Em seguida, você pode optar por criar um teste codificado para não ser mais necessário testar o aplicativo manualmente.Dependendo da funcionalidade específica testada no aplicativo, você pode gravar código para um teste funcional ou para um teste de integração que pode ou não incluir testes no nível da interface do usuário.Se quiser apenas acessar diretamente uma lógica de negócios, você poderá codificar um teste de unidade.Porém, em determinadas circunstâncias, pode ser benéfico incluir testes dos diversos controles de interface de usuário no aplicativo.Um teste de IU codificado pode automatizar o cenário inicial (F5), verificando se a variação de código não afeta a funcionalidade do aplicativo.

Os testes durante o desenvolvimento de aplicativos

É fácil criar um teste de IU codificado.Basta realizar o teste manualmente enquanto o CUIT Test Builder é executado em segundo plano.Também é possível especificar quais valores devem ser exibidos em campos específicos.O CUIT Test Builder registra as ações e gera códigos a partir delas.Depois que o teste for criado, será possível editá-lo em um editor especializado que permite modificar a sequência de ações.

Como alternativa, se tiver um caso de teste que tenha sido registrado no Microsoft Test Manager, será possível gerar código a partir dele.Para obter mais informações, consulte Gravar e reproduzir testes manuais.

O CUIT Test Builder especializado e o editor facilitam a criação e a edição de testes de IU codificados mesmo que suas habilidades principais estejam concentradas em testes, e não em codificação.Mas, se você for um desenvolvedor e quiser estender o teste de maneira mais avançada, o código será estruturado para simplificar a cópia e a adaptação.Por exemplo, convém registrar um teste para comprar algo em um site e editar o código gerado para adicionar um loop que compre muitos itens.

Requisitos

Visual Studio Ultimate, Visual Studio Premium

Para obter mais informações sobre quais plataformas e configurações são compatíveis com testes de UI codificados, consulte Configurações e plataformas compatíveis para testes de IU codificados e gravações de ações.

Neste tópico

Criando testes de IU codificados
- Procedimento principal
- Iniciando e parando o aplicativo
- Validando as propriedades de controles de interface de usuário
Personalizando o teste de IU codificado
- O código gerado
- Codificando ações e propriedades de controle de interface de usuário
- Depuração
O que vem a seguir

Criando testes de IU codificados

Crie um projeto de teste de IU codificado.

Os testes de IU codificados devem estar contidos em um projeto de teste de IU codificado.Se você ainda não tiver um projeto de teste de IU codificado, crie um.No Gerenciador de Soluções, no menu de atalho da solução, escolha Adicionar, Novo Projeto e selecione Visual Basic ou Visual C#.Em seguida, escolha Teste, Teste de IU Codificado.
- Não vejo os modelos de projeto do Teste de IU Codificado.
  
  Você pode usar uma versão do Microsoft Visual Studio 2012 que não oferece suporte a testes de IU codificados.Para criar testes de IU codificados, você deve usar o Visual Studio Ultimate ou Visual Studio Premium.
Adicione um arquivo de teste de IU codificado.

Se tiver acabado de criar um projeto de IU codificado, o primeiro arquivo CUIT será adicionado automaticamente.Para adicionar outro arquivo de teste, abra o menu de atalho no projeto de teste de IU codificado, aponte para Adicionar e escolha Teste de IU Codificado.

No Gerar código para teste de IU codificado caixa de diálogo caixa, escolha gravar ações, editar o mapa de interface do usuário ou adicionar asserções.

O Construtor de Teste de IU Codificado é exibido, e o Visual Studio é minimizado.

Gravar uma seqüência de ações.

Para iniciar a gravação, escolha o registro ícone.Realize as ações que você quer testar no aplicativo, inclusive iniciá-lo, se isso for necessário.

Por exemplo, se você estiver testando um aplicativo Web, convém iniciar um navegador, navegar até o site e fazer logon no aplicativo.

Para pausar o registro, por exemplo, se você tem de lidar com emails recebidos, escolha Pausar.

Cuidado
Todas as ações realizadas na área de trabalho serão registradas.Pause a gravação se estiver realizando ações que possam levar à exclusão de dados confidenciais na gravação.

Excluir ações registradas por equívoco, escolha Editar ações.

Para gerar código replicará as ações, escolha o Gerar código ícone e digite um nome e descrição para a interface do usuário codificado de método de teste.

Verifique os valores nos campos de interface do usuário, como caixas de texto.

Escolha Adicionar Asserções no Construtor de Teste de IU Codificado e escolha um controle de interface de usuário no aplicativo em execução.Na lista de propriedades exibida, selecione uma propriedade, por exemplo, Texto em uma caixa de texto.No menu de atalho, escolha Adicionar Asserção.Na caixa de diálogo, selecione o operador de comparação, o valor de comparação e a mensagem de erro.

Feche a janela de declaração e escolha Gerar código.

Codificado elemento direcionamento de teste de interface do usuário

Dica
Alterne entre o registro de ações e a verificação de valores.Gere códigos no final de cada sequência de ações ou verificações.Se quiser, você poderá inserir novas ações e verificações depois.

Para obter mais detalhes, consulte Validando propriedades de controles.

Exibir o código de teste gerado.

Para exibir o código gerado, feche a janela Construtor de Teste de IU.No código, é possível ver os nomes que você deu a cada etapa.O código está no arquivo CUIT que você criou:

    [CodedUITest]
    public class CodedUITest1
    { ...
      [TestMethod]
      public void CodedUITestMethod1()
      {
          this.UIMap.AddTwoNumbers();
          this.UIMap.VerifyResultValue();
          // To generate more code for this test, select 
          // "Generate Code" from the shortcut menu.
      }
    }

Adicionar mais ações e asserções.

Coloque o cursor no ponto apropriado no método de teste e, no menu de atalho, escolha Gerar Código para Teste de IU Codificado.O novo código será inserido nesse ponto.
Edite os detalhes das ações de teste e as asserções.

Abra UIMap.uitest.Esse arquivo é aberto no Editor de testes de interface de usuário codificada, em que é possível editar qualquer sequência de ações registradas, além de editar as asserções.

Para obter mais informações, consulte Editando testes de interface de usuário codificada usando o editor de teste de interface de usuário codificada.
Executar o teste.

Use o Gerenciador de Testes, ou abra o menu de atalho no método de teste e escolha Executar Testes.Para obter mais informações sobre como executar testes, consulte Executando testes de unidade com o Gerenciador de Testes e Opções adicionais para executar testes de IU codificados no o que vem a seguir? seção no final deste tópico.

As seções restantes neste tópico fornecem mais detalhes sobre as etapas desse procedimento.

Para obter um exemplo mais detalhado, consulte Instruções passo a passo: criando, editando e mantendo um teste de IU codificado.Neste passo a passo, você criará um aplicativo simples do Windows Presentation Foundation (WPF) para demonstrar como criar, editar e manter um teste de IU codificado.O passo a passo fornece soluções para corrigir os testes que foram interrompidos por vários problemas de timing e refatoração de controle.

Iniciando e parando o aplicativo em teste

Não desejo iniciar e parar meu aplicativo, navegador ou banco de dados separadamente para cada teste.Como evito isso?

Se você não quiser registrar as ações para iniciar o aplicativo em teste, você deve iniciar seu aplicativo antes de escolher o registro ícone.
No final de um teste, o processo no qual o teste é executado é encerrado.Se tiver iniciado o aplicativo no teste, normalmente, o aplicativo é fechado.Se não quiser que o teste feche o aplicativo quando terminar, você deverá adicionar um arquivo .runsettings à solução e usar a opção KeepExecutorAliveAfterLegacyRun.Para obter mais informações, consulte Configurando testes de unidade usando um arquivo .runsettings.
É possível adicionar um método de inicialização do teste, identificado por um atributo [TestInitialize], que executa o código no início de cada método de teste.Por exemplo, você poderia iniciar o aplicativo do método TestInitialize.
É possível adicionar um método de limpeza de teste, identificado por um atributo [TestCleanup], que executa o código no fim de cada método de teste.Por exemplo, o método para fechar o aplicativo poderia ser chamado do método TestCleanup.

Validando as propriedades de controles de interface de usuário

É possível usar o Construtor de Teste de IU Codificado para adicionar um controle de interface do usuário ao UIMap para o teste ou gerar código para um método de validação que usa uma asserção para um controle de interface de usuário.

Para gerar asserções para os controles de interface de usuário, escolha a ferramenta Adicionar Asserções no Construtor de Teste de IU Codificado e arraste-a até o controle no aplicativo em teste que você deseja verificar se está correto.Quando a caixa contornar o controle, solte o mouse.O código da classe de controle é criado imediatamente no arquivo UIMap.Designer.cs.

Codificado elemento direcionamento de teste de interface do usuário

As propriedades desse controle agora são listadas no Adicionar asserções caixa de diálogo.

Outra maneira de navegar até um determinado controle é escolhendo a seta (<<) para expandir a exibição do Mapa de Controles de IU.Para encontrar um controle pai, irmão ou filho, é possível clicar em qualquer lugar no mapa e usar as telas de direção para navegar pela árvore.

Propriedades de teste UI codificadas

Não vejo nenhuma propriedade quando seleciono um controle no aplicativo ou não vejo o controle no Mapa de Controles de IU.

No código do aplicativo, o controle que você deseja verificar deve ter uma ID exclusiva, como um atributo de ID HTML ou WPF UId.Talvez seja necessário atualizar o código do aplicativo para adicionar essas IDs.

Depois, abra o menu de atalho na propriedade do controle de interface de usuário que você deseja verificar e aponte para Adicionar Asserção.Na caixa de diálogo Adicionar Asserção, selecione o Comparador da asserção, por exemplo, AreEqual, e digite o valor da asserção em Valor de Comparação.

Asserções de teste UI codificadas

Quando tiver adicionado todas as asserções do teste, escolha OK.

Para gerar o código das asserções e adicionar o controle ao mapa de interface do usuário, escolha o ícone Gerar Código.Digite um nome para o método de teste de IU codificado e uma descrição para o método, que serão adicionados como comentários para ele.Escolha Adicionar e Gerar.Em seguida, escolha o ícone Fechar para fechar o Construtor de Teste de IU Codificado.Isso gera um código semelhante ao código a seguir.Por exemplo, se o nome inserido for AssertForAddTwoNumbers, o código terá a aparência deste exemplo:

Adiciona uma chamada ao método de asserção AssertForAddTwoNumbers para o método de teste no arquivo de teste de IU codificado:
```
      [TestMethod]
      public void CodedUITestMethod1()
      {
          this.UIMap.AddTwoNumbers();
          this.UIMap.AssertForAddTwoNumbers();
      }
```
É possível editar esse arquivo para alterar a ordem das etapas e das asserções ou criar novos métodos de teste.Para adicionar mais código, coloque o cursor no método de teste e, no menu de atalho, escolha Gerar Código para Teste de IU Codificado.
Adiciona um método chamado AssertForAddTwoNumbers ao mapa de interface do usuário (UIMap.uitest).Esse arquivo é aberto no Editor de testes de interface de usuário codificada, em que é possível editar as asserções.

Para obter mais informações, consulte Editando testes de interface de usuário codificada usando o editor de teste de interface de usuário codificada.

Também é possível exibir o código gerado do método de asserção em UIMap.Designer.cs.Porém, você não deve editar esse arquivo.Se quiser criar uma versão adaptada do código, copie os métodos em outro arquivo, como UIMap.cs, renomeie e edite os métodos lá.
```
      public void AssertForAddTwoNumbers()
      {
          ...
      }
```
O controle que desejo selecionar perde o foco e desaparece quando tento selecionar a ferramenta Adicionar asserções no construtor de teste de IU codificado. Como selecionar o controle?

Selecionando um controle oculto usando o teclado

Às vezes, ao adicionar controles e validar suas propriedades, seja necessário usar o teclado.Por exemplo, quando você tenta registrar um teste de IU codificado que usa um controle de menu de contexto, a lista de itens de menu no controle perderá o foco e desaparecerá quando você tentar selecionar a ferramenta Adicionar Asserções no Construtor de Teste de IU Codificado.Isso é demonstrado na ilustração a seguir, em que o menu de contexto no Internet Explorer perderá o foco e desaparecerá se você tentar selecioná-lo usando a ferramenta Adicionar Asserções.

Para usar o teclado e selecionar um controle de interface de usuário, focalize o controle usando o mouse.Em seguida, mantenha as teclas Ctrl e I pressionadas simultaneamente.Solte as teclas.O controle é registrado pelo Construtor de Teste de IU Codificado.

Cuidado

Se usar o Microsoft Lync, feche o Lync antes de iniciar o Construtor de Teste de IU Codificado.O Microsoft Lync interfere no atalho de teclado Ctrl+I.
Não consigo registrar uma passagem do mouse em um controle. Há uma maneira de contornar isso?

Registrando manualmente passagens do mouse

Em algumas circunstâncias, um determinado controle usado em um teste de IU codificado pode exigir que você use o teclado para registrar manualmente eventos de passagem do mouse.Por exemplo, quando você testa um aplicativo do Windows Form ou do Windows Presentation Foundation (WPF), talvez haja código personalizado.Ou talvez haja um comportamento especial definido para a passagem do mouse sobre um controle, como a expansão de um nó de árvore quando um usuário o focaliza.Para testar circunstâncias como essa, você precisa notificar manualmente o Construtor de Teste de IU Codificado que está focalizando o controle pressionando as teclas predefinidas do teclado.

Ao realizar o teste de IU codificado, focalize o controle.Em seguida, mantenha a tecla Ctrl pressionada, enquanto pressiona e solta as teclas Shift e R do teclado.Solte as teclas.Um evento de passagem do mouse é registrado pelo Construtor de Teste de IU Codificado.

Depois que você gerar o método de teste, um código semelhante ao exemplo a seguir será adicionado ao arquivo UIMap.Desinger.cs:
```
// Mouse hover '1' label at (87, 9)
Mouse.Hover(uIItem1Text, new Point(87, 9));
```

Cuidado
Se usar o Microsoft Lync, feche o Lync antes de iniciar o Construtor de Teste de IU Codificado.O Microsoft Lync interfere no atalho de teclado Ctrl+I.

A atribuição de tecla para capturar eventos de passagem do mouse está sendo usada em outro lugar no meu ambiente. Posso alterar a atribuição de tecla padrão?

Configurando atribuições de teclado de passagem do mouse

Se necessário, a atribuição de teclado padrão de Ctrl+Shift+R usada para aplicar eventos de passagem do mouse nos testes de IU codificados pode ser configurada para usar teclas diferentes.

Cuidado
Você não deve alterar as atribuições de teclado para eventos de passagem do mouse em circunstâncias comuns.Tenha cuidado ao definir a atribuição de teclado.A opção talvez já esteja em uso em outro lugar dentro do Visual Studio ou no aplicativo que está sendo testado.

Para alterar as atribuições de teclado, você deve modificar o seguinte arquivo de configuração:

<letra da unidade:>\Arquivos de Programas (x86)\Microsoft Visual Studio 11.0\Common7\IDE\CodedUITestBuilder.exe.config

No arquivo de configuração, altere os valores das teclas HoverKeyModifier e HoverKey para modificar as atribuições de teclado:

<!-- Begin : Background Recorder Settings -->
<!-- HoverKey to use. -->
<add key="HoverKeyModifier" value="Control, Shift"/>
<add key="HoverKey" value="R"/>

Estou tendo problemas para registrar passagens do mouse em um site. Há uma correção para isso, muito?

Definindo passagens do mouse implícitas para o navegador da Web

Em muitos sites, quando você focaliza um determinado controle, ele expande para mostrar detalhes adicionais.Geralmente, eles parecem menus em aplicativos da área de trabalho.Como esse é um padrão comum, os testes de IU codificados permitem passagens do mouse implícitas na navegação na Web.Por exemplo, se você registrar passagens do mouse no Internet Explorer, será acionado um evento.Esses eventos podem acarretar o registro de passagens redundantes do mouse.Por isso, as passagens do mouse implícitas são registradas com ContinueOnError definido como true no arquivo de configuração de teste de interface do usuário.Isso permite que a reprodução continue em caso de falha em um evento de passagem do mouse.

Para habilitar o registro de passagens do mouse implícitas em um navegador da Web, abra o arquivo de configuração:

<letra da unidade:>\Arquivos de Programas (x86)\Microsoft Visual Studio 11.0\Common7\IDE\CodedUITestBuilder.exe.config

Verifique se o arquivo de configuração está com a chave RecordImplicitiHovers definida com o valor true, como mostrado no exemplo a seguir:
```

<add key="RecordImplicitHover" value="true"/>
```

Personalizando o teste de IU codificado

Depois de criar o teste de IU codificado, você poderá editá-lo usando qualquer uma destas ferramentas no Visual Studio:

Coded UI Test Builder: usar o construtor de teste de IU codificado para adicionar controles e validação aos seus testes.Consulte a seção Adicionando controles e validando suas propriedades neste tópico.
Editor de teste de IU codificado: o Editor de testes de UI codificados permite modificar facilmente os testes de UI codificados.Com o Editor de testes de interface de usuário codificada, você pode localizar, exibir e editar os métodos de teste.Também é possível editar ações de interface do usuário e seus controles associados no mapa de controles de IU.Para obter mais informações, consulte Editando testes de interface de usuário codificada usando o editor de teste de interface de usuário codificada.
Editor de Códigos:
- adicione manualmente códigos dos controles ao teste, como descrito na seção Codificando ações e propriedades de controle de IU deste tópico.
- Depois de criar um teste de IU codificado, você poderá modificá-lo para ser controlado por dados.Para obter mais informações, consulte Criando um teste de interface do usuário codificado controlado por dados.
- Na reprodução de um teste de IU codificado, é possível instruir o teste a aguardar a ocorrência de determinados eventos, como a exibição de uma janela, o desaparecimento da barra de progresso etc.Para isso, adicione o método UITestControl.WaitForControlXXX() apropriado.Para obter uma lista completa dos métodos disponíveis, consulte Fazendo testes de IU codificado aguardar eventos específicos durante a reprodução.Para obter um exemplo de um teste de IU codificado que aguarda um controle para ser habilitado usando o método WaitForControlEnabled, consulte Instruções passo a passo: criando, editando e mantendo um teste de IU codificado.
- Os teste de IU codificados incluem suporte a alguns dos controles HTML5 incluídos no Internet Explorer 9 e no Internet Explorer 10.Para obter mais informações, consulte Usando controles HTML5 em testes de IU codificados.
- Diretrizes de codificação do teste de IU codificado:

O código gerado

Quando você escolhe Gerar Código, diversas partes do código são criadas:

Uma linha no método de teste.
```
    [CodedUITest]
    public class CodedUITest1
    { ...
      [TestMethod]
      public void CodedUITestMethod1()
      {
          this.UIMap.AddTwoNumbers();
          // To generate more code for this test, select 
          // "Generate Code" from the shortcut menu.      }
    }
```
É possível clicar com o botão direito do mouse nesse método para adicionar mais ações registradas e verificações.Também é possível editá-lo para estender ou modificar o código.Por exemplo, você poderia embutir parte do código em um loop.

Também é possível adicionar novos métodos de teste e adicionar código a eles da mesma forma.Cada método de teste deve ter o atributo [TestMethod].
Um método em UIMap.uitest

Esse método inclui os detalhes das ações registradas ou o valor verificado por você.Você pode editar esse código abrindo UIMap.uitest.Ele é aberto em um editor especializado, no qual é possível excluir ou refatorar as ações registradas.

Também é possível exibir o método gerado em UIMap.Designer.cs.Esse método realiza as ações registradas quando você executa o teste.
```
// File: UIMap.Designer.cs
public partial class UIMap
{
  /// <summary>
  /// Add two numbers
  /// </summary>
  public void AddTwoNumbers()
  { ...   }
}
```
Cuidado

Você não deve editar esse arquivo, porque ele será registrado quando você cria mais testes.

É possível criar versões adaptadas desses métodos copiando-os em UIMap.cs.Por exemplo, você poderia criar uma versão parametrizada que seria chamada a partir de um método de teste:
```
// File: UIMap.cs
public partial class UIMap // Same partial class
{
  /// <summary>
  /// Add two numbers – parameterized version
  /// </summary>
  public void AddTwoNumbers(int firstNumber, int secondNumber)
  { ...   // Code modified to use parameters.
  }
}
```
Declarações em UIMap.uitest

Essas declarações representam os controles de interface de usuário do aplicativo usados pelo teste.Elas são usadas pelo código gerado para operar os controles e acessar suas propriedades.

Também será possível usá-las para gravar seu próprio código.Por exemplo, é possível fazer o método de teste escolher um hiperlink em um aplicativo Web, digitar um valor em uma caixa de texto ou ramificar e utilizar ações de testes diferentes com base no valor de um campo.

É possível adicionar vários testes de IU codificados e vários objetos e arquivos de mapa de IU para facilitar os testes de um aplicativo grande.Para obter mais informações, consulte Testando um aplicativo grande com vários mapas de interface do usuário.

Cuidado
Você não deve editar esse arquivo, porque ele será registrado quando você cria mais testes.

Para obter mais informações sobre o código gerado, consulte Anatomia de um teste de IU codificado.

Codificando ações e propriedades de controle de interface de usuário

Quando você trabalha com controles de teste de IU em testes de IU codificados, eles são separados em duas partes: ações e propriedades.

A primeira parte consiste em ações, que é possível realizar em controles de teste de IU.Por exemplo, os testes de IU codificados podem simular cliques do mouse em um controle de teste de IU ou simular teclas pressionadas no teclado para afetar um controle de teste de IU.
A segunda parte consiste em permitir que você obtenha e defina as propriedades em um controle de teste de IU.Por exemplo, os testes de IU codificados podem obter a contagem de itens em um ListBox ou definir um CheckBox no estado selecionado.

Acessando ações do controle de teste de IU

Para realizar ações em controles de teste de IU, como cliques do mouse ou ações de teclado, use os métodos nas classes Mouse e Keyboard:

Para realizar uma ação orientada pelo mouse, como um clique do mouse em um controle de teste de IU, use Click.

Mouse.Click(buttonCancel);
Para realizar uma ação orientada pelo teclado, como digitar em um controle de edição, use SendKeys.

Keyboard.SendKeys(textBoxDestination, @"C:\\Temp\\Output.txt");

Acessando propriedades do controle de teste de IU

Para obter e definir valores de propriedade específicas de controle de interface de usuário, é possível obter e definir diretamente os valores como as propriedades de um controle ou usar os métodos UITestControl.GetProperty e UITestControl.SetProperty com o nome da propriedade específica que você deseja obter ou definir.

GetProperty Retorna um objeto que pode ser convertido para o Type.SetProperty aceita um objeto para o valor da propriedade.

Para obter ou definir propriedades de controles de teste de IU diretamente

Com controles derivados de T:Microsoft.VisualStudio.TestTools.UITesting.UITestControl, como T:Microsoft.VisualStudio.TestTools.UITesting.HtmlControls.HtmlList ou T:Microsoft.VisualStudio.TestTools.UITesting.WinControls.WinComboBox, é possível obter ou definir os valores de propriedade diretamente da seguinte forma:
```
int i = myHtmlList.ItemCount;
myWinCheckBox.Checked = true;
```

Para obter propriedades de controles de teste de IU

Para obter um valor de propriedade de um controle, use GetProperty.
Para especificar a propriedade de controle a ser obtida, use a cadeia de caracteres apropriada da classe PropertyNames em cada controle como parâmetro para GetProperty.
GetProperty Retorna o tipo de dados apropriado, mas este valor retornado é convertido como um Object.Em seguida, o Object de retorno deve ser convertido como tipo apropriado.

Exemplo:

int i = (int)GetProperty(myHtmlList.PropertyNames.ItemCount);

Para definir propriedades para controles de teste de IU

Para obter uma propriedade em um controle, use SetProperty.
Para especificar a propriedade do controle a ser definida, use a cadeia de caracteres apropriada da classe PropertyNames como primeiro parâmetro para SetProperty, com o valor da propriedade como segundo parâmetro.

Exemplo:

SetProperty(myWinCheckBox.PropertyNames.Checked, true);

Depuração

Você pode analisar testes de IU codificados usando logs de teste de IU codificado.Os logs de teste de IU codificado filtram e registram informações importantes sobre as execuções de teste de IU codificado.O formato dos logs permite depurar rapidamente os problemas.Para obter mais informações, consulte Analisando testes de interface de usuário codificada usando logs de teste de interface de usuário codificada.

O que vem a seguir?

Opções adicionais para executar testes de IU codificados: você pode executar testes de UI codificados diretamente do Visual Studio, conforme descrito anteriormente neste tópico.Além disso, é possível executar testes de IU automatizados em Microsoft Test Manager ou Team Foundation Build.Quando são automatizados, os testes de IU codificados precisam interagir com a área de trabalho quando executados, diferentemente de outros testes automatizados.

Adicionando suporte para controles personalizados: a estrutura de testes de UI codificada não oferece suporte a todas as interfaces do usuário possíveis e talvez não ofereça suporte a interface do usuário que você deseja testar.Por exemplo, você não pode criar imediatamente um teste de IU codificado para a IU do Microsoft Excel.Porém, você pode criar uma extensão para o framework de teste de IU codificado que oferecerá suporte a um controle personalizado.

Os testes de IU codificados costumam ser usados para automatizar testes manuais.Para obter orientação adicional, consulte teste para entrega contínua com o Visual Studio 2012 – capítulo 5: automatizando testes do sistema.Para obter mais informações sobre testes manuais, consulte [obsoleto] Criando casos de teste manuais usando o Microsoft Test Manager.Para obter mais informações sobre testes automatizados do sistema, consulte Criando testes automatizados por meio do Microsoft Test Manager.

Recursos externos

Orientação

Teste para entrega contínua com o Visual Studio 2012 – capítulo 2: testes de unidade: Testando o interior

teste para entrega contínua com o Visual Studio 2012 – capítulo 5: automatizando testes do sistema

Perguntas frequentes

Testes de UI codificados FAQ - 1

-2 de perguntas frequentes sobre testes de UI codificados

Fórum

Visual Studio automação de testes de IU (inclui CodedUI)

Consulte também

Compartilhar via