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 crias em Cria uma biblioteca de classes .NET.

Criar um projeto de teste de unidade

Os testes de unidade proporcionam testes de software automatizados ao longo do desenvolvimento e da publicação. MSTest é uma das três estruturas de teste que você pode escolher. Os outros são xUnit e nUnit.

Inicia o Visual Studio.
Abra a solução ClassLibraryProjects que criou 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 na solução em Solution Explorer e selecione Adicionar>Novo projeto.
2. Na página Adicionar um novo projeto , digite mstest na caixa de pesquisa. Escolha C# ou Visual Basic da lista de Línguas, e depois escolha Todas as plataformas da lista de Plataformas.
3. Escolha o modelo MSTest Test Project e, em seguida, escolha Next.
4. Na página Configurar seu novo projeto , digite StringLibraryTest na caixa Nome do projeto . Em seguida, escolha Avançar.
5. Na página Informação adicional, selecione .NET 10 na caixa Framework, selecione Microsoft.Testing.Platform para o executor Test, e depois escolha Create.
O Visual Studio cria o projeto e abre o ficheiro de classe na janela de código com o seguinte código. Se o idioma que pretende utilizar não for apresentado, 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 ficheiro de projeto StringLibraryTest em C#, e importa Microsoft.VisualStudio.TestTools.UnitTesting em Visual Basic.
- Aplica o TestClassAttribute atributo à Test1 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.

Abra o Visual Studio Code.
Abra a solução ClassLibraryProjects que criou em Criar uma biblioteca de classes .NET.
A partir de Solution Explorer, selecione Novo Projeto, ou na Paleta de Comandos selecione .NET: Novo Projeto.
Selecione Projeto de Teste MSTest, nomeie-o "StringLibraryTest", selecione o diretório predefinido e selecione Criar Projeto.

O modelo do 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:
- Aplica o TestClassAttribute atributo à Test1 classe.
- Aplica o TestMethodAttribute atributo para definir TestMethod1.
- Importa o Microsoft.VisualStudio.TestTools.UnitTesting espaço de nomes, que contém os tipos usados para testes unitários. O namespace é importado através de uma global using diretiva em GlobalUsings.cs.
Cada método etiquetado com [TestMethod] numa classe de teste marcada com [TestClass] é executado automaticamente quando o teste unitário é invocado.

Abra o terminal e navegue até à pasta de tutoriais que contém os projetos StringLibrary e ShowCase.
Crie um novo projeto de teste MSTest:
```
dotnet new mstest -n StringLibraryTest
```
O modelo do 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:
- Aplica o TestClassAttribute atributo à Test1 classe.
- Aplica o TestMethodAttribute atributo para definir TestMethod1.
- Importa o Microsoft.VisualStudio.TestTools.UnitTesting espaço de nomes, que contém os tipos usados para testes unitários.
Cada método etiquetado com [TestMethod] numa classe de teste marcada com [TestClass] é executado automaticamente quando o teste unitário é invocado.

Adicionar uma referência de projeto

Para o projeto de teste funcionar com a classe StringLibrary, adicionar uma referência ao projeto StringLibrary no projeto StringLibraryTest.

Em Solution Explorer, clique com o botão direito no nó Dependências do projeto StringLibraryTest e selecione Adicionar Referência do Projeto no menu contextual.
No diálogo Gestor de Referências , selecione a caixa ao lado de StringLibrary.
Selecione OK.

A partir de Solution Explorer clique com o botão direito no projeto 'StringLibraryTest' e selecione Add Project Reference.
Selecione "StringLibrary".

Navegue até à 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 unitário é executado, cada método marcado com o TestMethodAttribute atributo numa classe marcada com o TestClassAttribute atributo executa-se 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 Assert. Muitos métodos de afirmação incluem pelo menos dois parâmetros, um dos quais é o resultado esperado do teste e o outro é o resultado real do teste. Alguns dos métodos mais frequentemente chamados da classe Assert são mostrados na tabela a seguir:

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

Também pode usar o Assert.Throws método num método de teste para indicar o tipo de exceção que se espera que lance. O teste falhará se a exceção especificada não for lançada.

Ao testar o StringLibrary.StartsWithUpper método, deves fornecer um número de cadeias que comecem com um carácter maiúsculo. Você espera que o método retorne true nesses casos, para que você possa chamar o método Assert.IsTrue. Da mesma forma, queres fornecer várias sequências de texto que comecem por algo que não seja um carácter maiúsculo. Você espera que o método retorne false nesses casos, para que você possa chamar o método Assert.IsFalse.

Como o teu método de biblioteca lida com cadeias, também deves garantir que gere com sucesso uma cadeia vazia (String.Empty) e uma null cadeia. Uma cadeia vazia é aquela que não tem caracteres e cuja Length é 0. Uma null string é aquela que não foi inicializada. Podes chamar StartsWithUpper diretamente como método estático e passar um único String argumento. Ou pode chamar StartsWithUpper como método de extensão numa string variável atribuída a null.

Vais definir três métodos, cada um dos quais chama um Assert método para cada elemento num array de strings. Vai chamar um método de sobrecarga que permite especificar uma mensagem de erro a ser exibida em caso de falha no 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:

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 TestStartsWithUpper inclui a letra maiúscula grega alfa (U+0391) e a letra maiúscula cirílica EM (U+041C). O teste de caracteres minúsculos no método TestDoesNotStartWithUpper inclui a letra pequena grega alfa (U+03B1) e a letra pequena cirílica Ghe (U+0433).

Na barra de menus, selecione Ficheiro>Guardar Test1.cs Como ou Ficheiro>Guardar Test1.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) - Codepage 65001 na lista suspensa Codificação e selecione OK.

Se não conseguir guardar o seu código-fonte como ficheiro codificado em UTF8, o Visual Studio pode guardá-lo como ficheiro ASCII. Quando isso acontece, o tempo de execução 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 Test>Run All Tests. Se a janela do Test Explorer não abrir, abra-a escolhendo TestTest Explorer. 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.

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

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.

Constrói e executa os teus testes

Em Solution Explorer, clique com o botão direito na solução e selecione Build ou na Paleta de Comandos, selecione .NET: Build.
Selecione a janela de Testes , selecione Executar Testes ou, na Paleta de Comandos, selecione Testar: Executar todos os Testes.

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

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

Guarde as suas alterações e faça os testes:
```
dotnet test
```
Os testes devem passar.

Lidar com falhas de teste

Se você estiver fazendo desenvolvimento orientado a testes (TDD), você escreve testes primeiro e eles falham na primeira vez que você os executa. Em seguida, você adiciona código ao aplicativo que faz o teste ser bem-sucedido. Para este tutorial, você criou o teste depois de escrever o código do aplicativo que ele valida, para que você não tenha visto o teste falhar. Para validar que um teste falha quando você espera que ele falhe, adicione um valor inválido à entrada de teste.

Modifique a matriz words no método TestDoesNotStartWithUpper 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 Test>Run All Tests na barra de menus. A janela Test Explorer indica que dois testes foram bem-sucedidos e um falhou.
Selecione o teste reprovado, TestDoesNotStartWith.

A janela Test Explorer exibe a mensagem produzida pela afirmação: "Assert.IsFalse falhou." Esperado para 'Erro': false; real: Verdade." Devido à falha, as cadeias de caracteres na matriz após "Erro" não foram testadas.

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

O resultado mostra que o teste falhou e fornece uma mensagem de erro para o teste falhado: "Assert.IsFalse falhou. Esperado para 'Erro': falso; actual: Verdade". Devido à falha, nenhuma string no array depois do "Erro" foi testada.

Faça os testes:
```
dotnet test
```
O resultado mostra que o teste falhou e fornece uma mensagem de erro para o teste falhado: "Assert.IsFalse falhou. Esperado para 'Erro': falso; actual: Verdade". Devido à falha, nenhuma string no array depois do "Erro" foi testada.

Remove a cadeia "Erro" que adicionaste.
Execute novamente o teste e os testes são aprovados.

Testar a versão Release da biblioteca

Agora que todos os testes passaram ao executar a versão de Debug da biblioteca, executa os testes uma vez adicional contra a versão Release da biblioteca. Vários fatores, incluindo as otimizações do compilador, podem por vezes produzir comportamentos diferentes entre as versões de Depuração e de Lançamento.

Para testar o build de lançamento:

Na barra de ferramentas Visual Studio, altere a configuração da compilação de Debug para Release.
Em Solution Explorer, clique com o botão direito no projeto StringLibrary e selecione Build no menu contextual para recompilar a biblioteca.
Execute os testes de unidade escolhendo Test>Run All Tests na barra de menus. Os testes passam.

Executa os testes com a configuração da compilação Release:

dotnet test StringLibraryTest/StringLibraryTest.csproj --configuration Release

Os testes passam.

Executa os testes com a configuração da compilação Release:

dotnet test --configuration Release

Os testes passam.

Testes de depuração

Se estiveres a usar Visual Studio como teu IDE, podes usar o mesmo processo mostrado no Tutorial: Depurar uma aplicação de consola .NET para depurar código usando o teu projeto de teste unitário. Em vez de iniciar o projeto do aplicativo ShowCase , clique com o botão direito do mouse no projeto StringLibraryTests e selecione Depurar testes no menu de contexto.

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

Se estiveres a usar o Visual Studio Code como o teu IDE, podes usar o mesmo processo mostrado em Debug a aplicação de consola .NET para depurar o código utilizando o teu projeto de teste unitário. Em vez de iniciar o projeto da aplicação ShowCase , abra StringLibraryTest/Test1.cs e selecione Debug Tests no ficheiro atual entre as linhas 7 e 8. Se não conseguires encontrá-lo, carrega em Ctrl+Shift+P para abrir a paleta de comandos e entra na Janela de Recarregar.

O Visual Studio Code inicia o projeto de testes com o depurador associado. A execução para em qualquer ponto de interrupção que tenha adicionado ao projeto de teste ou ao código da biblioteca subjacente.

Recursos adicionais

Testes unitários em .NET

Recursos de limpeza

O GitHub apaga automaticamente o teu Codespace após 30 dias de inatividade. Se planeia explorar mais tutoriais nesta série, pode deixar o seu Codespace provisionado. Se estiveres pronto para visitar o site .NET para descarregar o SDK .NET, podes apagar o teu Codespace. Para eliminar o seu Codespace, abra uma janela do navegador e navegue até aos seus Codespaces. Vês uma lista dos teus codespaces na janela. Selecione os três pontos (...) na entrada para o espaço de código do tutorial de aprendizagem. Depois seleciona "Eliminar".

Próximos passos

Neste tutorial, você testou uma biblioteca de classes. Pode disponibilizar a biblioteca a outros publicando-a na NuGet como um pacote. Para saber como, siga um tutorial do NuGet:

Crie e publique um pacote usando a CLI 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:

Instale e use um pacote usando a CLI dotnet

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

Publique uma aplicação .NET consola

Comentários

Esta página foi útil?

Last updated on 2026-03-11

Partilhar 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

Constrói e executa os teus testes

Lidar com falhas de teste

Testar a versão Release da biblioteca

Testes de depuração

Recursos adicionais

Recursos de limpeza

Próximos passos

Comentários

Recursos adicionais