Testes de unidade para métodos genéricos

Você pode gerar testes de unidade para métodos genéricos exatamente como faz para outros métodos, conforme descrito em Como: criar e executa um teste de unidade.As seções a seguir fornecem informações e exemplos de criação de testes de unidade para métodos genéricos.

Argumentos de tipo e restrições de tipo

Quando Visual Studio gera um teste de unidade para uma classe genérica, tais como MyList<T>, ele gera dois métodos: um auxiliar genérico e um método de teste.Se MyList<T> tem uma ou mais restrições de tipo, o argumento de tipo deve satisfazer a todas as restrições de tipo.Para certificar-se de que a genérica de código sob teste funciona conforme o esperado para entradas de todos os permitidos, o método de teste chama o método auxiliar genérico com todas as restrições que você deseja testar.

Exemplos

Os exemplos a seguir ilustram os testes de unidade para os genéricos:

• Edição gerou o código de teste.Este exemplo tem duas seções, código de teste gerado e editado o código de teste.Ele mostra como editar o código de teste bruto gerado a partir de um método genérico em um método de teste úteis.

• Usando uma restrição de tipo.Este exemplo mostra um teste de unidade de um método genérico que usa uma restrição de tipo.Neste exemplo, a restrição de tipo não é satisfeita.

Exemplo 1: Edição de código de teste gerado

O código de teste nesta seção testa um método do código sob teste chamado SizeOfLinkedList().Esse método retorna um inteiro que especifica o número de nós na lista vinculada.

O primeiro exemplo de código, na seção código de teste geradas, mostra o código de teste não-editadas conforme ela foi gerada pelo Visual Studio Premium ou Visual Studio Ultimate.O segundo exemplo, na seção código de teste editada, mostra como você pode torná-lo a testar o funcionamento do método SizeOfLinkedList para dois tipos de dados diferentes, int e char.

Este código ilustra dois métodos:

• um método auxiliar de teste, SizeOfLinkedListTestHelper<T>().Por padrão, um método auxiliar de teste tem "TestHelper" no seu nome.

• um método de teste, SizeOfLinkedListTest().Cada método de teste é marcado com o atributo TestMethod.

Código de teste gerado

O seguinte código de teste foi gerado a partir do SizeOfLinkedList() método.Como esse é o teste gerados não-editado, deve ser modificado para corretamente, testar o método SizeOfLinkedList.

public void SizeOfLinkedListTestHelper<T>()
{
    T val = default(T); // TODO: Initialize to an appropriate value
    MyLinkedList<T> target = new MyLinkedList<T>(val); // TODO: Initialize to an appropriate value
    int expected = 0; // TODO: Initialize to an appropriate value
    int actual;
    actual = target.SizeOfLinkedList();
    Assert.AreEqual(expected, actual);
    Assert.Inconclusive("Verify the correctness of this test method.");
}

[TestMethod()]
public void SizeOfLinkedListTest()
{
   SizeOfLinkedListTestHelper<GenericParameterHelper>();
}

No código anterior, o parâmetro de tipo genérico é GenericParameterHelper.Ao passo que você possa editá-lo para fornecer tipos de dados específicos, conforme mostrado no exemplo a seguir, você pode executar o teste sem editar essa instrução.

Código de teste editado

No código a seguir, o método de teste e o método auxiliar de teste foram editadas para torná-los com êxito o método de teste o código under teste- SizeOfLinkedList().

Método auxiliar de teste

O método auxiliar de teste executa as etapas a seguir, que correspondem às linhas de código rotulado etapas 1 a 5.

1. Crie uma lista vinculada genérica.

2. Acrescente os quatro nós à lista vinculada.O tipo de dados do conteúdo de nós é desconhecido.

3. Atribua o tamanho esperado de lista vinculada à variável expected.

4. Calcular o tamanho real da lista vinculada e atribuí-la à variável actual.

5. Comparar actual com expected em uma instrução Assert.Se o real não é igual ao esperado, o teste falhar.

Método de teste

O método de teste é compilado em código que é chamado quando você executar o teste chamado SizeOfLinkedListTest.Ele executa as etapas a seguir, que correspondem às linhas de código rotulado etapas 6 e 7.

1. Especificar <int> quando você chamar o método auxiliar de teste, para verificar se o teste funciona para integer variáveis.

2. Especificar <char> quando você chamar o método auxiliar de teste, para verificar se o teste funciona para char variáveis.

public void SizeOfLinkedListTestHelper<T>()
{
    T val = default(T); 
    MyLinkedList<T> target = new MyLinkedList<T>(val); // step 1
    for (int i = 0; i < 4; i++) // step 2
    {
        MyLinkedList<T> newNode = new MyLinkedList<T>(val);
        target.Append(newNode);
    }
    int expected = 5; // step 3
    int actual;
    actual = target.SizeOfLinkedList(); // step 4
    Assert.AreEqual(expected, actual); // step 5
}

[TestMethod()]
public void SizeOfLinkedListTest() 
{
    SizeOfLinkedListTestHelper<int>();  // step 6
    SizeOfLinkedListTestHelper<char>(); // step 7
}

Observação

Cada vez que o teste de SizeOfLinkedListTest é executado, o TestHelper método é chamado duas vezes.A instrução assert deve ser avaliada como verdadeiro sempre para o teste seja aprovado.Se o teste falhar, talvez não seja claro se a chamada especificada <int> ou a chamada que especificou <char> fez com que ele falhe.Para encontrar a resposta, você pode examinar a pilha de chamadas, ou você poderia definir pontos de interrupção no seu método de teste e, então, depurar ao executar o teste.Para mais informações, consulte Como: Depurar ao executar um teste em um aplicativo ASP.Solução de NET.

Exemplo 2: Usando uma restrição de tipo

Este exemplo mostra um teste de unidade de um método genérico que usa uma restrição de tipo não é satisfeita.A primeira seção mostra o código do projeto de código sob teste.A restrição de tipo é realçada.

A segunda seção mostra o código do projeto de teste.

Projeto de código sob teste

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;

namespace ClassLibrary2
{
    public class Employee
    {
        public Employee(string s, int i)
        {
        }
    }

    public class GenericList<T> where T : Employee
    {
        private class Node
        {
            private T data;
            public T Data
            {
                get { return data; }
                set { data = value; }
            }
        }
    }
}

Projeto de Teste

Assim como acontece com todos os testes de unidade recém-gerado, você deve adicionar instruções de Assert-inconclusive para teste de unidade para torná-lo a retornar resultados úteis.Você não adicioná-los para o método marcado com o atributo TestMethod mas para o método de "TestHelper", o que, para este teste é denominado DataTestHelper<T>().

Neste exemplo, parâmetro de tipo genérico T tem a restrição de where T : Employee.Esta restrição não é atendida no método de teste.Portanto, o DataTest() método contém uma instrução Assert que o alerta para a necessidade de fornecer a restrição de tipo que foi colocada em T.A mensagem desta instrução Assert diz da seguinte maneira:("No appropriate type parameter is found to satisfies the type constraint(s) of T. " + "Please call DataTestHelper<T>() with appropriate type parameters.");

Em outras palavras, quando você chama o DataTestHelper<T>() método a partir do método de teste, DataTest(), você deve passar um parâmetro do tipo Employee ou uma classe derivada de Employee.

using ClassLibrary2;

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace TestProject1

{
    [TestClass()]
    public class GenericList_NodeTest
    {
    
        public void DataTestHelper<T>()
            where T : Employee
        {
            GenericList_Shadow<T>.Node target = new GenericList_Shadow<T>.Node(); // TODO: Initialize to an appropriate value
            T expected = default(T); // TODO: Initialize to an appropriate value
            T actual;
            target.Data = expected;
            actual = target.Data;
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void DataTest()
        {
            Assert.Inconclusive("No appropriate type parameter is found to satisfies the type constraint(s) of T. " +
            "Please call DataTestHelper<T>() with appropriate type parameters.");
        }
    }
}

Consulte também

Conceitos

Verificando o código usando testes de unidade

Outros recursos

Anatomia de um teste de unidade