• Artigo

Este artigo foi traduzido por máquina.

Execução de Testes

Parcial Antirandom seqüência de teste

James McCaffrey

Baixar o código de exemplo

Antirandom (AR) teste é uma variação do teste aleatório puro, que é o processo de geração aleatória de entrada e envio que a entrada para um sistema em teste.Na maioria das situações, entrada de teste aleatório não tem um associado explícito retorno valor ou sistema estado esperado.Em tais situações, o objetivo do teste aleatório é tentar gerar uma falha do sistema de algum tipo, como um travar ou falha.Pesquisa os estudos mostram que teste aleatório puro é relativamente menos eficiente em descobrir bugs que outros paradigmas de testes, como testes de partição a equivalência e teste de análise de valor de limite.No entanto, teste aleatório é atraente, pois normalmente é rápida e fácil de implementar.A idéia de AR teste parece foram introduzidos pelo campo de teste de hardware.Essencialmente, testes de AR gera um conjunto de entrada de valores aleatórios, onde os valores são tão diferentes quanto possível uns dos outros.Pressupõe-se que entrada semelhante a um sistema irá expor tipos semelhantes de bugs e, portanto, um conjunto de entrada que contêm valores que são muito diferentes uns dos outros tem uma probabilidade maior de expor erros em um sistema de software.

Figura 1 de geração parcial AR seqüências

Aqui está um exemplo.Suponha que um sistema de hardware tem um parâmetro que aceita valores 3 bits.O domínio de entrada completo, portanto, tem oito valores: {000, 001, 010, 011, 100, 101, 110, 111}.Além disso, suponha que você deseja gerar um conjunto de teste que contém quatro entradas de AR porque teste completa de todos os valores de oito não é viável por algum motivo.Seu conjunto de teste de AR inicial está vazio e o valor {0,0,0} pode ser selecionado do domínio de entrada e adicionado ao conjunto de teste arbitrariamente.A próxima entrada a ser adicionado ao conjunto de teste de AR é o valor do espaço de domínio que seja mais diferente dos valores no conjunto de teste atuais.Nesse caso, o valor {1,1,1} é a mais diferente do {0,0,0} usando praticamente qualquer definição racional de diferentes, portanto, o teste de AR definir agora contém {0,0,0} e {1,1,1}.Em seguida, suponha que o valor {0,0,1} é selecionado do domínio de entrada usando o procedimento descrito abaixo e adicionados ao teste AR definir de forma que seu conjunto agora contém {0,0,0}, {1,1,1} e {0,0,1}.Qualquer um dos cinco valores restantes no domínio de entrada são candidatos para o quarto e último membro do conjunto de teste.No entanto, exatamente qual valor é escolhido depende da função de diferença usada.Uma função Candidato é a distância Hamming entre dois valores, que é apenas o número de posições onde os bits de dois valores são diferentes.A soma de distâncias Hamming entre cada valor de candidatos e os três membros atuais do conjunto de teste de AR são:

010: 1 + 2 + 2 = 5
011: 2 + 1 + 1 = 4
100: 1 + 2 + 2 = 5
101: 2 + 1 + 1 = 4
110: 2 + 1 + 3 = 6

Porque {1,1,0} é mais diferente dos membros existentes do conjunto de teste de AR, ele é adicionado ao conjunto de teste. Este exemplo aponta pura AR teste entrada geração requer uma enumeração completa de todo o domínio de entrada. Isso pode ser possível para determinados tipos de teste com um tamanho de bit de entrada relativamente pequeno de hardware ou sistemas de software com um pequeno domínio entrado. No entanto, testes de AR puro é raramente possível para sistemas de software complexos. Esta coluna apresenta uma abordagem chamo parcial AR seqüência de teste, que pode ser usada para testar uma grande variedade de sistemas de software.

A melhor maneira para explicar onde eu estou cabeças é com duas capturas de tela. A Figura 1 mostra um exemplo de como um conjunto de teste de seqüência de caracteres de AR parcial pode ser gerado.

O exemplo mostrado na do Figura 1 se baseia em um sistema de pôquer sete-cartão de algum tipo. Cada seqüência representa sete cartões onde 'A'representa um ás;MENSAGEM 'representa um 10;e seria 'c', ', 'h'e do 'representam paus, ouros, copas e espadas. Se forem permitidas duplicatas, o número total de seqüências de caracteres de entrada é 52 elevado à potência sétima = 1,028,071,702,528, que é provável que seja impossível de gerenciar na maioria das situações teste. AR teste definida geração começa criando um domínio de entrada substituto, que é um subconjunto de todo o domínio entrado selecionado aleatoriamente. Aqui eu uso um tamanho de domínio substituto artificialmente pequeno de seqüências de 10 caracteres para manter meu exemplo curto. O tamanho do conjunto de teste AR é definido como três, novamente artificialmente pequeno para fins de demonstração. O conjunto de teste de AR é inicialmente vazio;a seqüência de caracteres do primeira valor do domínio substituto, "Ts qui 3 h Qd Kd 4d 9 d," é adicionado para o AR definido. Em seguida, o programa de demonstração examina cada um das seqüências de caracteres no domínio substituto para localizar a seqüência de caracteres que seja mais diferente da única seqüência de caracteres no conjunto de AR. Nesse caso, a seqüência de caracteres "c 3 9 h 9s 3s como 9 c c 2"está selecionado como mais diferente. Explicarei como a computação de diferença é executada em breve. Em seguida, o programa de demonstração rescans domínio substituto para localizar o valor de seqüência de caracteres que é mais diferente de ambas as duas seqüências no momento no conjunto de teste de AR. Após esse valor final, "9 d Js Js Kd 7 h 5d jc", é determinada e adicionado ao conjunto de AR, o programa de demonstração exibe o conjunto final. O resultado é um conjunto de entradas de teste que contém seqüências de caracteres que são mais diferentes uns dos outros que seria o caso se as seqüências de caracteres tinham sido escolhidas aleatoriamente.


Figura 2 teste com AR parcial seqüências

Figura 3 estrutura do teste de AR parcial definir geração

using System;
namespace Demo
{
class Program
{
static Random r = new Random(0);
static void Main(string[] args)
{
try
{
Console.WriteLine(
"\nBegin partial antirandom string generation demo”);
long domainSize = (long)Math.Pow(52, 7); // 1,028,071,702,528
int surrogateDomainSize = 8;
int antiRandomTestSetSize = 3;
// display sizes of input domain, surrogate domain,
antirandom test set
// initialize and display surrogate domain
// create partial antirandom test set
// display partial antirandom test set
}
catch (Exception ex)
{
Console.WriteLine("Fatal: " + ex.Message);
Console.ReadLine();
}
} // Main()
} // class
} // ns

A captura de tela no do Figura 2 mostra uma maneira na qual seqüências de AR parciais podem ser usadas para testar um sistema. Estou testando um módulo PokerLib.dll hipotético que aceita uma cadeia de caracteres que representa uma mão de pôquer sete cartão conforme descrito anteriormente. A idéia é gerar conjuntos de teste de AR parciais repetidamente e enviar a todos os valores a seqüência de caracteres em cada teste definidos para o sistema em teste. Nessa situação, impõe um número arbitrário máximo de ciclos de 1.000.000. A demonstração mostrada na Figura 2 usa um tamanho de entrada de substitutos de 100 e um teste de AR parcial Definir tamanho de 10. Codifiquei o sistema PokerLib.dll hipotético em teste para produzir rapidamente uma exceção para demonstrar o que você espera acontece ao executar AR parcial de teste, que é produzir um erro.

Nesta coluna, uso o termos AR teste, testes de AR parcial e seqüência AR parcial testes mais ou menos alternadamente. Refere-no entanto, na literatura de pesquisa acadêmica, testes de AR geralmente se ao processo descrito onde os valores de entrada são binários e todo o domínio de entrada é verificado para determinar os valores de AR conjunto de teste. Uso o termo "parcial"para distinguir a técnica descrita aqui, que examina um domínio substituto, de "pura"AR de teste.

As seções a seguir, irá apresentar e explique o código gerado capturas de tela mostradas nas figuras 1 de e 2. Em particular, descreverei técnicas diferentes que você pode usar para determinar a diferença entre duas seqüências de caracteres e quando cada técnica é apropriada. Também apresentarei algumas diretrizes sobre como selecionar o tamanho do domínio substitutos e o teste de AR Definir tamanho. Suponho que você tem início a intermediário nível habilidades de programação. Meus exemplos são codificados com translation from VPE for Csharp, mas você deve ser capaz de facilmente recast meu código em outros idiomas, incluindo o VB.NET, Java, Perl e PowerShell. Tenho certeza de que você encontrará parcial AR teste um tópico interessante e que a capacidade de testar sistemas usando seqüências de AR parciais pode ser um acréscimo valioso para seu teste kit de ferramentas.

Gerar strings de AR parcial

O código no do Figura 3 é a estrutura geral do programa que gerou a captura de tela mostrada na do Figura 1.

É criar um projeto translation from VPE for Csharp Console Application chamado demonstração usando Visual Studio 2008. Minha geração AR parcial não usa qualquer especializados namespaces do .NET Framework, para excluído a gerada automaticamente usando instruções, exceto para o que faz referência ao namespace System raiz. Eu instancio um objeto de Random usando um valor semente de 0:

static Random r = new Random(0);

Eu fornecer um valor semente para o construtor de Random em vez de usar o construtor padrão sem uma semente, para que minha saída será pode ser reproduzida. Para maior clareza e simplicidade, em toda esta coluna uso o termo "aleatório"em vez de mais precisas "pseudoaleatórios." Depois de exibir uma mensagem de início, uso o método Math.pow() para calcular o número total de seqüências de caracteres no domínio de entrada para o cenário de teste. Tecnicamente, não preciso essas informações, mas ele serve para destacar que testes de seqüência de caracteres de AR parcial é normalmente útil em situações em que há muitas entradas para testar exaustivamente. Nessa situação, uma seqüência de caracteres de entrada representa uma mão de cartas de sete e tem a forma "Rs Rs Rs Rs Rs Rs RS", onde R é um dos valores de classificação 13 ("A", "T", "2 a 9", "J", "P","K") e "s"é um dos quatro valores de naipe ("c", "d", "h", "s"). Cada cartão pode ser uma das 13 * 4 = 52 possibilidades, e, portanto, com duplicatas permitidas, o número total de seqüências de caracteres possíveis é 52 elevado à potência sétima.

Figura 4 gerando um String cartão aleatório

public static string MakeARandomCard()
{
string answer = "";
int rank = r.Next(1, 14); // 1-13
int suit = r.Next(1, 5); // 1-4
if (rank == 1) answer += "A";
else if (rank == 10) answer += "T";
else if (rank == 11) answer += "J";
else if (rank == 12) answer += "Q";
else if (rank == 13) answer += "K";
else answer += rank.ToString(); // 2 thru 9
if (suit == 1) answer += "c";
else if (suit == 2) answer += "d";
else if (suit == 3) answer += "h";
else answer += "s";
return answer;
}

Em seguida, defino os tamanhos do domínio de substitutos e o teste definida para oito e três, respectivamente. Esses tamanhos são muito menores do que aquelas que normalmente você deseja usar em um ambiente de produção. Falarei sobre os problemas relacionados a escolher esses tamanhos em breve. Eu inicializar domínio substituto chamando um método auxiliar chamado MakeARandomDomainString():

Console.WriteLine("\nGenerating surrogate domain");
for (int i = 0; i < surrogateDomain.Length; ++i)
  surrogateDomain[i] = MakeARandomDomainString();

O código para o método auxiliar é:

public static string MakeARandomDomainString()
{
  string answer = "";
  for (int c = 0; c < 6; ++c) // first 6 cards
    answer += MakeARandomCard() + " ";
  
  answer += MakeARandomCard(); // last card, no trailing space
  return answer;
}

Quando usando parcial AR testes, cada cenário de teste terá um formato de seqüência de caracteres diferentes de entrada. Em um extremo, você não pode ter nenhuma restrição em formato de seqüência de caracteres de entrada diferente de comprimento. Em tais situações, você precisará simplesmente gerar seqüências de caracteres totalmente aleatórias. No meu exemplo, tenho um formato bem estruturado. Em geral, a utilidade da seqüência de AR parcial teste aumenta como a estrutura da entrada de seqüências de caracteres aumenta. O método MakeARandomDomainString() simplesmente gera uma seqüência que representa sete cartões iterativamente chamando um método auxiliar MakeARandomCard(), conforme mostrado no do Figura 4.

Uso o objeto de Random, instanciado anteriormente para produzir dois pseudoaleatórios inteiros no intervalo [1,13] e [1,4], respectivamente. Observe que os dois parâmetros para o método Random.Next() representam o limite inferior inclusive e o limite superior exclusivo, portanto, r.Next(1,14) gera um inteiro aleatório entre um e 13 inclusive em vez de entre um e 14. Uso o operador += sobrecarregado para criar seqüência de caracteres meu cartão em vez da classe StringBuilder mais eficiente do namespace System.Text. No decorrer deste artigo, eu usar técnicas de programação genéricas para que mais facilmente você pode refatorar meu código de exemplo em outras linguagens de programação. Além disso, ter codifiquei meu exemplo usando um estilo tradicional não OOP para que você pode refatorar facilmente linguagens de script com suporte limitado OOP, como JavaScript e Perl.

Depois de criar o domínio substituto, eu exibi-la:

Console.WriteLine("\nThe surrogate domain is: \n");
for (int i = 0; i < surrogateDomain.Length; ++i)
  Console.WriteLine("[" + i + "] " + surrogateDomain[i]);

Neste exemplo, eu não verificar valores duplicados no domínio substituto. Em geral, o esforço necessário para evitar duplicatas no domínio substituto é muito grande justificar o benefício obtido. Lembre-se que a aparência principal de técnicas de testes aleatórias é simplicidade. Além disso, como você verá em breve, valores duplicados no domínio substitutos são altamente improvável de ser colocado no conjunto de teste de AR. Agora estou pronto para gerar o conjunto de teste de AR parcial. O código na Figura 5 mostra como fazer isso. Começo, selecionando o primeiro valor no domínio substitutos e colocá-lo no conjunto de teste de AR:

Console.WriteLine("Adding " + surrogateDomain[0] + " to AR test set");
antiRandomTestSet[0] = surrogateDomain[0];
int numberValuesInTestSet = 1;

Como as seqüências de caracteres no domínio substitutos são geradas aleatoriamente, na maioria das situações não há nenhuma vantagem na seleção de uma determinada seqüência de caracteres. Uso um numberValuesInTestSet variável para manter o controle de muitas como cadeias de caracteres atualmente no teste de AR definidas.

Figura 5 código para gerar um teste de AR parcial definir

for (int k = 1; k < antiRandomTestSet.Length; ++k) {
int largestTotalDeltaForAllI = 0;
int indexOfBestCandidate = 0;
int totalDeltaForCurrentI = 0;
for (int i = 0; i < surrogateDomain.Length; ++i) {
totalDeltaForCurrentI = 0;
for (int j = 0; j < numberValuesInTestSet; ++j) {
totalDeltaForCurrentI +=
RotateDistance(surrogateDomain[i], antiRandomTestSet[j]);
} // j
if (totalDeltaForCurrentI > largestTotalDeltaForAllI) {
largestTotalDeltaForAllI = totalDeltaForCurrentI;
indexOfBestCandidate = i;
}
} // i
Console.WriteLine("\nDetermining antirandom value: [" + k + "]");
Console.WriteLine(
"String at [" + indexOfBestCandidate + "] in surrogate domain");
Console.WriteLine(
"is most different from strings curently in AR test set");
Console.WriteLine(“Adding " + surrogateDomain[indexOfBestCandidate] +
" to AR test set");
antiRandomTestSet[numberValuesInTestSet++] =
surrogateDomain[indexOfBestCandidate];
} // k

Mais externo para loop com variável de índice k é usado para aponte para e preencher cada célula no conjunto de teste de AR. Iniciar no valor k = 1, pois eu propagado a primeira célula o teste de AR definida no índice 0 com o primeiro valor no domínio substituto. Como o objetivo é localizar a seqüência de caracteres no domínio substituto mais diferente de todas as seqüências no momento no conjunto de teste de AR, crio largestTotalDeltaForAllI variável para controlar um valor que representa a maior diferença encontrada. Também inicializo uma variável indexOfBestCandidate para registro onde no domínio substituto a seqüência de caracteres com o maior valor de diferença foi encontrada.

Figura 6 Levenshtein distância

public static int LevenshteinDistance(string s, string t) // assume s, t
not null
{
int[,] dist = new int[s.Length + 1, t.Length + 1]; // distance
int subCost; // substitution cost
if (s.Length == 0) return t.Length;
if (t.Length == 0) return s.Length;
for (int i = 0; i <= s.Length; ++i)
dist[i,0] = i;
for (int j = 0; j <= t.Length; ++j)
dist[0,j] = j;
for (int i = 1; i <= s.Length; i++) {
for (int j = 1; j <= t.Length; j++) {
if (t[j-1] == s[i-1])
subCost = 0;
else
subCost = 1;
int temp = Math.Min(dist[i - 1, j] + 1, dist[i, j - 1] + 1);
dist[i, j] = Math.Min(temp, dist[i - 1, j - 1] + subCost);
}
}
return dist[s.Length, t.Length];
}

A próxima para loop com índice variável i itera em cada seqüência de candidato no domínio substituto. Após inicializar uma variável totalDeltaForCurrentI para 0, uso o aninhados para loop com variável de índice j para buscar cada uma das cadeias de caracteres atualmente no conjunto de teste de AR. Portanto, neste ponto, índice k (e variável numberValuesInTestSet) apontam para a próxima célula vazia no conjunto de teste de AR, índice i aponta para uma seqüência de candidato no domínio substituto, e índice j aponta para uma seqüência de caracteres atualmente no AR conjunto de teste. Agora eu determinar a diferença entre as duas seqüências apontado pelo i e j e acumular essa diferença para o total em execução para a atual seqüência candidato no domínio substituto:

totalDeltaForCurrentI +=
RotateDistance(surrogateDomain[i], antiRandomTestSet[j]);

A chamada ao método auxiliar RotateDistance() é importante e discutirei em apenas um momento. Se a soma de distância entre a seqüência de caracteres candidato e todas as seqüências no conjunto de teste de AR for maior que maior valor de soma de distâncias meu atual, atualizo minhas variáveis de controle:

if (totalDeltaForCurrentI > largestTotalDeltaForAllI) {
largestTotalDeltaForAllI = totalDeltaForCurrentI;
indexOfBestCandidate = i;
}

Lembre-se que o objetivo do teste de seqüência de caracteres de AR parcial é gerar strings que são tão diferentes quanto possível uns dos outros. Após imprimir algumas mensagens de andamento para o shell de comando, adiciono o melhor candidato encontrado no domínio substituto para o conjunto de teste de AR e a atualização o número de valores no conjunto de teste:

antiRandomTestSet[numberValuesInTestSet++] =
  surrogateDomain[indexOfBestCandidate];

Porque o índice k e numberValuesInTestSet variável mantém o mesmo valor, eu poderia ter substituído k aqui. No entanto, o uso da variável mais descritivo é um pouco mais legível na minha opinião.

A diferença entre duas seqüências de computação

Ao executar seqüência AR parcial de teste, você precisa um método que computa a diferença entre duas seqüências de caracteres. Exatamente como você comparar duas seqüências de caracteres será dependem do formato das seqüências usadas em seu cenário de teste. Se as seqüências de caracteres que estejam sendo comparadas sempre tem o mesmo comprimento, uma simples possibilidade é usar a distância de Hamming baseados em caracteres, que é apenas o número de posições em qualquer seqüência de caracteres onde os caracteres são diferentes. Por exemplo, se s = "carro"e t = "sacola", a distância Hamming entre s e t é dois. Se as duas seqüências têm comprimentos diferentes, você pode usar uma distância Hamming modificada que adiciona a diferença no tamanho entre seqüência mais longa e a menor seqüência de caracteres. Por exemplo se s = "carro"e t = "cabo", a distância Hamming modificada é aquele (para 'r'vs.' b ') + 2 (para 'l'e 'e') = 3. É aqui uma maneira de implementar a distância Hamming de seqüências do mesmo tamanho:

public static int HammingDistance(string s, string t)
{
  if (s.Length != t.Length)
    throw new Exception("s and t must have same length in
      HammingDistance()");
  int ct = 0;
  for (int i = 0; i < s.Length; ++i)
    if (s[i] != t[i])
      ++ct;
  return ct;
}

Outra medida simples da diferença entre duas seqüências de caracteres é a distância cartesiano baseados em caracteres. Isso é semelhante à distância geométrica entre dois pontos, você pode se lembrar de ensino algebra. Suponha que a seqüência de caracteres s = "bat"e t = "carro". Valor de 'b' ASCIIé o valor ASCII do 'c' e 98é 99 e, portanto, a diferença entre os dois caracteres é uma. A diferença entre a mensagem 'e 'r'é dois. A distância cartesiano baseados em caracteres entre seqüências de caracteres s e t é sqrt(1^2 + 0^2 + 2^2) = 2,24. Uma maneira mais sofisticada para calcular a diferença entre duas seqüências de caracteres é a distância Levenshtein. A distância Levenshtein entre duas seqüências de caracteres é o menor número de caracteres inserções, exclusões e substituições necessárias para transformar uma seqüência para o outro. A distância Levenshtein é um tópico fascinante no seu próprio direito, mas uma discussão completa sobre ele está fora do escopo deste artigo. Figura 6 lista uma implementação simples da distância Levenshtein que você pode usar para testar a seqüência de caracteres AR parcial.

O mais estruturada suas seqüências de entrada estiverem, o mais provável que ele é um método personalizado diferença serão mais úteis que métodos de diferenças genérico, como a distância Hamming ou a distância Levenshtein. Por exemplo, no cenário meu cartão de pôquer, considere estas duas seqüências de caracteres:

s = "Ac Kd Qh Js Tc 9d 8h"
t = "Kd Qh Js Tc 9d 8h 7c"

Observe que as duas seqüências de caracteres representam mãos de pôquer que são muito semelhantes, com placas de seis de sete sendo idênticas. No entanto, a distância Hamming entre s e t é 14, e, como acontece, a distância Levenshtein é seis. Em meu cenário, implementei um método de diferença personalizado chamado RotateDistance(). RotateDistance() método tira proveito da estrutura das seqüências de mão pôquer e compara com base em cartão de valores. O código para RotateDistance() está listado na Figura 7. Meu método diferença personalizado inicia por computação a distância Hamming entre os argumentos de método de entrada:

s = "Ac Kd Qh Js Tc 9d 8h"
t = "Kd Qh Js Tc 9d 8h 7c"
distance = 14

Em seguida, RotateDistance(s,t) gira seqüência s para a esquerda por uma posição de cartão e calcula a distância Hamming novamente:

s = "Kd Qh Js Tc 9d 8h Ac"
t = "Kd Qh Js Tc 9d 8h 7c"
distance = 1

O método executa esse processo girar e comparar através de todas as posições de sete cartão e retorna a distância menor encontrada, que, neste exemplo é um. O código para o método auxiliar RotateLeft() usa String.Substring() para dividir o argumento de entrada em duas partes e, em seguida, seqüência de caracteres concatenação recombiná duas partes:

public static string RotateLeft(string s)
{
  string firstPart = s.Substring(0, 3);
  string remainder = s.Substring(3, s.Length - 3);
  string answer = remainder + " " + firstPart.Trim();
  return answer;
}

Baseado na minha experiência, quando seqüências de entrada de teste tem uma quantidade razoável de estrutura, alguma variação do algoritmo girar e comparar que descrevi geralmente é altamente eficaz. Deixe-me destacar que, mesmo se seu cenário de teste tem altamente estruturados seqüências de caracteres de entrada, você está não tem obrigação escrever um método personalizado diferença como fiz aqui. Usando um método personalizado diferença ajudará a gerar AR strings que são mais diferentes uns dos outros gerada ao usar o Hamming distância ou Levenshtein distância, mas você deve avaliar o benefício contra o esforço necessário para criar um método personalizado diferença.

Figura 7 personalizado RotateDistance() método

public static int RotateDistance(string s, string t)
{
int d = HammingDistance(s, t);
for (int compare = 1; compare <= s.Length / 3; ++compare)
{
s = RotateLeft(s);
int temp = HammingDistance(s, t);
if (temp < d)
d = temp;
}
return d;
}

Testando com seqüências de AR parcial

Seqüência de caracteres de AR parcial teste é realmente uma meta-técnica, que significa que o método é mais de um conjunto geral de diretrizes em vez de uma abordagem de estilo manual específico que pode ser aplicada em todas as situações de teste. Uma das muitas maneiras possíveis para executar testes de seqüência de caracteres de AR parcial está ilustrada na captura de tela mostrada na do Figura 2. A listagem na do Figura 8 é o código chave que gerou a captura de tela no do Figura 2.

Primeiro, eu exibir algumas mensagens de log para o shell de comando, incluindo o nome do sistema em teste, o tamanho do domínio substitutos e o AR testar tamanho do conjunto. Usar a abordagem que descrevi na seção anterior, se o domínio substituto tem tamanho m e o tamanho de teste de AR tem tamanho n, gerar o conjunto de teste de AR requer (n * (n-1) * m) / 2 iterações. Além disso, uma comparação de seqüência de caracteres é executada em cada iteração, e cada comparação requer pelo menos min(length(s),length(t)) caractere comparações. O ponto está gerando um conjunto de teste AR parcial em que você especificar um tamanho de domínio grande substituto, e um tamanho de conjunto de teste de AR grande pode exigem uma quantidade significativa de tempo de processamento. Quanto maior esses dois tamanhos são, melhor o seu conjunto de teste AR será em termos de diversidade de entrada de seqüência de caracteres de teste, mas o tempo necessário para gerar o conjunto de teste de AR reduz o número de entradas realmente enviado para o sistema em teste.

Figura 8 exemplo de teste com AR parcial seqüências

int sdSize = 100;
int arSize = 10;
Console.WriteLine("\nBegin antirandom testing demo");
Console.WriteLine("System under test = PokerLib.dll module");
Console.WriteLine("Maximum number of cycles = 1,000,000");
Console.WriteLine("Surrogate domain size = " + sdSize);
Console.WriteLine("Antirandom test set size = " + arSize);
long maxNumberCycles = 100000;
int cycle = 0;
while (cycle < maxNumberCycles)
{
++cycle;
Console.WriteLine("=============================");
Console.WriteLine("Current antirandom cycle = " + cycle);
Console.WriteLine("Generating antirandom test set");
string[] arTestSet = MakeAntiRandomTestSet(sdSize, arSize);
Console.WriteLine("\nThe antirandom test set is: \n");
Console.WriteLine("[0] " + arTestSet[0]);
Console.WriteLine("[1] " + arTestSet[1]);
Console.WriteLine(" . . . . . . .");
Console.WriteLine("[9] " + arTestSet[9]);
Console.WriteLine(
"\nSending each antirandom input to system under test\n");
for (int i = 0; i < arTestSet.Length; ++i) {
PerformTest(arTestSet[i]);
}
Console.WriteLine("All antirandom input accepted by SUT\n");
}

Em seguida, eu especificar o número máximo de ciclos para gerar conjuntos de teste de AR. Em muitos cenários de testes, você deseja executar AR teste continuamente;em tais situações, você pode substituir apenas o controle ao loop com while(true). Dentro do loop de controle principal do AR, eu gerar um conjunto de teste de AR e enviar cada seqüência de teste definido como entrada para o sistema em teste. Escrevi dois métodos auxiliares pequeno. O primeiro método, MakeAntiRandomTestSet(), simplesmente encapsula o código apresentado na seção anterior:

public static string[] MakeAntiRandomTestSet(int surrogateDomainSize,
  int antirandomTestSetSize)
{
  string[] result = new string[antirandomTestSetSize];

  string[] sd = new string[surrogateDomainSize];
  // generate surrogate domain, sd
  // fill antirandom test set, result
  return result;
}

O segundo método auxiliar, PerformTest(), aceita uma seqüência de caracteres e simula o teste do sistema PokerLib.dll hipotético em teste:

public static void PerformTest(string s)
{
  if (s[1] == 'c' && s[4] == 'c') {
    throw new Exception("Exception thrown in system
      under test\n" + "for input = " + s);
  }
}

Aqui é criar uma situação em que o sistema em teste falhará se o primeiro duas placas de caso de teste de entrada são paus. Observe que eu me lembro para exibir a entrada de caso de teste que gera a falha do sistema para que o problema pode ser reproduzido e corrigido, por fim, a equipe de desenvolvimento. Seria uma pena se, após vários dias ou até mesmo semanas ou meses da execução de teste estendido de AR, induzir a uma falha catastrófica do sistema em teste e localizar o que você esqueceu de registrar a entrada que gerou o erro.

Há muitos outros padrões, que você pode usar para teste AR parcial. Em vez de usar um domínio pequeno substitutos e AR um pequeno conjunto combinado com um grande número de ciclos de teste, você talvez queira gerar um grande conjunto de teste de AR de um domínio grande substitutos e executar menos ciclos de teste. Observe que a abordagem descrita nesta seção gera um conjunto de teste de AR e usa as seqüências de caracteres no conjunto, mas não salvar qualquer um do AR testará conjuntos. Uma alternativa é escrever as seqüências de caracteres em cada AR teste definida para o armazenamento externo, como um arquivo de texto, uma planilha do Excel, ou uma tabela do SQL, como as cadeias de caracteres são gerados. Em seguida, se você desejar executar teste de regressão, já terá o preparado para o teste de entrada e sua execução de teste será muito mais rápido do que se você tinha regenerar a entrada.

Resumo

Deixe-me resumir as idéias apresentadas neste artigo. Teste de seqüência de caracteres de AR parcial é uma técnica que é útil em situações em que um sistema em teste aceita entrada de seqüência de caracteres e o tamanho do domínio entrado é muito grande para testar exaustivamente. Para executar parcial seqüência AR teste, você primeiro criar um domínio grande substituto que é um subconjunto aleatório do domínio de entrada. Em seguida, você gerar um conjunto de teste de AR que é um subconjunto do domínio substituto onde as seqüências de caracteres no conjunto de teste são maximally diferentes uns dos outros. Cada seqüência de caracteres no conjunto de teste de AR, em seguida, é enviada para o sistema em teste. Na maioria das situações, você não determinam um valor esperado explícito ou estado para cada entrada de seqüência de caracteres de AR. Em vez disso, você está tentando fazer com que o sistema em teste falha de alguma forma. A distância Hamming e a distância Levenshtein são duas técnicas genéricas para calcular um valor de diferença entre duas seqüências de caracteres. Se seu cenário de teste tiver cadeias de caracteres que têm um grau alto de estrutura, você pode criar seu próprio método de diferença seqüência personalizada. Tais métodos personalizados freqüentemente envolvem rotação de seqüência de caracteres.

Pesquisa acadêmica no campo de teste consistente de software produz resultados que sugerem que é não único melhor técnica de teste. Quando apropriado, adicionar parcial seqüência AR testes para seu esforço de teste pode ajudar você produzir software que tenha menos de bugs, é mais confiável e é mais seguro.

Dr. James McCaffrey trabalha para a Volt Information Sciences Inc., onde gerencia o treinamento técnico para engenheiros de software com base no Redmond, Wash. ’s Microsoft, campus. Ele trabalhou em vários produtos Microsoft, incluindo o Internet Explorer e o MSN Search e é autor de “ .NET Test Automation: Uma abordagem de solução de problema ” (Apress, 2006). Dr.. McCaffrey pode ser contatado pelo jmccaffrey@volt.com de ou v-jammc@microsoft.com.