Introdução ao teste de unidade

Use o Visual Studio para definir e executar testes de unidade para manter a integridade do código, garantir a cobertura do código e encontrar erros e falhas antes dos clientes. Execute os testes de unidade com frequência para verificar se o código está funcionando corretamente.

Neste artigo, o código usa C# e C++, as ilustrações estão em C#, mas os conceitos e recursos se aplicam a linguagens .NET, C++, Python, JavaScript e TypeScript.

Criar testes de unidade

Esta seção descreve como criar um projeto de teste de unidade.

Abra o projeto que você deseja testar no Visual Studio.

Para demonstrar um exemplo de teste de unidade, este artigo testa um projeto simples do Console C# ou C++ "Hello World" chamado HelloWorld. O código de exemplo para esse projeto é o seguinte:
- .NET
- C++
```
namespace HelloWorld
{
   public class Program
   {
      public static void Main()
      {
         Console.WriteLine("Hello World!");
      }
   }
}
```
```
#include <iostream>

int main()
{
   std::cout << "Hello World!\n";
}
```
No Gerenciador de Soluções, selecione o nó da solução. Em seguida, na barra de menus superior, selecioneAdicionar>Arquivo>Novo Projeto.
Na caixa de diálogo novo projeto, localize o projeto de teste de unidade que deseja usar.

Digite o teste na caixa de pesquisa para localizar um modelo de projeto de teste de unidade para a estrutura de teste que você deseja usar, como MSTest (C#) ou o projeto de Teste de Unidade Nativa (C++) e selecione-o.

A partir do Visual Studio 2017 versão 14.8, os idiomas do .NET incluem modelos internos para NUnit e xUnit. Para C++, neste exemplo, selecione o projeto de Teste de Unidade Nativa , que usa o Microsoft Native Unit Test Framework. (Para usar uma estrutura de teste do C++ diferente, consulte Escrevendo testes de unidade para C/C++). Para Python, consulte Configurar o teste de unidade no código python para configurar seu projeto de teste.

Dica

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

A ilustração a seguir mostra um teste de unidade MSTest, que tem suporte no .NET.

Clique em Avançar, escolha um nome para o projeto de teste e clique em Criar.

O projeto é adicionado à sua solução.
No projeto de teste de unidade, adicione uma referência ao projeto que você deseja testar clicando com o botão direito do mouse em Referências ou Dependências e escolhendo Adicionar Referência ou Adicionar Referência de Projeto.
Selecione o projeto que contém o código que você testará e clicará em OK.

Adicione código ao método de teste de unidade.

Por exemplo, você pode usar o código a seguir selecionando a guia de documentação correta que corresponde à sua estrutura de teste: MSTest, NUnit ou xUnit (com suporte apenas no .NET) ou C++ Microsoft Native Unit Test Framework.

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);
         }
      }
   }
}

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);
         }
      }
   }
}

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);
            }
        }
    }
}

#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

Abra o Gerenciador de Testes.

Para abrir o Gerenciador de Testes, escolha oGerenciador de > na barra de menus superior (ou pressione Ctrl + E, T).
Execute os testes de unidade clicando em Executar Tudo (ou pressione Ctrl + R, V).

Após a conclusão dos testes, uma marca de seleção verde indica que um teste foi aprovado. Um ícone vermelho "x" indica que um teste falhou.

Dica

Você pode usar o Gerenciador de Testes para executar testes de unidade da MSTest (estrutura de teste interna) ou de estruturas de teste de terceiros. Você pode agrupar testes em categorias, filtrar a lista de testes e criar, salvar e executar playlists de testes. Você também pode depurar testes e analisar o desempenho dos testes e a cobertura de código.

Exibir resultados de teste de unidade ao vivo (Visual Studio Enterprise)

Se você estiver usando a estrutura de teste MSTest, xUnit ou NUnit no Visual Studio 2017 ou posterior, poderá ver os resultados dinâmicos dos testes de unidade.

Observação

Para seguir estas etapas, o Visual Studio Enterprise é necessário, juntamente com o código .NET e uma das seguintes estruturas de teste: MSTest, xUnit ou NUnit.

Ative o teste de unidade ao vivo no menu Teste escolhendo Teste>Unidade Dinâmica>Iniciar.
Exiba os resultados dos testes na janela do editor de código enquanto você escreve e edita código.
Clique em um indicador de resultado de teste para ver mais informações, como os nomes dos testes que abrangem esse método.

Para obter mais informações sobre o teste de unidade ao vivo, consulte o teste de unidade ao vivo.

Usar uma estrutura de teste de terceiros

Você pode executar testes de unidade no Visual Studio usando estruturas de teste de terceiros, como NUnit, Boost ou Google C++ Testing Framework, dependendo da linguagem de programação. Para usar uma estrutura de terceiros:

Use o Gerenciador de Pacotes NuGet para instalar o pacote NuGet para a estrutura de sua escolha.
(.NET) A partir do Visual Studio 2017 versão 14.6, o Visual Studio inclui modelos de projeto de teste pré-configurados para estruturas de teste NUnit e xUnit. Os modelos também incluem os pacotes NuGet necessários para habilitar o suporte.
(C++) No Visual Studio 2017 e versões posteriores, algumas estruturas como o Google C++ Testing Framework já estão incluídas. Para obter mais informações, consulte Gravar testes de unidade para C/C++ no Visual Studio.

Para adicionar um projeto de teste de unidade:

Abra a solução que contém o código que você deseja testar.
Clique com o botão direito do mouse na solução no Gerenciador de Soluções e escolha Adicionar>Novo Projeto.
Selecione um modelo de projeto de teste de unidade.

Neste exemplo, selecione NUnit

O modelo de projeto inclui referências do NuGet para NUnit e NUnit3TestAdapter.
Adicione uma referência do projeto de teste ao projeto que contém o código que você deseja testar.

Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Adicionar>Referência. (Você também pode adicionar uma referência no menu de clique com o botão direito do mouse do nó de Referências ou de Dependências.)
Adicione código ao método de teste.
Execute o teste no Gerenciador de Testes ou clicando com o botão direito do mouse no código de teste e escolhendo Executar Testes (ou Ctrl + R, T).

Próximas etapas

Noções básicas de teste de unidade

Criar e executar testes de unidade para código gerenciado

Escrever testes de unidade para C/C++

Comentários

Esta página foi útil?

Last updated on 2025-12-12