Testes de unidade para métodos genéricos
Você pode gerar teste de unidade para métodos genéricos exatamente como você faria para outros métodos, como descrito em Como: criar e executa um teste de unidade.As seções a seguir fornecem informações e exemplos de criar teste de unidade para métodos genéricos.
Argumentos de tipo e restrições do tipo
Quando Visual Studio gerencie um teste de unidade para uma classe genérico, como MyList<T>, gerenciar 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 do tipo deve satisfazer todas as restrições de tipo.Para garantir que o código genérico em trabalhos de teste como esperado para todas as entradas permitidas, o método de teste chama o método auxiliar genérica com todas as restrições que você deseja testar.
Exemplos
Os exemplos a seguir ilustram teste de unidade para produtos genéricas:
Editar o código de teste gerado.Este exemplo tem duas seções, o código de teste gerado e o código de teste editado.Mostra como editar o código de teste bruto que é gerado a partir de um método genérico em um método útil de teste.
Usando uma restrição de tipo.Este exemplo mostra um teste de unidade de um método genérico que use uma restrição de tipo.Neste exemplo, a restrição de tipo não for satisfeita.
Exemplo 1: Editar o código de teste gerado
O código de teste nesta seção testa um método de código-sob- teste nomeada SizeOfLinkedList().Esse método retorna um inteiro que especifica o número de nós na lista vinculada.
A primeira exemplo de código, no código de teste gerado, seção a seguir mostra o código de teste não editado como foi gerada por Visual Studio Premium ou por Visual Studio Ultimate.O segundo exemplo, no código de teste editado seção, mostra como você pode fazer o testar a operação do método de SizeOfLinkedList para dois tipos de dados, int e chardiferentes.
Este código a seguir ilustra dois métodos:
um método auxiliar de teste, SizeOfLinkedListTestHelper<T>().Por padrão, um método auxiliar de teste “tem TestHelper” no nome.
um método de teste, SizeOfLinkedListTest().Cada método de teste é marcado com o atributo de TestMethod.
Código de teste gerado
O seguinte código de teste foi gerado a partir do método de SizeOfLinkedList() .Como esse é o teste gerado não editado, deve ser alterado para testar corretamente o método de 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.Embora seja possível editar o para fornecer tipos de dados específicos, como mostrado no seguinte exemplo, 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 foi editado para fazer com êxito testar o método SizeOfLinkedList()de código-sob- teste.
Método auxiliar de teste
O método auxiliar de teste executa as seguintes etapas, que correspondem às linhas no código chamado etapa 1 para a etapa 5.
Crie uma lista vinculada genérico.
Anexar quatro nós à lista vinculada.O tipo de dados de conteúdo desses nós é desconhecido.
Atribuir o tamanho esperado da lista vinculada a expectedvariável.
Calcule o tamanho real da lista vinculada e atribuí-lo a actualvariável.
Compare actual com expected em uma instrução declare.Se o real não é igual à esperada, o teste falhar.
Método de teste
O método de teste é compilado em código que é chamado quando você executa o teste nomeada SizeOfLinkedListTest.Executa as seguintes etapas, que correspondem às linhas no código chamado etapa 6 e etapa 7.
Especifique <int> quando você chama o método auxiliar de teste, para verificar se o trabalho de teste para variáveis de integer .
Especifique <char> quando você chama o método auxiliar de teste, para verificar se o trabalho de teste para variáveis de char .
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
}
.gif "Observação") Observação |
|---|
Cada vez que as execuções de teste de SizeOfLinkedListTest, o método de TestHelper são chamados duas vezes em.A instrução declare deve avaliar para retificar todas as vezes para que o teste definido.Se o teste falhar, talvez não seja claro se a chamada que especificou <int> ou a chamada que especificaram <char> o causou a falha.Para localizar a resposta, você pode examinar a pilha de chamadas, ou você pode definir pontos de interrupção em seu método de teste e depois depurar-los durante a execução do teste.Para obter mais informações, consulte Como depurar durante a execução de um teste em uma solução do ASP.NET. |
Exemplo 2: Usando uma restrição de tipo
Este exemplo mostra um teste de unidade de um método genérico que use uma restrição de tipo que não é atendida.O primeiro código mostra a seção de projeto de código-sob- teste.A restrição de tipo é destacada.
O segundo código mostra a seção de 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
Como com qualquer teste recentemente gerados de unidade, você deve adicionar não inconsequente afirma instruções para esse teste de unidade para torná-lo retornar resultados úteis.Você não adiciona ao método marcado com o atributo de TestMethod mas o método de “TestHelper”, que para este teste é nomeada DataTestHelper<T>().
Neste exemplo, o parâmetro de tipo genérico T tem a restrição where T : Employee.Essa restrição não for satisfeita no método de teste.Em virtude disso, o método de DataTest() contém uma instrução declare alertas que você fornecer ao requisito a restrição de tipo que foi colocada em T.A mensagem desta afirma leitura da instrução seguinte maneira: ("No appropriate type parameter is found to satisfies the type constraint(s) of T. " + "Please call DataTestHelper<T>() with appropriate type parameters.");
Ou seja quando você chama o método de DataTestHelper<T>() do método de teste, DataTest(), você deve transmitir um parâmetro de 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 código usando testes de unidade