Tutorial: Testar uma biblioteca de classes .NET

Este tutorial mostra como automatizar o teste de unidade adicionando um projeto de teste a uma solução.

Pré-requisitos

Este tutorial funciona com a solução que você cria em Criar uma biblioteca de classes .NET.

Criar um projeto de teste de unidade

Os testes de unidade oferecem testes automatizados de software durante o processo de desenvolvimento e publicação. MSTest é uma das três estruturas de teste que você pode escolher. Os outros são xUnit e nUnit.

Inicie Visual Studio.
Abra a solução ClassLibraryProjects criada em Criar uma biblioteca de classes .NET.
Adicione um novo projeto de teste de unidade chamado "StringLibraryTest" à solução.
1. Clique com o botão direito do mouse na solução em Gerenciador de Soluções e selecione Add>New project.
2. Na página Adicionar um novo projeto, insira mstest na caixa de pesquisa. Escolha C# ou Visual Basic na lista De idiomas e escolha As plataformas na lista Plataforma.
3. Escolha o modelo do Projeto de Teste MSTest e, em seguida, Avançar.
4. Na página Configurar seu novo projeto, insira StringLibraryTest na caixa Nome do projeto. Em seguida, escolha Avançar.
5. Na página Additional information, selecione .NET 10 na caixa Framework, selecione Microsoft.Testing.Platform para o Test runner e escolha Create.
Insira informações adicionais para o projeto de teste do MSTest
Visual Studio cria o projeto e abre o arquivo de classe na janela de código com o código a seguir. Se o idioma que você deseja usar não for mostrado, altere o seletor de idioma na parte superior da página.
```
namespace StringLibraryTest
{

    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestMethod1()
        {
        }
    }
}
```
```
Imports Microsoft.VisualStudio.TestTools.UnitTesting

Namespace StringLibraryTest
    <TestClass>
    Public Class Test1
        <TestMethod>
        Sub TestSub()

        End Sub
    End Class
End Namespace
```
O código-fonte criado pelo modelo de teste de unidade faz o seguinte:
- Inclui Microsoft.VisualStudio.TestTools.UnitTesting no arquivo de projeto StringLibraryTest em C#e importa Microsoft.VisualStudio.TestTools.UnitTesting em Visual Basic.
- Aplica o atributo à classe.
- Aplica o atributo TestMethodAttribute para definir TestMethod1 em C# ou TestSub em Visual Basic.
Cada método marcado com [TestMethod] em uma classe de teste marcada com [TestClass] é executado automaticamente quando o teste de unidade é executado.

Inicie Visual Studio Code.
Abra a solução ClassLibraryProjects criada em Criar uma biblioteca de classes .NET.
Em Gerenciador de Soluções, selecione New Project ou, na Paleta de Comandos, selecione .NET: Novo Projeto.
Selecione MsTest Test Project, nomeie-o como "StringLibraryTest", selecione o diretório padrão e selecione Criar Projeto.

O modelo de projeto cria StringLibraryTest/Test1.cs com o seguinte código:
```
namespace StringLibraryTest;

[TestClass]
public class Test1
{
    [TestMethod]
    public void TestMethod1()
    {
    }
}
```
O código-fonte criado pelo modelo de teste de unidade faz o seguinte:
- Ele aplica o atributo à classe.
- Ele aplica o atributo para definir .
- Importa o namespace, que contém os tipos usados para teste unitário. O namespace é importado por meio de uma diretiva no GlobalUsings.cs.
Cada método marcado com [TestMethod] em uma classe de teste marcada com [TestClass] é executado automaticamente quando o teste de unidade é invocado.

Abra o terminal e navegue até a pasta de tutoriais que contém os projetos StringLibrary e ShowCase.
Crie um novo projeto de teste do MSTest:
```
dotnet new mstest -n StringLibraryTest
```
O modelo de projeto cria StringLibraryTest/Test1.cs com o seguinte código:
```
namespace StringLibraryTest;

[TestClass]
public class Test1
{
    [TestMethod]
    public void TestMethod1()
    {
    }
}
```
O código-fonte criado pelo modelo de teste de unidade faz o seguinte:
- Ele aplica o atributo à classe.
- Ele aplica o atributo para definir .
- Importa namespace, que contém os tipos usados para testes unitários.
Cada método marcado com [TestMethod] em uma classe de teste marcada com [TestClass] é executado automaticamente quando o teste de unidade é invocado.

Adicionar uma referência de projeto

Para que o projeto de teste funcione com a classe, adicione uma referência no projeto ao projeto.

Em Gerenciador de Soluções Clique com o botão direito do mouse no nó Dependencies do projeto StringLibraryTest e selecione Add Project Reference no menu de contexto.
Na caixa de diálogo Gerenciador de Referência , selecione a caixa ao lado de StringLibrary.

Adicione StringLibrary como uma referência de projeto para StringLibraryTest.
Selecione OK.

Em Gerenciador de Soluções clique com o botão direito do mouse no Projeto 'StringLibraryTest' e selecione Add Project Reference.
Selecione "StringLibrary".

Navegue até a pasta StringLibraryTest e adicione a referência do projeto:

cd StringLibraryTest
dotnet add reference ../StringLibrary/StringLibrary.csproj

Adicionar e executar métodos de teste de unidade

Quando um teste de unidade é executado, cada método marcado com o atributo em uma classe marcada com o atributo é executado automaticamente. Um método de teste termina quando a primeira falha é encontrada ou quando todos os testes contidos no método são bem-sucedidos.

Os testes mais comuns chamam membros da classe . Muitos métodos assert incluem pelo menos dois parâmetros, um deles é o resultado esperado do teste, e o outro é o resultado real do teste. Alguns dos métodos chamados com mais frequência da classe são mostrados na tabela a seguir:

Métodos assert	Função
`Assert.AreEqual`	Verifica se os dois valores ou objetos são iguais. O assert falha se os valores ou objetos não forem iguais.
`Assert.AreSame`	Verifica se duas variáveis de objeto se referem ao mesmo objeto. A assert falhará se as variáveis se referirem a objetos diferentes.
`Assert.IsFalse`	Verifica se uma condição é . O assert falhará se a condição for .
`Assert.IsNotNull`	Verifica se um objeto não é . A assert falhará se o objeto for .

Você também pode usar o método em um método de teste para indicar o tipo de exceção que ele deve gerar. O teste falhará se a exceção especificada não for lançada.

Ao testar o método, você deseja fornecer várias cadeias de caracteres que começam com um caractere maiúsculo. Você espera que o método retorne nesses casos, para que possa chamar o método . Da mesma forma, você deseja fornecer uma série de cadeias de caracteres que começam com algo diferente de um caractere maiúsculo. Você espera que o método retorne nesses casos, para que possa chamar o método .

Como o método de biblioteca lida com cadeias de caracteres, você também deseja garantir que ele manipule com êxito uma cadeia de caracteres vazia () e uma cadeia de caracteres. Uma cadeia de caracteres vazia é aquela que não tem caracteres e cujo é 0. Uma cadeia de caracteres é aquela que não foi inicializada. Você pode chamar diretamente como um método estático e passar um único argumento. Ou você pode chamar como um método de extensão em uma variável atribuída a .

Você definirá três métodos, cada um dos quais chama um método para cada elemento em uma matriz de cadeia de caracteres. Você chamará uma sobrecarga de método que permite especificar uma mensagem de erro a ser exibida em caso de falha de teste. A mensagem identifica a cadeia de caracteres que causou a falha.

Para criar os métodos de teste:

Na janela de código Test1.cs ou Test1.vb , substitua o código pelo seguinte código:

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports UtilityLibraries

Namespace StringLibraryTest
    <TestClass>
    Public Class UnitTest1
        <TestMethod>
        Public Sub TestStartsWithUpper()
            ' Tests that we expect to return true.
            Dim words() As String = {"Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"}
            For Each word In words
                Dim result As Boolean = word.StartsWithUpper()
                Assert.IsTrue(result,
                       $"Expected for '{word}': true; Actual: {result}")
            Next
        End Sub

        <TestMethod>
        Public Sub TestDoesNotStartWithUpper()
            ' Tests that we expect to return false.
            Dim words() As String = {"alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                               "1234", ".", ";", " "}
            For Each word In words
                Dim result As Boolean = word.StartsWithUpper()
                Assert.IsFalse(result,
                       $"Expected for '{word}': false; Actual: {result}")
            Next
        End Sub

        <TestMethod>
        Public Sub DirectCallWithNullOrEmpty()
            ' Tests that we expect to return false.
            Dim words() As String = {String.Empty, Nothing}
            For Each word In words
                Dim result As Boolean = StringLibrary.StartsWithUpper(word)
                Assert.IsFalse(result,
                       $"Expected for '{If(word Is Nothing, "<null>", word)}': false; Actual: {result}")
            Next
        End Sub
    End Class
End Namespace

O teste de caracteres maiúsculos no método inclui a letra grega maiúscula alfa (U+0391) e a letra cirílica maiúscula EM (U+041C). O teste de caracteres minúsculos no método inclui a letra minúscula grega alfa (U+03B1) e a letra minúscula cirílica Ghe (U+0433).

Na barra de menus, selecione Salvar arquivoTest1.cs Como ou Salvar ArquivoTest1.vb Como. Na caixa de diálogo Salvar Arquivo Como, selecione a seta ao lado do botão Salvar e selecione Salvar com Codificação.
Na caixa de diálogo Confirmar Salvar Como, selecione o botão Sim para salvar o arquivo.
Na caixa de diálogo Opções Avançadas de Salvamento, selecione Unicode (UTF-8 com assinatura) – página de código 65001 na lista suspensa Codificação e selecione OK.

Se você não salvar o código-fonte como um arquivo codificado em UTF8, Visual Studio poderá salvá-lo como um arquivo ASCII. Quando isso acontece, o runtime não decodifica com precisão os caracteres UTF8 fora do intervalo ASCII e os resultados do teste não estão corretos.
Na barra de menus, selecione TestarExecutar Todos os Testes. Se a janela do Gerenciador de Testes não abrir, abra-a escolhendo TesteGerenciador de Testes. Os três testes são listados na seção Testes Aprovados, e a seção Resumo relata o resultado da execução do teste.

janela do Explorador de Testes com testes aprovados

Abra StringLibraryTest/Test1.cs e substitua todo o código pelo código a seguir.

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Salve suas alterações.

Compilar e executar seus testes

Em Gerenciador de Soluções, clique com o botão direito do mouse na solução e selecione Build ou na Paleta de Comandos, selecione .NET: Build.
Selecione a janela Teste , selecione Executar Testes ou na Paleta de Comandos , selecione Teste: Executar todos os Testes.

Abra StringLibraryTest/Test1.cs e substitua todo o código pelo seguinte código:

using UtilityLibraries;

namespace StringLibraryTest
{
    [TestClass]
    public sealed class Test1
    {
        [TestMethod]
        public void TestStartsWithUpper()
        {
            // Tests that we expect to return true.
            string[] words = ["Alphabet", "Zebra", "ABC", "Αθήνα", "Москва"];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsTrue(result, $"Expected for '{word}': true; Actual: {result}");
            }
        }

        [TestMethod]
        public void TestDoesNotStartWithUpper()
        {
            // Tests that we expect to return false.
            string[] words = ["alphabet", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                          "1234", ".", ";", " "];
            foreach (var word in words)
            {
                bool result = word.StartsWithUpper();
                Assert.IsFalse(result, $"Expected for '{word}': false; Actual: {result}");
            }
        }

        [TestMethod]
        public void DirectCallWithNullOrEmpty()
        {
            // Tests that we expect to return false.
            string?[] words = [string.Empty, null];
            foreach (var word in words)
            {
                bool result = StringLibrary.StartsWithUpper(word);
                Assert.IsFalse(result, $"Expected for '{word ?? "<null>"}': false; Actual: {result}");
            }
        }
    }
}

Salve suas alterações e execute os testes:
```
dotnet test
```
Os testes devem passar.

Gerenciar falhas de teste

Se você estiver fazendo o TDD (Desenvolvimento Orientado por Testes), você grava os testes primeiro e eles falharão na execução. Em seguida, você adiciona o código ao aplicativo que faz com que o teste seja bem-sucedido. Neste tutorial, você criou o teste depois de gravar o código do aplicativo que ele valida, portanto, você não viu o teste falhar. Para validar se um teste falha conforme o esperado, adicione um valor inválido à entrada de teste.

Modifique a matriz no método para incluir a cadeia de caracteres “Error”.

string[] words = { "alphabet", "Error", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                   "1234", ".", ";", " " };

Dim words() As String = { "alphabet", "Error", "zebra", "abc", "αυτοκινητοβιομηχανία", "государство",
                   "1234", ".", ";", " " }

Execute o teste selecionando TestarExecutar Todos os Testes na barra de menus. A Janela Gerenciador de Testes indica que dois testes tiveram êxito e um falhou.

Janela Gerenciador de Testes com testes com falha
Selecione o teste com falha, .

A janela Gerenciador de Testes mostra a mensagem produzida pelo assert: "Assert.IsFalse falhou. Esperado para 'Error': false; real: true; devido à falha, as strings no array depois de "Error" não foram testadas.

janela do Explorador de Testes mostrando a falha na asserção IsFalse

Execute os testes clicando no erro verde ao lado do teste no editor.

A saída mostra que o teste falhou e fornece uma mensagem de erro para o teste que falhou: "Assert.IsFalse falhou." Esperado para 'Error': falso; real: verdadeiro". Devido à falha, nenhuma cadeia de caracteres na matriz após "Erro" foi testada.

Execute os testes:
```
dotnet test
```
A saída mostra que o teste falha e fornece uma mensagem de erro para o teste que falhou: "Falha em Assert.IsFalse. Esperado para 'Error': false; real: verdadeiro". Devido à falha, nenhuma cadeia de caracteres na matriz após "Erro" foi testada.

Remova a cadeia de caracteres "Erro" que você adicionou.
Execute novamente o teste, e ele será aprovado.

Testar a versão de lançamento da biblioteca

Agora que todos os testes foram aprovados ao executar a compilação de Debug da biblioteca, execute os testes mais uma vez na compilação de Release da biblioteca. Vários fatores, incluindo otimizações de compilador, às vezes podem produzir comportamento diferente entre builds de Debug e Liberação.

Para testar a compilação de Lançamento:

Na barra de ferramentas Visual Studio, altere a configuração de build de Debug para Release.
Em Gerenciador de Soluções, clique com o botão direito do mouse no projeto StringLibrary e selecione Build no menu de contexto para recompilar a biblioteca.
Execute os testes de unidade escolhendo TestarExecutar Todos os Testes da barra de menu. Os testes são aprovados.

Execute os testes com a configuração de compilação de Release:

dotnet test StringLibraryTest/StringLibraryTest.csproj --configuration Release

Os testes são aprovados.

Execute os testes com a configuração de build de Release.

dotnet test --configuration Release

Os testes são aprovados.

Testes de depuração

Se você estiver usando Visual Studio como seu IDE, poderá usar o mesmo processo mostrado em Tutorial: depurar um aplicativo de console .NET para depurar o código usando seu projeto de teste de unidade. Em vez de iniciar o projeto do aplicativo ShowCase, clique com o botão direito do mouse no projeto StringLibraryTests e selecione Testes de Depuração no menu de contexto.

Visual Studio inicia o projeto de teste com o depurador anexado. A execução é interrompida em qualquer ponto de interrupção que você adicionou ao projeto de teste ou ao código da biblioteca subjacente.

Se você estiver usando Visual Studio Code como seu IDE, poderá usar o mesmo processo mostrado em Depurar um aplicativo de console .NET para depurar o código usando seu projeto de teste de unidade. Em vez de iniciar o projeto de aplicativo ShowCase , abra StringLibraryTest/Test1.cs e selecione Testes de Depuração no arquivo atual entre as linhas 7 e 8. Se não for possível encontrá-lo, pressione Ctrl+Shift+P para abrir a paleta de comandos e insira Recarregar Janela.

Visual Studio Code inicia o projeto de teste com o depurador anexado. A execução será interrompida em qualquer ponto de interrupção que você adicionou ao projeto de teste ou ao código da biblioteca subjacente.

Recursos adicionais

Testes unitários em .NET

Recursos de limpeza

GitHub exclui automaticamente o Codespace após 30 dias de inatividade. Se você planeja explorar mais tutoriais nesta série, pode deixar o seu Codespace provisionado. Se você estiver pronto para visitar o site .NET para baixar o SDK do .NET, poderá excluir seu Codespace. Para excluir seu Codespace, abra uma janela do navegador e navegue até seus Codespaces. Você verá uma lista de seus codespaces na janela. Selecione os três pontos () na entrada do espaço de código do tutorial Learn. Em seguida, selecione "Excluir".

Próximas etapas

Neste tutorial, você testou uma biblioteca de classes. Você pode disponibilizar a biblioteca para outras pessoas publicando-a no NuGet como um pacote. Para saber como, siga um tutorial do NuGet:

Criar e publicar um pacote usando a CLI do dotnet

Se você publicar uma biblioteca como um pacote NuGet, outras pessoas poderão instalá-la e usá-la. Para saber como, siga um tutorial do NuGet:

Instalar e usar um pacote usando a CLI do dotnet

Uma biblioteca não precisa ser distribuída como um pacote. Ela pode ser empacotada com um aplicativo de console que a usa. Para saber como publicar um aplicativo de console, consulte o tutorial anterior nesta série:

Publish um aplicativo de console .NET

Comentários

Esta página foi útil?

Last updated on 2026-03-06

Compartilhar via

Tutorial: Testar uma biblioteca de classes .NET

Pré-requisitos

Criar um projeto de teste de unidade

Adicionar uma referência de projeto

Adicionar e executar métodos de teste de unidade

Compilar e executar seus testes

Gerenciar falhas de teste

Testar a versão de lançamento da biblioteca

Testes de depuração

Recursos adicionais

Recursos de limpeza

Próximas etapas

Comentários

Recursos adicionais