Compartilhar via


Testes de unidade para métodos genéricos

Você pode gerar testes de unidade para métodos genéricos exatamente como faria para outros métodos, conforme descrito em Como: Criar e executar 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, como MyList<T>, ele gera dois métodos: um auxiliar genérico e um método de teste. Se MyList<T> tem um ou mais restrições de tipo, o argumento de tipo deve satisfazer a todo o tipo de restrições. Para certificar-se de que a classe genérica código sob teste funciona conforme o esperado para entradas todos os permitidos, o método de teste chama o método auxiliar genérico com as restrições que você deseja testar.

Exemplos

Os exemplos a seguir ilustram os testes de unidade para 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 raw é 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 para 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 de código under 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 de código de teste gerado, mostra o código de teste não-editadas como ela foi gerada pelo Visual Studio Premium ou Visual Studio Ultimate. O segundo exemplo, na seção de código de teste editada, mostra como você pode torná-lo a testar o funcionamento do método SizeOfLinkedList de dois diferentes tipos de dados, 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" em 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 de SizeOfLinkedList() método. Como esse é o teste gerados não-editado, deve ser modificado 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. Enquanto você pode 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 editada

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 de 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 de 1 a 5.

  1. Crie uma lista vinculada genérica.

  2. Acrescente a 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 no 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çãoObservação

Cada vez que o teste de SizeOfLinkedListTest é executado, o TestHelper método é chamado duas vezes. A instrução assert deve ser avaliada como true para o teste passe sempre. Se o teste falhar, talvez não seja claro se a chamada especificada <int> ou a chamada que está especificado <char> deixá-lo a falhar. 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 obter mais informações, consulte Como: Depure 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 para 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 under teste. A restrição de tipo é realçada.

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

Projeto de código Under 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

Como ocorre com todos os testes de unidade recém-gerado, você deve adicionar instruções de Assert-inconclusive desse 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 "testhelper" método, que, para este teste é denominado DataTestHelper<T>().

Neste exemplo, parâmetro de tipo genérico T tem a restrição where T : Employee. Essa restrição não é atendida no método de teste. Portanto, o DataTest() método contém uma instrução Assert que avisa à necessidade de fornecer a restrição de tipo que foi colocada na T. A mensagem desta instrução Assert lê como segue: ("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>() o método 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

Anatomia de um teste de unidade

Verificando o código usando testes de unidade