Verificando o código usando testes de interface do usuário codificada

Artigo
03/12/2013

Os testes automatizados que levam seu aplicativo através da interface do usuário (UI) são conhecidos como interface do usuário codificado testa (CUITs).Esses incluem testes de colisão funcionais dos controles de interface do usuário.Permite que você verifique se o aplicativo inteiro, incluindo sua interface do usuário, está funcionando corretamente.Os testes codificados de interface do usuário são particularmente úteis onde há uma validação ou outra lógica na interface do usuário, por exemplo em um página da Web.Também são usados com freqüência para automatizar um teste manual existente.

Conforme mostrado na ilustração a seguir, uma experiência de desenvolvimento típica pode ser uma, onde inicialmente, você compila somente o aplicativo (F5) e clique nos controles de interface de usuário para verificar que as coisas trabalhassem corretamente.Você então poderá decidir criar um teste codificado para que você não precisava de continuar para testar manualmente o aplicativo.Dependendo da funcionalidade específica que está sendo testada em seu aplicativo, você pode escrever código para um teste funcional, ou para um teste de integração que pode ou não pode incluir teste na interface do usuário em nível.Se você simplesmente quer acessar diretamente alguma lógica comercial, você pode codificar um teste de unidade.No entanto, em determinadas circunstâncias, pode ser útil incluir teste de vários controles de interface do usuário em seu aplicativo.Um teste codificado de interface do usuário pode automatizar o cenário de inicial (F5), verificando que agitações de código não afeta a funcionalidade do seu aplicativo.

Testes durante o desenvolvimento de aplicativo

Criar um teste codificado de interface do usuário é fácil.Você simplesmente executa o teste manualmente quando o construtor de teste de CUIT executar no plano de fundo.Você também pode especificar valores que devem aparecer em campos específicos.O construtor de teste de CUIT registra suas ações e gera código de eles.Depois que o teste é criado, você pode editá-lo em um editor especializado que permite que você altere a sequência de ações.

Como alternativa, se você tiver uma situação de teste que é gravada no gerenciador de teste da Microsoft, você pode gerar código do.Para obter mais informações, consulte Recording and Playing Back testes manuais.

O construtor e o editor especializados de teste de CUIT facilitam criar e editar teste codificados de interface do usuário mesmo se suas habilidades chave são concentradas testar um em vez de codificação.Mas se você for um desenvolvedor e você deseja estender o teste de uma maneira mais eficiente, o código é estruturado de modo que é simples copiar e se adaptar.Por exemplo, você pode registrar um teste para comprar algo em um site, e editar o código gerado para adicionar um loop que comprasse vários itens.

Requisitos

Visual Studio Ultimate, Visual Studio Premium

Para obter mais informações sobre o que plataformas e configurações são suportadas pelos testes codificados de interface do usuário, consulte Supported Configurations and Platforms for Coded UI Tests and Action Recordings.

Neste tópico

Criando teste codificados de interface de usuário
- procedimento Main
- Inicial e parar o aplicativo
- Validando as propriedades de controles de interface de usuário
Personalizando seu teste codificado de interface de usuário
- O código gerado
- Ações e propriedades de controle da interface do usuário de codificação
- Depuração
O que é seguinte

Criando teste codificados de interface de usuário

Crie um projeto de teste codificado de interface do usuário.

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

Se você criou um projeto codificado de interface do usuário, o primeiro arquivo de CUIT é adicionado automaticamente.Para adicionar um outro arquivo de teste, abra o menu de atalho codificado no projeto de teste de interface do usuário, aponte para Adicionar, e escolha Teste de IU Codificado.

Na caixa de diálogo de Gerar Código para Teste de IU Codificado , escolha Registrar ações, edite o mapa de interface do usuário ou adicionar asserções.

O construtor codificado de teste de interface de usuário será exibido e Visual Studio é minimizado.
Registrar uma sequência de ações.

Para começar a escrever, clique no ícone de Gravar .Executar as ações que você deseja testar em seu aplicativo, incluindo iniciar o aplicativo se isso é necessário.

Por exemplo, se você está testando uma aplicativo da web, você pode iniciar um navegador, navegue para o site, e entre ao aplicativo.

Para pausar gravaçãopor exemplo, se você tem que lidar com o email de entrada, escolha Pausar.

Para excluir ações que você gravou por engano, escolher Ações de edição.

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

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

Escolha Adicione declarações no construtor codificado de teste de interface do usuário, e então escolha um controle de interface do usuário no aplicativo em execução.Na lista de propriedades que aparece, selecione uma propriedade, por exemplo, Texto em uma caixa de texto.No menu de atalho, escolha Adicione a declaraçã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 de direcionamento de teste de interface do usuário

Dica
Alternar entre ações de gravação e verificar valores.Gerar código ao final da cada sequência de ações ou de verificação.Se você desejar, você poderá posteriormente inserir novos ações e verifica.

Para mais detalhes, consulte Validando propriedades de controles.

Exibir o código de teste gerado.

Para exibir o código gerado, feche a janela do construtor de teste de interface do usuário.Em código, você pode ver os nomes que você deu a cada etapa.O código está no arquivo de 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 em seguida, no menu de atalho, escolha Gerar Código para Teste de IU Codificado.O novo código será inserido nesse ponto.
Editar o detalhe de ações de teste e de asserções.

UIMap.uitest aberto.Este arquivo é aberto no editor codificado de teste de interface do usuário, onde você pode editar qualquer sequência de ações que você gravou bem como editar suas declarações.

Para obter mais informações, consulte Editing Coded UI Tests Using the Coded UI Test Editor.
Execute o teste.

Use o teste Explorer, ou abra o menu de atalho no método de teste, e então escolha Executar Testes.Para obter mais informações sobre como executar testes, consulte Executando testes de unidade com Test Explorer e opções adicionais para executar testes codificados de interface do usuário na seção de O que mais? no final deste tópico.

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

Para um exemplo mais detalhado, consulte Walkthrough: Creating, Editing and Maintaining a Coded UI Test.Nesta explicação passo a passo, você criará um simples aplicativo Windows Presentation Foundation (WPF) demonstrar como criar, editar, e manter um teste codificado de interface do usuário.A explicação passo a passo fornece soluções para corrigir os testes que foram quebrados por vários problemas de tempo e controlam refatoração.

Inicial e parar o aplicativo no teste

Eu não desejo para iniciar separada e parar meu aplicativo, o navegador, ou banco de dados para cada teste.Como eu evito isso?

Se você não deseja gravar as ações iniciar o aplicativo do teste, você deve iniciar o aplicativo antes que você escolha o ícone de Gravar .
No final de um teste, o processo no qual os ensaios terminam.Se você iniciou o aplicativo no teste, o aplicativo é fechado em geral.Se você não deseja que o teste para fechar o seu aplicativo quando termina, você deve adicionar um arquivo de .runsettings a sua solução e usar a opção de KeepExecutorAliveAfterLegacyRun .Para obter mais informações, consulte Configurando testes de unidade usando um arquivo .runsettings.
Você pode adicionar um teste inicializa o método, identificado pelo atributo de TestInitialize [], que executa o código no início de cada método de teste.Por exemplo, você pode iniciar o aplicativo do método de TestInitialize.
Você pode adicionar um método de limpeza de teste, identificado pelo atributo de TestCleanup [], que executa código do final da cada método de teste.Por exemplo, o método para fechar o aplicativo poderia ser chamado pelo método de TestCleanup.

Validando as propriedades de controles de interface de usuário

Você pode usar Construtor codificado de teste de interface de usuário para adicionar um controle de (UI) de interface do usuário a UIMap para o seu teste, ou para gerar código para um método de validação que use uma declaração para um controle da interface do usuário.

Para gerar asserções para os controles de interface do usuário, escolha a ferramenta de Adicione declarações no construtor codificado de teste de interface de usuário para e arraste-a para o controle no aplicativo no teste que você deseja verificar está correta.Quando a caixa descreve seu controle, libere o mouse.O código de classe do controle é criado imediatamente no arquivo de UIMap.Designer.cs .

Codificado elemento de direcionamento de teste de interface do usuário

As propriedades para esse controle agora estão listadas na caixa de diálogo de Adicione declarações .

Outra maneira de navegação em um controle específico é escolher a seta (<<) para expandir a exibição para Mapa de Controles de IU.Para localizar um pai, irmão, ou controle filho, você pode clicar em qualquer lugar no mapa e usar as teclas de seta para mover o redor da árvore.

Propriedades de teste de interface do usuário codificadas

Eu não consulto nenhuma propriedade quando eu seleciono um controle no my aplicativo, ou eu não ver o controle na interface do usuário controlar o mapa.

No código do aplicativo, o controle que você deseja verificar deve ter um ID exclusivo, como um atributo de identificação HTML, ou um WPF UId.Você pode precisar atualizar o código do aplicativo para adicionar esses identificações.

Em seguida, abrir o menu de atalho na propriedade do controle da interface do usuário que você deseja verificar, aponte para e então Adicione a declaração.Na caixa de diálogo de Adicione a declaração , selecione Comparador para sua declaração, por exemplo AreEqual, e digite um valor para sua declaração no Valor de comparação.

Declarações de teste de interface do usuário codificadas

Quando você adicionou todas as suas declarações para o seu teste, escolha OK.

Para gerar código para suas declarações e adicionar o controle ao mapa de interface do usuário, escolha o ícone de Gerar código .Digite um nome para o método codificado de teste de interface do usuário e uma descrição para o método, que será adicionado como comentários para o método.Escolha Adicione e gere.Em seguida, clique no ícone de Fechar para fechar Construtor codificado de teste de interface de usuário.Isso gera código semelhante ao seguinte código.Por exemplo, se o nome que você inseriu é AssertForAddTwoNumbers, o código terá o aspecto como neste exemplo:

Adiciona uma chamada para o método AssertForAddTwoNumbers declarar o método de teste em seu arquivo codificado de teste de interface de usuário:
```
      [TestMethod]
      public void CodedUITestMethod1()
      {
          this.UIMap.AddTwoNumbers();
          this.UIMap.AssertForAddTwoNumbers();
      }
```
Você pode editar este arquivo para alterar a ordem das etapas e das declarações, ou criar novos métodos de teste.Para adicionar mais código, coloque o cursor no método de teste e escolha no menu de atalho Gerar Código para Teste de IU Codificado.
Adiciona um método chamado AssertForAddTwoNumbers ao seu mapa de interface do usuário (UIMap.uitest).Este arquivo é aberto no editor codificado de teste de interface do usuário, onde você pode editar as declarações.

Para obter mais informações, consulte Editing Coded UI Tests Using the Coded UI Test Editor.

Você também pode exibir o código gerado de declaração de método em UIMap.Designer.cs.No entanto, você não deve editar o arquivo.Se você desejar tornar uma versão adaptada de código, copiar os métodos para outro arquivo como UIMap.cs, renomeie os métodos, e editá-los localmente.
```
      public void AssertForAddTwoNumbers()
      {
          ...
      }
```

O controle que desejo para selecionar perde o foco e desaparecerá quando eu tento selecione a ferramenta de asserções adicionar o construtor codificado de teste de interface do usuário. Como eu seleciono o controle?

Selecionando um controle hidden usando o teclado

Às vezes, quando adicionando controles e validar suas propriedades, talvez você precise usar o teclado.Por exemplo, quando você tentar gravar um teste codificado de interface do usuário que usa um controle menu de contexto, a lista de itens de menu no controle perderá o foco e desaparecerá quando você tenta selecione a ferramenta de asserções adicionar o construtor codificado de teste de interface do usuário.Isso é demonstrado na ilustração a seguir, onde o menu de contexto no Internet Explorer perderá o foco e desaparecerá se você tentar selecione o com a ferramenta de asserções adicionar.

CodedUITest_SelectControlKeyboard

Para usar o teclado para selecionar um controle da interface do usuário, passa sobre o controle com o mouse.Pressionar a tecla de Ctrl e a chave de I ao mesmo tempo.Liberar as chaves.O controle é identificado pelo construtor codificado de teste de UT.

Cuidado
Se você usar o Microsoft Lync, você deve fechar Lync antes de iniciar o construtor codificado de teste de interface do usuário.Microsoft Lync interfere com o atalho de teclado Ctrl+I .

Eu não consigo registrar um foco do mouse em um controle. Há uma maneira redor desse?

Gravando manualmente pairos do mouse

Em algumas circunstâncias, um controle específico que foi usado em um teste codificado de interface do usuário pode exigir que você usar o teclado para registrar manualmente eventos de foco do mouse.Por exemplo, quando você testar um formulário do Windows ou um aplicativo Windows Presentation Foundation (WPF), pode haver um código personalizado.Ou, pode haver um comportamento especial definido focalizando sobre um controle, como um nó de árvore que expande quando um usuário passa sobre ele.Para testar condições como estes, você terá que manualmente notificar o construtor codificado de teste de interface do usuário que você está sobre o controle pressionando as teclas de teclado predefinidos.

Quando você executar o seu teste codificado de interface do usuário, foco no controle.Então pressione e segure a tecla CTRL, quando você pressiona e manter as teclas SHIFT e do R no teclado.Liberar as chaves.Um evento de foco do mouse é identificado pelo construtor codificado de teste de UT.

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

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

Configurando atribuições do teclado de foco do mouse

Se necessário, a atribuição de teclado padrão de Ctrl+Shift+R que é usado para aplicar o mouse que passa eventos em seus testes codificados de interface do usuário pode ser configurado para usar chaves diferentes.

Cuidado
Você não deve ter que alterar as atribuições do teclado para eventos de foco do mouse em condições comuns.Use cuidados ao reatribuir a atribuição do teclado.Sua escolha pode já estar em uso em outro lugar dentro do Visual Studio ou aplicativo que está sendo testado.

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

<drive letter:>\ arquivo de programa (x) \ Microsoft Visual Studio 11,0 \ Common7 \ IDE \ CodedUITestBuilder.exe.config

No arquivo de configuração, alterar os valores de chaves de HoverKeyModifier e de HoverKey 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 com pairos do mouse de gravação em um site. Há uma correção para isso, muito?

Defina o mouse focaliza implícita para navegador da web

Em muitos sites web, quando você passa sobre um controle específico, expande para mostrar detalhes adicionais.Em geral, esses são como menus em aplicativos desktop.Porque este é um padrão comum, os testes codificados de interface do usuário permitem pairos implícitos para procurar da Web.Por exemplo, se você registra pairos no Internet Explorer, um evento é acionado.Esses eventos podem levar a pairos redundantes obter gravada.Devido a isso, os pairos implícitos são gravados com ContinueOnError definido como true no arquivo de configuração de teste de interface do usuário.Isso permite que a reprodução continue se um evento de foco falhar.

Para ativar a escrita de pairos implícitos em um navegador da Web, abra o arquivo de configuração:

<drive letter:>\ arquivo de programa (x) \ Microsoft Visual Studio 11,0 \ Common7 \ IDE \ CodedUITestBuilder.exe.config

Verifique se o arquivo de configuração principal RecordImplicitiHovers tenha definido como um valor de true conforme mostrado no exemplo o seguir:
```

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

Personalizando seu teste codificado de interface de usuário

Depois de criar o seu teste codificado de interface do usuário, você pode editá-lo usando algumas das ferramentas no Visual Studio:

Uso deConstrutor codificado de teste de interface de usuário: o construtor codificado de teste de interface do usuário adicionar controles e validação adicionais aos testes.Consulte a seção Adicionando controles e validar suas propriedades neste tópico.
Editor codificado de teste de interface de usuário: o editor codificado de teste de interface do usuário permite que você facilmente alterar seus testes codificados de interface do usuário.Usando o editor codificado de teste de interface do usuário, você pode localizar, exibir, editar e seus métodos de teste.Você também pode editar ações de interface do usuário e seus controles associados no mapa de controle da interface do usuário.Para obter mais informações, consulte Editing Coded UI Tests Using the Coded UI Test Editor.
Editor de códigos:
- Adicionar manualmente o código para os controles no seu teste como descrito na seção de Ações e propriedades de controle da interface do usuário de codificação neste tópico.
- Depois de criar um teste codificado de interface do usuário, você pode modificá-lo ser orientado a dados.Para obter mais informações, consulte How to: Create a Data-Driven Coded UI Test.
- Em um reprodução codificado de teste de interface do usuário, você pode instruir o teste para esperar certos eventos para ocorrer, como uma janela para aparecer, barra de progresso a desaparecer, e assim por diante.Para fazer isso, adicione o método apropriado de UITestControl.WaitForControlXXX() .Para obter uma lista completa dos métodos disponíveis, consulte Making Coded UI Tests Wait For Specific Events During Playback.Para um exemplo de interface do usuário codificado testar que as espera para um controle está ativado usando o método de WaitForControlEnabled, consulte Walkthrough: Creating, Editing and Maintaining a Coded UI Test.
- Os testes codificados de interface do usuário incluem suporte para alguns dos controles HTML5 que são incluídos no Internet Explorer 9 e no Internet Explorer 10.Para obter mais informações, consulte Using HTML5 Controls in Coded UI Tests.
- Orientação codificado de codificação de teste de interface de usuário:

O código gerado

Quando você escolhe Gerar código, várias partes de 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.      }
    }
```
Você pode clicar com o botão direito do mouse neste método para adicionar mais ações e verifica registrados.Você também pode estender para editá-lo manualmente ou alterar o código.Por exemplo, você pode incluir qualquer código em um loop.

Você também pode adicionar novos métodos de teste e adicionar-lhes o código da mesma forma.Cada método de teste deve ter o atributo de [TestMethod] .
Um método em UIMap.uitest

Este método inclui o detalhe as ações que você gravou ou o valor que você selecionou.Você pode editar este código abrindo UIMap.uitest.Abre em um editor especializado em que você pode excluir ou refactor as ações registrados.

Você também pode exibir o método gerado em UIMap.Designer.cs.Esse método executa ações que você gravou 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 o arquivo, porque será regenerado quando você cria mais testes.

Você pode fazer versões adaptadas desses métodos para copiar os UIMap.cs.Por exemplo, você poderia fazer uma versão com parâmetros que você poderia chamar um método do 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 que são usados por seu teste.É usado pelo código gerado para operar os controles e para acessar suas propriedades.

Você também pode usá-lo se você escrever seu próprio código.Por exemplo, você pode ter o método de teste escolha um hiperlink em um aplicativo da Web, digite um valor em uma caixa de texto, ou ramificação fora e executar ações diferentes de teste com base em um valor em um campo.

Você pode adicionar várias codificados teste de interface do usuário e vários objetos e arquivos de mapa de interface do usuário para facilitar testar um aplicativo grande.Para obter mais informações, consulte Testing a Large Application with Multiple UI Maps.

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

Para obter mais informações sobre o código gerado, consulte Anatomy of a Coded UI Test.

Ações e propriedades de controle da interface do usuário de codificação

Quando você trabalha com controles de teste de interface do usuário em testes codificados de interface do usuário são separados em duas partes: ações e propriedades.

A primeira parte consiste nas ações que você pode executar em controles de teste de interface do usuário.Por exemplo, os testes codificados de interface do usuário podem simular cliques do mouse em um controle de teste de interface do usuário, ou simular as chaves tipadas no teclado para afetar um controle de teste de interface do usuário.
A segunda parte consiste permite que você obter e definir propriedades em um controle de teste de interface do usuário.Por exemplo, os testes codificados de interface do usuário podem obter a contagem dos itens em ListBox, ou definir CheckBox ao estado selecionado.

Acessando ações do controle de teste de interface de usuário

Para executar ações em controles de teste de interface do usuário, como cliques do mouse ou ações do teclado, usa os métodos nas classes de Mouse e de Keyboard :

Para executar uma ação mouse-over orientada, como um clique do mouse, em um controle de teste de interface do usuário, Clickde uso.

Mouse.Click(buttonCancel);
Para executar uma ação o orientada, como digite em um controle de edição, SendKeysde uso.

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

Acessando propriedades de controle de teste de interface de usuário

Para obter e definir valores de propriedade de controle específicos de interface do usuário, você pode diretamente obter ou definir os valores das propriedades de um controle, ou você pode usar UITestControl.GetProperty e métodos de UITestControl.SetProperty com o nome da propriedade específica que você deseja obtém ou define.

GetProperty retorna um objeto, que pode então ser convertido em Typeapropriado.SetProperty aceita um objeto para o valor da propriedade.

Para obter ou definir propriedades de interface do usuário testar controles diretamente

Com os controles que derivam de T: Microsoft.VisualStudio.TestTools.UITesting.UITestControl, como T: Microsoft.VisualStudio.TestTools.UITesting.HtmlControls.HtmlList ou T: Microsoft.VisualStudio.TestTools.UITesting.WinControls.WinComboBox, você pode obter ou definir seus valores de propriedade diretamente, como segue:
```
int i = myHtmlList.ItemCount;
myWinCheckBox.Checked = true;
```

Para obter propriedades de interface do usuário testar controles

Para obter um valor da propriedade de um controle, use GetProperty.
Para especificar a propriedade do controle para obter, use a cadeia de caracteres apropriada da classe de PropertyNames em cada controle como o parâmetro a GetProperty.
GetProperty retorna o tipo de dados apropriado, mas esse valor de retorno é convertido como Object.Object de retorno deve então ser convertido para o tipo apropriado.

Exemplo:

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

Para definir propriedades para controles de teste de interface de usuário

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

Exemplo:

SetProperty(myWinCheckBox.PropertyNames.Checked, true);

Depuração

Você pode analisar teste codificados de interface do usuário usando logs codificados de teste de interface do usuário.Os logs codificados de teste de interface do usuário filtragem e gravam informações importantes sobre seus ensaios codificados de interface do usuário.O formato de logs permite que você depurar rapidamente problemas.Para obter mais informações, consulte Analyzing Coded UI Tests Using Coded UI Test Logs.

O que mais?

Opções adicionais para executar testes codificados de interface de usuário: você pode executar testes codificados de interface do usuário diretamente do Visual Studio, como descrito anteriormente neste tópico.Além disso, você pode executar testes automatizados de interface de usuário de Microsoft Test Manager, ou de Team Foundation Build.Quando os testes codificados de interface do usuário são automatizados, eles precisam interagir com a área de trabalho quando você executa o, diferentemente de outros testes automatizados.

Adicionando suporte para controles personalizados: interface do usuário codificado que testa a estrutura não suporta cada interface do usuário possível e não pode oferecer suporte a interface do usuário que você deseja testar.Por exemplo, você não pode criar imediatamente um teste codificado de interface de usuário de interface de usuário para Microsoft Excel.No entanto, você pode criar uma extensão a interface do usuário codificado que testa a estrutura que oferecem suporte a um controle personalizado.

Os testes codificados de interface do usuário são geralmente usados para automatizar teste manual.Para obter orientação adicional, consulte Teste para entrega contínuo com Visual Studio 2012 – capítulo 5: Automatizar testes do sistema.Para obter mais informações sobre teste manual, consulte Criando casos de testes manuais por meio do Microsoft Test Manager.Para obter mais informações sobre teste do sistema automatizado, consulte Criando testes automatizados por meio do Microsoft Test Manager.