1. O conteúdo
2. Execução
3. 2. Preparação do texto do módulo Program.cs
4. 2.2. Torne pública a classe Program
5. 3. Listagem do programa testado
6. 4. Criando um teste
7. 4.1. Adicionando um novo projeto à solução
8. 4.2. Estrutura da solução
9. 4.3. O texto do arquivo "UnitTest1.cs". Atributos [TestMethod] e [TestClass]
10. 4.4. Fazendo alterações no texto do módulo UnitTest1. Alterando o nome do método de teste
11. 4.5. Conectando o projeto MinApp ao projeto TestMinApp
12. 4.6. Fazendo alterações no texto do módulo UnitTest1.cs
13. 4.6.2. Texto do método TestMin ()
14. 4.7. Texto do módulo UnitTest1.cs
15. 5. Execute o teste e verifique o resultado do teste
16. 6. O resultado Interação entre projetos

Este tópico descreve o processo passo a passo de criação de um Teste de Unidade simples no Microsoft Visual Studio 2010 (C #) para um aplicativo como o Aplicativo de Console. Usando este exemplo, você pode aprender como criar seus próprios testes de unidade. O exemplo também demonstra o uso da classe Assert para testar a operação de funções.

O conteúdo

A condição do problema

Para um aplicativo como o aplicativo de console, desenvolva um teste de unidade que testa a operação da função Min (), que determina o elemento máximo de três números.

Para a função Min (), defina o método de teste para TestMin (). Verifique a função.

Execução

1. Criar um aplicativo usando o modelo de aplicativo de console

Execute o MS Visual Studio 2010 para execução Para criar um projeto usando o padrão Console Application, a seguinte seqüência de comandos deve ser chamada:

Arquivo -> Novo -> Projeto ...

Como resultado, a janela Novo Projeto é aberta. Na janela, selecione o modelo de Aplicativo do Console, conforme mostrado na Figura 1. O modelo é selecionado na guia Visual C #.

Visual C # -> Aplicativo do Console

Fig. 1. Janela "Novo Projeto". Escolhendo um aplicativo do tipo de aplicativo de console

2. Preparação do texto do módulo Program.cs

2.1. Adicionar função Min () ao texto do módulo

O texto da função Min () deve ser adicionado ao corpo da classe Program.

A função é declarada como pública (estática) e pública. Texto da função Min ()

public static int Min (int, int, int) {int min = a; if (min> b) min = b; if (min> c) min = c; return min; }

Fig. 2. Vista da janela do MS Visual Studio 2010, módulo “Program.cs”

2.2. Torne pública a classe Program

Para ter acesso à função Min () da classe Program, você precisa disponibilizar esta classe publicamente. Para fazer isso, antes de declarar uma classe, você precisa definir a palavra-chave pública.

... namespace MinApp {public class Program {// métodos de classe // ...}} ...

Depois disso, o programa de teste está pronto.

3. Listagem do programa testado

No momento, a listagem do programa que está sendo testado é a seguinte:

usando o sistema; using System.Collections.Generic; using System.Linq; using System.Text; namespace MinApp {public class Programa {public static int Min (int a, int b, int c) {int min = a; if (min> b) min = b; if (min> c) min = c; return min; } estático void Main (string [] args) {Console.WriteLine ("Demonstração do teste unitário em C #."); }}}

Como este programa será testado a partir de outro módulo de teste, não há necessidade de inserir mais nada na função Main (). Porque, de acordo com a condição do problema, você precisa testar a operação da função Min (). E isso será feito no módulo de teste. No momento, nosso programa está pronto para testes.

4. Criando um teste

O teste é criado por um projeto separado (Projeto) na solução (Solução). O programa que está sendo testado não sabe sobre isso. O programa que irá testar (o programa de teste) chamará as funções do programa que está sendo testado. No nosso caso, o programa de teste irá chamar a função

int Min (int, int, int);

4.1. Adicionando um novo projeto à solução

Para esta solução (Solution) você precisa adicionar um novo projeto usando o comando

Arquivo-> Adicionar-> Novo Projeto ...

A janela para criar um novo projeto é mostrada na Figura 3.

Fig. 3. Janela para criar um projeto do tipo Projeto de Teste

Um grupo de modelos do Visual C # -> Teste é selecionado na janela. Nos modelos exibidos, o modelo de projeto “Projeto de Teste” é selecionado. No campo "Nome", o nome do projeto que irá testar o nosso programa é indicado. Você precisa definir, por exemplo, TestMinApp. O projeto está localizado em uma pasta separada "E: \ Test \ MinApp".

Fig. 4. O texto do módulo UnitTest1.cs. Janela do utilitário Solution Explorer com projetos TestMinApp e MinApp exibidos

4.2. Estrutura da solução

Como pode ser visto na Figura 4, o utilitário Solution Explorer exibe a estrutura de itens da solução, que contém dois projetos:

• projeto MinApp. Este é um projeto criado usando o modelo de aplicativo de console com a função Min () que você deseja protestar;
• Projeto TestMinApp. Este projeto foi projetado para testar os recursos do projeto MinApp. O código do programa que testa a função Min () será inserido no arquivo de projeto UnitTest1 do projeto TestMinApp.

Ambos os projetos podem ser realizados independentemente uns dos outros.

4.3. O texto do arquivo "UnitTest1.cs". Atributos [TestMethod] e [TestClass]

No projeto TestMinApp, o arquivo de teste UnitTest1.cs é de interesse primário. Este arquivo contém métodos que testarão as funções do projeto MinApp. O projeto TestMinApp pode conter qualquer número de arquivos que contenham testes (por exemplo, UnitTest2.cs, UnitTest3.cs, etc.).

A listagem do arquivo UnitTest1.cs gerado pelo MS Visual Studio 2010 é a seguinte:

usando o sistema; using System.Text; using System.Collections.Generic; using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting; namespace TestMinApp {/// <summary> /// Descrição resumida para UnitTest1 /// </ summary> [TestClass] public class UnitTest1 {public UnitTest1 () {// // TODO: Adicione a lógica do construtor aqui //} private TestContext testContextInstance; /// <summary> /// Obtém ou define o contexto de teste. /// </ summary> public TestContext TestContext {get {return testContextInstance; } set {testContextInstance = valor; }} #region Atributos de teste adicionais // você pode usar seus testes // // Usar ClassInitialize // [ClassInitialize ()] // public static void MyClassInitialize (TestContext testContext) {} // // Use ClassCleanup para executar o código depois que todos os testes em uma classe tiverem executado // [ClassCleanup ()] // public static void MyClassCleanup () {} // // Use TestInitialize para executar o código antes de executar cada teste // [TestInitialize ()] // public void MyTestInitialize () {} // // Use TestCleanup para executar o código após cada teste ter executado // [TestCleanup ()] // public void MyTestCleanup ( ) {} // #endregion [TestMethod] public void TestMethod1 () {// // TODO: Adicione lógica de teste aqui //}}}

Como pode ser visto no código acima, o arquivo contém uma classe chamada UnitTest1. A classe tem um método público chamado TestMethod1 (). Antes de implementar o método TestMethod1 (), o atributo [TestMethod] é colocado. Isso significa que você precisa inserir o código que testará as funções do projeto MinApp no ​​corpo do método.

Na turma, você pode inserir qualquer número de métodos que testará funções diferentes de módulos diferentes. O principal é que esses métodos são marcados com o atributo [TestMethod].

4.4. Fazendo alterações no texto do módulo UnitTest1. Alterando o nome do método de teste

Você pode alterar os nomes dos métodos e adicionar novos métodos marcados com o atributo [TestMethod] no módulo UnitTest1.cs. Sendo assim, no texto do módulo UnitTest1.cs, você precisa renomear o método TestMethod1 () para TestMin ().

Depois que as alterações forem feitas, o texto abreviado do módulo do arquivo UnitTest1.cs será:

usando o sistema; using System.Text; using System.Collections.Generic; using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting; namespace TestMinApp {/// <summary> /// Descrição resumida para UnitTest1 /// </ summary> [TestClass] public class UnitTest1 {... [TestMethod] public void TestMin () {// // TODO: Adicionar teste lógica aqui //}}}

4.5. Conectando o projeto MinApp ao projeto TestMinApp

Para ter acesso à função Min () (projeto MinApp) do projeto TestMinApp, é necessário conectar o namespace no qual esta função está localizada.

Para fazer isso, antes de tudo, você precisa chamar o menu de contexto para o projeto TestMinApp. Então, no menu de contexto, você precisa chamar o comando “Add Reference ...” (Figura 5).

Fig. 5. Equipe "Adicionar referência ..."

Como resultado, a janela Add Reference será aberta, na qual você precisa selecionar o projeto MinApp.

Fig. 6. Janela "Adicionar Referência". Conectando o projeto MinApp

Após as ações concluídas, as funções do projeto MinApp estarão disponíveis para uso no projeto TestMinApp.

Fig. 7. Guia References com o projeto MinApp conectado

4.6. Fazendo alterações no texto do módulo UnitTest1.cs

4.6.1. Adicionando o namespace MinApp ao módulo UnitTest1.cs

Nesta etapa, no módulo UnitTest1.cs, você precisa adicionar o namespace MinApp usando a diretiva using:

usando o sistema; using System.Text; using System.Collections.Generic; using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting; usando o MinApp; namespace TestMinApp {...}

4.6.2. Texto do método TestMin ()

No texto do método TestMin (), digite o seguinte código:

... [TestMethod] public void TestMin () {// // TODO: Adicione lógica de teste aqui // int min; min = Programa .Min (3, 4, 5); Asser .AreEqual (2, min); } ...

4.7. Texto do módulo UnitTest1.cs

O texto de todo o módulo UnitTest1.cs é o seguinte:

usando o sistema; using System.Text; using System.Collections.Generic; using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting; usando o MinApp; namespace TestMinApp {/// <summary> /// Descrição resumida para UnitTest1 /// </ summary> [TestClass] public class UnitTest1 {public UnitTest1 () {// // TODO: Adicione a lógica do construtor aqui //} private TestContext testContextInstance; /// <summary> /// Obtém ou define o contexto de teste. /// </ summary> public TestContext TestContext {get {return testContextInstance; } set {testContextInstance = valor; }} #region Atributos de teste adicionais // você pode usar seus testes // // Usar ClassInitialize // [ClassInitialize ()] // public static void MyClassInitialize (TestContext testContext) {} // // Use ClassCleanup para executar o código depois que todos os testes em uma classe tiverem executado // [ClassCleanup ()] // public static void MyClassCleanup () {} // // Use TestInitialize para executar o código antes de executar cada teste // [TestInitialize ()] // public void MyTestInitialize () {} // // Use TestCleanup para executar o código após cada teste ter executado // [TestCleanup ()] // public void MyTestCleanup ( ) {} // #endregion [TestMethod] public void TestMin () {// // TODO: Adicione lógica de teste aqui // int min; min = Programa .Min (3, 4, 5); Asser .AreEqual (2, min); }}}

5. Execute o teste e verifique o resultado do teste

No Microsoft Visual Studio 2010, um menu especial de comandos chamado Test é implementado para trabalhar com testes de unidade.

Para executar um teste de execução, selecione um dos comandos.

ou

Teste -> Executar -> Todos os Testes em Solução

como mostrado na Figura 8.

Fig. 8. Ligue para o comando start test e visualize o resultado.

Depois de executar o teste, o resultado pode ser visto na parte inferior da janela Resultados do Teste. Como pode ser visto na figura, o teste não é passado. Isso é lógico, já que na função Assert.AreEqual () comparamos os números 2 e 3, que são diferentes. Aqui, o número 2 é especialmente introduzido em vez de 3.

Se, em vez do número 2, você digitar a resposta correta - número 3 (mínimo entre 3, 4, 5), o teste será passado (Figura 9). Neste caso, o texto do método TestMin () será o seguinte:

... [TestMethod] public void TestMin () {// // TODO: Adicione lógica de teste aqui // int min; min = Programa .Min (3, 4, 5); Asser .AreEqual (3, min); } ...

A janela de resultados é mostrada na Figura 9.

Fig. 9. Resultado do teste para o caso, se você digitar a resposta correta

Agora podemos concluir que a função Min () para este caso funciona corretamente.

6. O resultado Interação entre projetos

Neste trabalho, dois projetos são formados na solução. Um projeto MinApp contém a função Min () que você deseja testar. O segundo projeto, TestMinApp, contém métodos de teste.

No Microsoft Visual Studio 2010, cada projeto é iniciado usando diferentes comandos de menu. Assim, o projeto MinApp é lançado da maneira padrão no menu Executar. E o projeto TestMinApp é iniciado no menu especial Test.

Tópicos Relacionados