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 unitários

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

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 projeto simples de consola "Hello World" em C# ou C++ chamado HelloWorld. O código de exemplo para tal 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";
}
```
Em Explorador de Soluções, selecione o nó da solução. Depois, na barra de menu superior, selecione FicheiroAdicionarNovo Projeto.
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.

As linguagens .NET no Visual Studio incluem modelos 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 no código Python para configurar o seu projeto de teste.

Sugestão

Este artigo descreve como criar manualmente testes de unidade. Se quiser gerar testes automaticamente a partir de código existente, veja Gere e execute testes unitários usando testes GitHub Copilot para .NET, ou para outras linguagens, veja Use comandos com barra em GitHub Copilot

Sugestão

Este artigo descreve como criar manualmente testes de unidade. Se quiser gerar testes automaticamente a partir de código existente, veja Criar stubs de métodos de teste unitário em C# a partir de código, ou para outras linguagens, veja Usar slash commands no GitHub Copilot

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

Modelo de projeto de teste unitário

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

O projeto é adicionado à sua solução.

Projeto de teste unitário
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.
Selecione o projeto que contém o código que vai testar e clique em OK.

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 corresponde ao seu framework de teste: MSTest, NUnit ou xUnit (suportado apenas em .NET), ou Microsoft Native Unit Test Framework em C++.

MSTest
NUnit
xUnidade
Framework de Testes Unitários Nativos da Microsoft

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 Explorador de Testes, escolha Explorador de Testes de Teste na barra de menu superior (ou pressione Ctrl, T).
Executa os teus testes unitários clicando em Executar Tudo (ou carrega em CtrlR, V).

Captura de ecrã que mostra o Explorador de Testes.

Executar testes unitários no Explorador de Testes

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.

Captura de ecrã que mostra os resultados dos testes unitários no Explorador de Testes.

Consulte os resultados dos testes unitários no Test Explorer

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 estiver a usar o framework de testes MSTest, xUnit ou NUnit no Visual Studio 2017 ou posterior, pode ver resultados em tempo real dos seus 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.

Ativar os testes unitários ao vivo no menu de Teste escolhendo TesteTestes Unitários ao VivoIniciar.
Veja os resultados dos testes dentro da janela do editor de código enquanto escreve e edita código.

Captura de ecrã que mostra os resultados dos testes.

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

Captura de ecrã que mostra os indicadores dos resultados do teste.

Escolha os indicadores de resultados do teste

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 o NUnit, Boost ou Google C++ Testing Framework, dependendo da sua linguagem de programação. Para usar um framework de terceiros:

Use o NuGet Gestor de Pacotes para instalar o pacote NuGet para o framework que preferir.
(.NET) A partir do Visual Studio 2017 versão 14.6, o Visual Studio inclui modelos de projeto de teste pré-configurados 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, veja Write unit tests for C/C++ in Visual Studio.

Para adicionar um projeto de teste unitário:

Abre a solução que contém o código que queres testar.
Clique com o botão direito na solução em Explorador de Soluções e escolha Adicionar>Novo Projeto.
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.
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 em 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.)
Adicione código ao seu método de teste.

Captura de ecrã que mostra código no ficheiro de teste unitário.

Adicione código ao seu ficheiro de código de teste unitário
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 CtrlR, 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++

Comentários

Esta página foi útil?

Last updated on 2026-03-06