Partilhar via

Início rápido: desenvolvimento baseado em testes com o Gerenciador de Testes

  • Artigo

Recomendamos que você criar testes de unidade para ajudar a manter seu código de funcionamento muitas etapas incrementais de desenvolvimento.Há várias estruturas que você pode usar para escrever testes de unidade, incluindo alguns desenvolvidos por terceiros.Algumas estruturas de teste são especializadas para testes em plataformas ou idiomas diferentes.Test Explorer fornece uma interface única para testes de unidade em qualquer uma dessas estruturas.Adaptadores estão disponíveis para as estruturas mais comumente usados e você pode escrever seus próprios adaptadores para outras estruturas.

Test Explorer substitui o windows teste de unidade encontrado em edições anteriores do Visual Studio.Seus benefícios incluem:

  • Execute.NET, não gerenciado, banco de dados e outros tipos de testes usando uma única interface.

  • Use a estrutura de teste de unidade de sua escolha, como NUnit ou estruturas MSTest.

  • Consulte as informações que você normalmente precisa em uma janela.Mais detalhes podem ser encontrados na Propriedades janela.

Usando o Explorer de teste

Para executar testes de unidade usando o Explorer de teste

  1. Crie testes de unidade que usam estruturas de teste de sua escolha.

    Por exemplo, para criar um teste que usa o MSTest Framework:

    1. Crie um projeto de teste.

      No Novo projeto caixa de diálogo caixa, expanda Visual Basic, Visual C#, ou **Visual C++**e escolha teste.

      Selecione projeto de teste de unidade.

    2. Cada teste de unidade de gravação como um método.Prefixo de cada método de teste com o [TestMethod] atributo.

  2. Na barra de menu, escolha teste, Executar testes de unidade, Todos os testes.

    Cria a solução e os testes executados.

    Explorer de teste abre e exibe um resumo dos resultados.

Para ver uma lista completa de testes: escolha Mostrar tudo em qualquer categoria.

Para retornar para o resumo, escolha o HOME modo de exibição.

Para ver os detalhes de um resultado de teste: selecionar o teste em Test Explorer.Detalhes, como mensagens de exceção são exibidos no painel de detalhes.Você também pode ver mais detalhes na janela Propriedades.

Para navegar para o código de um teste: duas vezes no teste em Test Explorer ou escolha Abrir Test no menu de atalho.

Para depurar um teste: abrir o menu de atalho para um ou mais testes e escolha Depurar testes selecionados.

Observação importanteImportante

Os resultados são exibidos para o mais recente executados.A barra colorida resultados mostra somente os resultados de testes que executei.Por exemplo, se você executar vários testes e alguns deles falharem e executar apenas os testes bem-sucedidos, na barra de resultados mostrará todos verde.
ObservaçãoObservação

Se nenhum teste for exibido, certifique-se de que você tenha instalado um adaptador para conectar Test Explorer para o framework de teste que você está usando.Para obter mais informações, consulte Usando diferentes estruturas de teste com Test Explorer.

Passo a passo: Usando testes de unidade para desenvolver um método

Esta explicação passo a passo demonstra como desenvolver um método testado em C# usando a estrutura de teste de unidade de Microsoft.Você pode facilmente adaptá-lo para outros idiomas e usar outras estruturas de teste como o NUnit.Para obter mais informações, consulte Usando diferentes estruturas de teste.

Criando o teste e o método

  1. Crie um projeto de biblioteca de classes do Visual C#.Este projeto irá conter o código que desejamos oferecer.Neste exemplo, é denominado MyMath.

  2. Crie um projeto de teste.

    • No Novo projeto caixa de diálogo, escolha Visual C#, teste e escolha Projeto de teste de unidade.

      Novos projetos de código e teste

  3. Escreva um método de teste básico.Verifique se o resultado obtido de uma entrada específica:

      [TestMethod]
  public void BasicRooterTest()
  {
    // Create an instance to test:
    Rooter rooter = new Rooter();
    // Define a test input and output value:
    double expectedResult = 2.0;
    double input = expectedResult * expectedResult;
    // Run the method under test:
    double actualResult = rooter.SquareRoot(input);
    // Verify the result:
    Assert.AreEqual(expectedResult, actualResult,
        delta: expectedResult / 100);
  }

  4. Gere o método do teste.

    1. Coloque o cursor em Rootere, em seguida, no menu de atalho, escolha gerar, Novo tipo de.

    2. No Gerar novo tipo de caixa de diálogo, definir projeto para o projeto de biblioteca de classe.Neste exemplo, é MyMath.

    3. Coloque o cursor em SquareRoote, em seguida, no menu de atalho, escolha gerar, Método Stub.

  5. Execute o teste de unidade.

    • Sobre o teste menu, escolha Executar testes de unidade, Todos os testes.

      A solução é compilada e executada.

      Explorer de teste abre e exibe os resultados.

      O teste aparece sob Falha testes.

  6. Selecione o nome do teste.

    Os detalhes do teste aparecem na parte inferior do Explorer de teste.

  7. Selecione os itens do Rastreamento de pilha para ver onde o teste falhou.

Teste de unidade Test Explorer mostrando falhou.

Neste ponto, você criou um teste e um stub que irá modificar para que o teste passar.

Após cada alteração, faça todos os testes passar

  1. Em MyMath\Rooter.cs, melhorar o código de SquareRoot:

     public double SquareRoot(double input)
  {
    return input / 2;
  }

  2. No Explorer do teste, escolha Executar todas as.

    O código compila e executa o teste.

    Passa o teste.

    Unidade Test Explorer mostrando um teste de passagem.

Adicionar testes para estender o intervalo de entradas

  1. Para aumentar sua confiança que seu código funciona em todos os casos, adicione testes tente uma variedade maior de valores de entrada.

    DicaDica

    Evite alterar testes existentes que passam.Em vez disso, adicione novos testes.Altere testes existentes somente quando alterar os requisitos de usuário.Esta diretiva ajuda a garantir que você não perderá a funcionalidade existente enquanto você trabalha para estender o código.

    Na classe de teste, adicione o seguinte teste tenta um intervalo de valores de entrada:

      [TestMethod]
  public void RooterValueRange()
  {
    // Create an instance to test:
    Rooter rooter = new Rooter();
    // Try a range of values:
    for (double expectedResult = 1e-8;
        expectedResult < 1e+8;
        expectedResult = expectedResult * 3.2)
    {
      RooterOneValue(rooter, expectedResult);
    }
  }

  private void RooterOneValue(Rooter rooter, double expectedResult)
  {
    double input = expectedResult * expectedResult;
    double actualResult = rooter.SquareRoot(input);
    Assert.AreEqual(expectedResult, actualResult,
        delta: expectedResult / 1000);
  }

  2. No Explorer do teste, escolha Executar todas as.

    O novo teste falha, embora ainda passa o primeiro teste.

    Para localizar o ponto de falha, selecione o teste falhar e na parte inferior do Test Explorer, selecione o item superior da O rastreamento de pilha.

  3. Inspecione o método de teste para ver o que pode estar errado.No MyMath.Rooter classe, reescrever o código:

      public double SquareRoot(double input)
  {
    double result = input;
    double previousResult = -input;
    while (Math.Abs(previousResult - result) > result / 1000)
    {
      previousResult = result;
      result = result - (result * result - input) / (2 * result);
    }
    return result;
  }

  4. No Explorer do teste, escolha Executar todas as.

    Ambos os testes agora passarem.

Adicionar testes para casos excepcionais

  1. Adicione um teste para entradas negativas:

           [TestMethod]
        public void RooterTestNegativeInputx()
        {
            Rooter rooter = new Rooter();
            try
            {
                rooter.SquareRoot(-10);
            }
            catch (ArgumentOutOfRangeException e)
            {
                return;
            }
            Assert.Fail();
        }

  2. No Explorer do teste, escolha Executar todas as.

    O método sob teste loops e deve ser cancelado manualmente.

  3. Escolha Cancelar.

    O teste pára após 10 segundos.

  4. Corrigi o código do método:

      public double SquareRoot(double input)
  {
    if (input <= 0.0) 
    {
      throw new ArgumentOutOfRangeException();
    } 
  ...

  5. No Explorer do teste, escolha Executar todas as.

    Todos os testes foram bem-sucedidos.

Refatorar sem alterar os testes

  1. Simplificar o código, mas não alterar os testes.

    DicaDica

    A refatoração é uma alteração que é projetada para tornar o código executar melhor ou para tornar o código mais fácil de entender.Não se destina a alterar o comportamento do código e, portanto, os testes não são alterados.

    Recomendamos que você execute etapas refatoração separadamente das etapas que estendem a funcionalidade.Manter os testes inalterados dá confiança que não acidentalmente introduziu bugs durante a refatoração.

    		 
      public class Rooter
  {
    public double SquareRoot(double input)
    {
      if (input <= 0.0) 
      {
        throw new ArgumentOutOfRangeException();
      }
      double result = input;
      double previousResult = -input;
      while (Math.Abs(previousResult - result) > result / 1000)
      {
        previousResult = result;
        result = (result + input / result) / 2;
        //was: result = result - (result * result - input) / (2*result);
      }
      return result;
    }
  }

  2. Escolha executar todas as.

    Ainda passaram todos os testes.

    Unidade Test Explorer mostrando 3 testes que passaram.