Demonstra Passo a passo: Criar e executar testes de unidade

  • Artigo

Esta explicação passo irá guiá para criar, executar e personalizar uma série de testes usando Microsoft Visual Studio 2010. Inicie um projeto C# que está em desenvolvimento, crie testes que exercitem seu código, execute os testes e examine os resultados. Em seguida, você pode alterar seu código do projeto e executar novamente os testes.

ObservaçãoObservação

Para obter informações sobre como executar testes a partir de uma linha de comando, consulte Demonstra Passo a passo: Usando o utilitário de teste de linha de comando.

Nesta explicação passo a passo, você irá concluir as seguintes tarefas:

  • Preparar um projeto " conta bancária " para usar em um passo a passo.

  • Abrir um projeto existente.

  • Criar testes de unidade para métodos públicos e privados.

  • Execute esses testes no código.

  • Localizar e corrigir erros em testes.

  • Localizar e corrigir erros no código.

Pré-requisitos

Preparar o passo a passo

Para preparar o passo a passo

  1. Abra Visual Studio 2010 Premium.

  2. No menu File, aponte para New e clique Project.

    A caixa de diálogo New Project será exibida.

  3. Em Modelos instalados, clique em Visual C#.

  4. Na lista de tipos de aplicativos, clique em Biblioteca de classe.

  5. No nome , digite Bank e, em seguida, clique em OK.

    ObservaçãoObservação

    Se o nome " Bank " já estiver sendo usado, escolha outro nome para o projeto.

    O novo projeto Bank é criado e exibido no Solution Explorer, com o arquivo Class1. cs, aberto no Editor de código.

    ObservaçãoObservação

    Se o arquivo Class1. cs não estiver aberto no Editor de código, clique duas vezes no arquivo Class1. cs no Solution Explorer para abri-lo.

  6. Copie o código fonte a partir do Projeto de exemplo para criar testes de unidade.

  7. Substitua o conteúdo original de Class1. cs com o código a partir de Projeto de exemplo para criar testes de unidade.

  8. Sobre o Build menu, clique em Build Solution.

Agora você tem um projeto denominado Bank. Ele contém o código-fonte para teste e ferramentas para testá-lo. O espaço de nomes de Bank, BankAccountNS, contém a classe pública BankAccount, cujos métodos você testará nos procedimentos a seguir.

Criar um teste de unidade

Obrigatório: Siga as etapas no procedimento, o passo a passo de preparação.

Para criar um teste de unidade

  1. Se o arquivo Class1. cs não estiver aberto no Editor de código, no Solution Explorer, clique duas vezes no arquivo Class1. cs no projeto Bank.

  2. No BankAccount da classe no arquivo Class1. cs, role até o Debit () método.

  3. Com o botão direito do Debit () método e selecione Create Unit Tests.

    O Create Unit Tests caixa de diálogo é exibida.

    Em Current selection, uma estrutura de árvore mostra a hierarquia de classe e membro da montagem que abriga a classe BankAccount. Você pode usar esta página para gerar testes de unidade para qualquer seleção desses membros, e para escolher um projeto teste que você deseje gerar os testes de unidade para ser inseridos.

    Na estrutura de árvore, somente o método Debit() é selecionado. Deixe-o selecionado e também selecione o método Credit().

  4. Para Output project, selecione criar um novo projeto teste Visual C#.

  5. Clique em Settings.

    A caixa de diálogo Test Generation Settings aparece. Em Naming settings, você pode alterar a maneira como arquivos de teste, classes de teste e métodos de teste são nomeados bem como eles são gerados. Em General, você pode alterar outros aspectos da geração de testes. Deixe os valores padrão para essas configurações e clique OK.

  6. No Create Unit Tests caixa de diálogo, clique em OK.

    A caixa de diálogo New Test Project é exibida.

  7. Aceite o nome padrão e clique Create.

    Isto cria um projeto denominado TestProject1, que é exibido no Solution Explorer.

    Um arquivo chamado BankAccountTest.cs, que contém uma classe de teste é adicionado à TestProject1. A classe é preenchida com uma propriedade TestContext e métodos para testar o Debit () e Credit () métodos.

    ObservaçãoObservação

    Cada método de teste é automaticamente atribuído a TestMethod () atributo. Cada teste corresponde a um único método no código sob teste você deseja testar. Métodos de teste são abrigados em uma classe de teste que é atribuída a TestClass () atributo.

  8. No BankAccountTest.cs, especifique valores para as variáveis a serem testadas. Role até o DebitTest método, onde você pode ver // TODO linhas que indicam variáveis para o conjunto.

  9. Para saber quais valores de usar para o método DebitTest, abra o arquivo Class1. cs e role para a principal método. Observe que o nome do cliente é inicializado para SR. Bryan Walton, o saldo da conta é inicializado para 11.99, o crédito método é chamado com um parâmetro de 5,77e o débito método é chamado com um parâmetro de 11.22. Portanto, se esta conta inicia com uma Saldo de 11.99, uma chamada para o débito método durante a passagem 11.22 devem dar a você uma nova Saldo de 0.77.

    ObservaçãoObservação

    Você o usará esperado Saldo valor (0.77), posteriormente nesta explicação passo a passo.

  10. No arquivo BankAccountTest.cs, role até o DebitTest método.

  11. Defina os seguintes valores:

    BankAccount target = new BankAccount("Mr. Bryan Walton", 11.99);
double amount = 11.22;

  12. No CreditTest método, adicione "Mr. Bryan Walton", 11.99) para o novo BankAccount.

  13. Salve o arquivo BankAccountTest.cs.

Você criou um arquivo de código-fonte que contém testes para o projeto Bank. Agora você está pronto para executar os testes na classe BankAccountTest no código do projeto Bank.

Executar e personalizar um teste unidade

Obrigatório: Execute as etapas do procedimento criar um teste de unidade.

Para executar e personalizar um teste unidade

  1. Sobre o teste menu, clique em Windows e selecione Test View.

    É exibida a janela Test View.

  2. Com o botão direito DebitTest e clique em Run Selection.

    Se o Resultados de teste janela já não estiver aberta, ela abrirá agora. O teste DebitTest é executado.

    No resultado coluna o Test Results janela, o status do teste é exibido como executando enquanto o teste é executado. Após a execução do teste terminar, o resultado do teste é alterado para Inconclusive.

  3. No Test Results janela, clique com o botão direito na linha que representa o teste e, em seguida, clique em View Test Results Details.

  4. No Test Results Details de página, não há mensagem de erro "Assert. Inconclusive falhou. Um método que não retorna um valor não pode ser verificado. " Para trabalhar para criar um teste bem-sucedido, inicie localizando e avaliando essa a instrução Assert.

  5. Para localizar o método de teste que contém o Assert abrir o arquivo de BankAccountTest.cs de instrução e role para a DebitTest () método.

  6. A instrução Assert está na última linha do método DebitTest. Ela é lida da seguinte forma:

    Assert.Inconclusive("A method that does not return a value cannot be verified.");

    Comentário sem a instrução Assert.

  7. Se você executou o teste agora, ele deve gerar um resultado Passed, mas somente porque ele testado para nada. Você deve adicionar código que testem para resultados esperados. Adicione a instrução a seguir para o final do método DebitTest:

    Assert.AreEqual((System.Convert.ToDouble(0.77)), target.Balance, 0.05);

    Esta instrução compara o resultado esperado (0.77) com o resultado atual de uma chamada para o método Balance da classe BankAccount. Se os dois valores são diferentes, Assert retorna False, que faz o teste falhar.

    ObservaçãoObservação

    Essa instrução Assert inclui um terceiro parâmetrodelta,. com um valor de 0,05. O parâmetro delta é necessário nessa sobrecarga da Assert. AreEqual método; Ele compensa o erro de arredondamento intrínseco de tipos de ponto flutuante, como Doubles.

Você tem de executar o método DebitTest gerado de sua classe de teste BankAccountTest, indicado que ele precisava de alterações, e fez estas alterações. Ela agora está pronto para testar com precisão o método Debit de seu aplicativo.

Executar um teste de unidade e corrigir seu código

Obrigatório: Execute as etapas do procedimento Executar e personalizar um teste de unidade.

Para executar um teste unidade e corrigir seu código

  1. Execute o teste Debit novamente: No arquivo BankAccountTest.cs, clique com o botão direito do DebitTest () método e clique Executar testes.

    Na coluna Result na janela Test Results, o estado do teste é exibido como Running enquanto o teste está sendo executado. Após o teste em execução terminar, o resultado do teste é alterado para Failed.

  2. Na janela Test Results, clique com o botão direito na linha que representa o teste e, em seguida, clique em View Test Results Details.

    Isso abre o teste de página de detalhes dos resultados, que exibe a mensagem de erro "Assert. AreEqual falhou. Esperada uma diferença não maior que <0.05> entre o valor esperado <0.77> e o valor real <23.21> ". Esses números parecem indicar uma operação matemática defeituosa. Como o método DebitTest da classe BankAccountTest testa o método Debit da classe BankAccount, inicie verificando o método Debit.

  3. Abra o arquivo Class1. cs e role para a débito método.

  4. Observe a atribuição a seguir:

    m_balance += amount;

    Esta atribuição adiciona uma quantidade à um saldo quando, em um método Debit, ele deveria ser subtraído. Altere essa linha para a seguinte forma:

    m_balance -= amount;

  5. Execute o teste Debit novamente.

    A coluna Result da janela Test Results exibe Passed para DebitTest.

    ObservaçãoObservação

    Você não tinha reconstruir o projeto de teste depois de alterar o código-fonte porque executar um teste silenciosamente constrói o projeto.

Você criou um teste de unidade que funciona e, através dele, encontrou e corrigiu um erro em seu código.

Criar e executar um teste de unidade para um método privado

Obrigatório: Execute as etapas no procedimento, executar um teste de unidade e corrigir seu código.

Para criar e executar um teste de unidade para um método privado

  1. Abra o arquivo Class1. cs no projeto Bank.

  2. Com o botão direito do FreezeAccount() método e selecione Create Unit Tests.

    Isso exibe o Create Unit Tests caixa de diálogo.

    Na estrutura de árvore exibida, apenas o FreezeAccount() método é selecionado.

  3. (Opcional) Clique em filtroe desmarque itens da exibição pública não. Observe que o FreezeAccount() método é removido da lista de métodos de filho da classe BankAccount. Clique em filtro novamente e selecione itens da exibição pública não para exibir o FreezeAccount() método.

  4. Certifique-se de que o FreezeAccount() método está selecionada e clique em OK.

    Isso cria um novo arquivo do acessador particular é denominado Bank.accessor. Ele contém métodos acessadores especiais que o teste usa indiretamente chamar métodos particulares na classe BankAccount. Você pode ver o novo arquivo exibido no Solution Explorer na pasta de referências de teste.

  5. Abra o arquivo de BankAccountTest.cs e vá até o FreezeAccountTest() método.

  6. Alterar o código da FreezeAccountTest() método para que ele lê como segue. As áreas de novas ou alteradas são indicadas:

    public void FreezeAccountTest()
{
    BankAccount_Accessor target = new BankAccount_Accessor("Mr. Bryan Walton", 11.99); // TODO: Initialize to an appropriate value
target.FreezeAccount(); 
    // Assert.Inconclusive("A method that does not return a value cannot be verified.");
    
    bool creditAccount = false; // False means account could be credited: Fail test. 
    // Try to credit account
    try
    {
        target.Credit(1.00); 
    }
    catch (System.Exception)
    {
        // Threw exception. FreezeAccount worked correctly: Pass test. 
        creditAccount = true;
    }
    
    // Assert fails if 'creditAccount' condition is false. Fail test.
    Assert.IsTrue(creditAccount, "Was able to credit account.");
}

  7. Execute o FreezeAccountTest de teste.

    No resultado coluna na janela Test Results, o status do teste final é exibido como Passed. Este é o resultado esperado porque o teste é chamado de Credit () método após congelar a conta chamando o FreezeAccount() método.

Você adicionou um método privado, criou um novo de teste unidade para ele e executou o teste. Você pode executá-lo outras vezes, usando os outros valores limites, como 15.00, para o balance variável.

Próximas etapas

Quando você executa testes no código em um assembly, você pode ver a proporção de código do projeto que está sendo testado, coletando dados de cobertura de código. Para obter mais informações, consulte Demonstra Passo a passo: Executar testes e exibir cobertura código.

Você pode executar testes em uma linha de comando em vez de em Visual Studio. Para obter mais informações, consulte Demonstra Passo a passo: Usando o utilitário de teste de linha de comando.

Se você estiver usando Visual Studio 2010 Ultimate, você pode criar testes de carga para isolar problemas de stress and performance usando os testes de unidade.

Demonstra Passo a passo: Criando e executando um teste de carga que contém os testes de unidade

Consulte também

Tarefas

Projeto de exemplo para criar testes de unidade