Introdução ao teste de unidade

Use o Visual Studio para definir e executar testes unitários para manter a saúde do código, garantir a cobertura do código e encontrar erros e falhas antes dos seus clientes. Faz testes unitários com frequência para garantir que o teu código está a funcionar corretamente.

Neste artigo, o código utiliza C# e C++, as ilustrações estão em C#, mas os conceitos e funcionalidades aplicam-se às linguagens .NET, C++, Python, JavaScript e TypeScript.

Criar testes de unidades

Esta secção descreve como criar um projeto de teste unitário.

1. Abre o projeto que queres testar no Visual Studio.

   Para efeitos de demonstração de um teste unitário de exemplo, este artigo testa um simples projeto de consola "Hello World" em C# ou C++ chamado HelloWorld. O código de exemplo para tal projeto é o seguinte:

   .NET

   namespace HelloWorld
   {
      public class Program
      {
         public static void Main()
         {
            Console.WriteLine("Hello World!");
         }
      }
   }
   

   C++

   #include <iostream>
   
   int main()
   {
      std::cout << "Hello World!\n";
   }
   

2. No Explorador de Soluções, selecione o nó da solução. Depois, na barra de menu superior, selecione Ficheiro>Adicionar>Novo Projeto.

3. Na caixa de diálogo do novo projeto, encontre o projeto de teste unitário a usar.

   Escreva test na caixa de pesquisa para encontrar um modelo de projeto de teste unitário para o framework de teste que pretende usar, como MSTest (C#) ou o projeto Native Unit Test (C++), e selecione-o.

   A partir da versão 14.8 do Visual Studio 2017, as linguagens .NET incluem templates incorporados para NUnit e xUnit. Para C++, neste exemplo selecione o projeto Native Unit Test , que utiliza o Microsoft Native Unit Test Framework. (Para usar um framework de testes C++ diferente, veja Escrever testes unitários para C/C++). Para Python, veja Configurar testes unitários em código Python para configurar o seu projeto de teste.

   Sugestão

   Para C# apenas, podes criar projetos de teste unitário a partir de código usando um método mais rápido. Para mais informações, consulte Criar projetos de teste unitário e métodos de teste. Para usar esse método com o .NET Core ou .NET Standard, é necessário o Visual Studio 2019 ou posterior.

   A ilustração seguinte mostra um teste unitário MSTest, que é suportado em .NET.

   

   Clica em Próximo, escolhe o nome do projeto de teste e depois clica em Criar.

   O projeto é adicionado à sua solução.

   

4. No projeto de teste unitário, adicione uma referência ao projeto que pretende testar clicando com o botão direito em Referências ou Dependências e depois escolhendoAdicionar Referência ou Adicionar Referência do Projeto.

5. Selecione o projeto que contém o código que vai testar e clique em OK.

   

6. Adicione código ao método de teste unitário.

   Por exemplo, pode usar o seguinte código selecionando o separador de documentação correto que corresponda ao seu framework de teste: MSTest, NUnit ou xUnit (suportado apenas em .NET), ou Microsoft Native Unit Test Framework em C++.

   MSTest

   using Microsoft.VisualStudio.TestTools.UnitTesting;
   using System.IO;
   using System;
   
   namespace HelloWorldTests
   {
      [TestClass]
      public class UnitTest1
      {
         private const string Expected = "Hello World!";
         [TestMethod]
         public void TestMethod1()
         {
            using (var sw = new StringWriter())
            {
               Console.SetOut(sw);
               HelloWorld.Program.Main();
   
               var result = sw.ToString().Trim();
               Assert.AreEqual(Expected, result);
            }
         }
      }
   }
   

   NUnit

   using NUnit.Framework;
   using System.IO;
   using System;
   
   namespace HelloWorldTests
   {
      public class Tests
      {
         private const string Expected = "Hello World!";
   
         [SetUp]
         public void Setup()
         {
         }
         [Test]
         public void TestMethod1()
         {
            using (var sw = new StringWriter())
            {
               Console.SetOut(sw);
               HelloWorld.Program.Main();
   
               var result = sw.ToString().Trim();
               Assert.AreEqual(Expected, result);
            }
         }
      }
   }
   

   xUnidade

   using System;
   using Xunit;
   using System.IO;
   
   namespace HelloWorldTests
   {
       public class UnitTest1
       {
           private const string Expected = "Hello World!";
           [Fact]
           public void Test1()
           {
               using (var sw = new StringWriter())
               {
                   Console.SetOut(sw);
                   HelloWorld.Program.Main();
   
                   var result = sw.ToString().Trim();
                   Assert.Equal(Expected, result);
               }
           }
       }
   }
   

   Framework de Testes Unitários Nativos da Microsoft

   #include "pch.h"
   #include "CppUnitTest.h"
   #include "../HelloWorldUnitTestCPP/HelloWorldUnitTestCPP.cpp"   // Update using your project name
   
   using namespace Microsoft::VisualStudio::CppUnitTestFramework;
   
   namespace HelloWorldTests
   {
      TEST_CLASS(HelloWorldTests)
      {
      public:
   
         TEST_METHOD(TestMethod)
         {
            std::string expected = "Hello World!\n";
   
            std::stringstream buffer;
            std::streambuf* sbuf = std::cout.rdbuf(); // Save cout's buffer
            std::cout.rdbuf(buffer.rdbuf()); // Redirect cout to the stringstream buffer
   
            // Call main() in your test
            int result = main();
   
            // When finished, redirect cout to the original buffer 
            std::cout.rdbuf(sbuf);
            std::cout << "std original buffer: \n";
            std::cout << buffer.get();
   
            // Test
            Assert::AreEqual(expected, buffer.str());
         }
      };
   }
   

Executar testes de unidade

1. Abra o Gerenciador de Testes.

   Para abrir o Explorador de Testes, escolha Explorador de Testes> de Teste na barra de menu superior (ou pressione Ctrl + , T).

2. Executa os teus testes unitários clicando em Executar Tudo (ou carrega em Ctrl + R, V).

   

   Após a conclusão dos testes, um visto verde indica que o teste foi aprovado. Um ícone vermelho com "x" indica que um teste falhou.

   

Sugestão

Pode usar o Test Explorer para executar testes unitários a partir do framework de teste incorporado (MSTest) ou de frameworks de teste de terceiros. Podes agrupar os testes em categorias, filtrar a lista de testes e criar, guardar e executar listas de reprodução de testes. Também pode depurar testes e analisar o desempenho dos testes e a cobertura do código.

Ver resultados de testes unitários ao vivo (Visual Studio Enterprise)

Se estiveres a usar o framework de testes MSTest, xUnit ou NUnit no Visual Studio 2017 ou posterior, podes ver resultados em tempo real dos teus testes unitários.

Observação

Para seguir estes passos, é necessário o Visual Studio Enterprise, juntamente com código .NET e um dos seguintes frameworks de teste: MSTest, xUnit ou NUnit.

1. Ativar os testes unitários ao vivo no menu de Teste escolhendo Teste>Testes Unitários ao Vivo>Iniciar.

   

2. Veja os resultados dos testes dentro da janela do editor de código enquanto escreve e edita código.

   

3. Clique num indicador de resultado de teste para ver mais informações, como os nomes dos testes que cobrem esse método.

   

Para mais informações sobre testes unitários ao vivo, consulte Testes unitários ao vivo.

Utilize um framework de teste de terceiros

Pode executar testes unitários no Visual Studio usando frameworks de teste de terceiros como NUnit, Boost ou Google C++ Testing Framework, dependendo da sua linguagem de programação. Para usar um framework de terceiros:

• Use o Gestor de Pacotes NuGet para instalar o pacote NuGet para a framework que preferir.

• (.NET) A partir da versão 14.6 do Visual Studio 2017, o Visual Studio inclui modelos pré-configurados de projetos de teste para frameworks de teste NUnit e xUnit. Os modelos incluem também os pacotes NuGet necessários para permitir o suporte.

• (C++) No Visual Studio 2017 e versões posteriores, alguns frameworks como o Google C++ Testing Framework já estão incluídos. Para mais informações, consulte Escrever testes unitários para C/C++ no Visual Studio.

Para adicionar um projeto de teste unitário:

1. Abre a solução que contém o código que queres testar.

2. Clique com o botão direito do mouse na solução no Gerenciador de Soluções e escolha Adicionar>Novo Projeto.

3. Selecione um modelo de projeto de teste unitário.

   Neste exemplo, selecione NUnit

   

   O modelo do projeto inclui referências NuGet ao NUnit e ao NUnit3TestAdapter.

   

4. Adiciona uma referência do projeto de teste ao projeto que contém o código que queres testar.

   Clique com o botão direito no projeto no Explorador de Soluções e depois selecione Adicionar>Referência. (Também pode adicionar uma referência a partir do menu do botão direito do elemento Referências ou Dependências.)

5. Adicione código ao seu método de teste.

   

6. Execute o teste a partir do Explorador de Testes ou clicando com o botão direito no código do teste e escolhendo Executar Testes(s) (ou Ctrl + R, T).

Próximos passos

Noções básicas de teste de unidade

Criar e executar testes unitários para código gerido

Escrever testes de unidade para C/C++