Condividi tramite

Il presente articolo è stato tradotto automaticamente.

Esecuzione di test

Parziale Antirandom stringa test

James McCaffrey

Scaricare il codice di esempio

Antirandom (AR) test è una variazione di test casuali pure, ovvero il processo di generazione casuale di input e l'invio di che l'input a un sistema sottoposta a test.Nella maggior parte dei casi, input di test casuali non dispone di un'esplicita previsto restituito valore o di sistema stato associato.In tali situazioni, lo scopo di test casuali è tentare di generare un errore di sistema di qualche tipo, ad esempio un blocco o arresto anomalo del sistema.Ricerca studi hanno dimostrato che pure test casuali è relativamente meno efficaci a rilevare gli errori rispetto ai altri paradigmi di test, ad esempio equivalenza partizione test e test di analisi per valore limite.Tuttavia, test casuali è interessante perché in genere è rapido e facile da implementare.Il concetto di test AR sembra sono stati introdotti dal campo di test dell'hardware.In sostanza, AR test genera un set di input di valori casuali, in cui i valori sono i diversi possibili tra loro.Il presupposto è che input simile a un sistema esporrà tipi simili di bug e ha quindi una maggiore probabilità di esporre gli errori in un sistema software in un insieme di input che contiene valori che sono molto diversi tra loro.

Figura 1 di generazione di stringhe AR parziale

Di seguito viene indicato un esempio.Si supponga che un sistema hardware disponga di un parametro che accetta valori di bit 3.Il dominio di input completo, include pertanto otto valori: {000, 001, 010, 011, 100, 101, 110, 111}.Si supponga, inoltre generare un insieme di test che contiene quattro AR input perché test completo di tutti e otto i valori non è fattibile per qualche motivo.Il set di test AR iniziale è vuoto, e il valore {0,0,0} può essere arbitrariamente selezionato dal dominio di input e aggiunti all'insieme di test.L'input da aggiungere all'insieme di test AR successivo è il valore dallo spazio di dominio più diverso da quelli correnti nel set di test.In questo caso, il valore {1,1,1} è il massimo diverso da {0,0,0} utilizzando qualsiasi definizione razionale di diversi, in modo che il test AR imposta ora contiene {0,0,0} e {1,1,1}.Successivamente, si supponga che il valore {0, 0, 1} sia selezionato dal dominio di input utilizzando la procedura descritta di seguito e aggiunto il test AR impostano in modo che l'insieme contiene ora {0,0,0}, {1,1,1} e {0, 0, 1}.Uno dei cinque valori rimanenti nel dominio di input sono candidati per il membro quarto e ultima del set di test.Tuttavia, esattamente il valore viene scelto dipende la funzione di differenza utilizzata.Una funzione di candidati è la distanza di Hamming tra due valori, ovvero solo il numero di posizioni in cui i bit di due valori diversi.La somma delle distanze Hamming tra ogni valore candidati e i tre membri di correnti del set di test AR sono:

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

Perché {1,1,0} è più diverso da quello i membri del set di test AR esistenti, viene aggiunto all'insieme di test. In questo esempio evidenzia che pura generazione di input test AR richiede un'enumerazione completa dell'intero dominio input. Questo potrebbe essere possibile per determinati tipi di test con una dimensione in bit input relativamente piccolo di hardware o per sistemi software con un dominio input di piccole dimensioni. Tuttavia, il test AR pure è raramente possibile per i sistemi software complessi. In questa colonna viene presentato un approccio possibile chiamare parziale AR stringa test che può essere utilizzato per verificare una vasta gamma di sistemi software.

Il metodo migliore per spiegare in cui sono angolare consiste nell'utilizzare due schermate. Nella figura 1 mostra un esempio di come è possibile generare un insieme di test di stringa AR parziale.

L'esempio nell' di figura 1 è basato su un sistema poker carta di sette di qualche tipo. Ogni stringa rappresenta sette schede, dove "A"rappresenta un asso;' T 'rappresenta un 10;e d 'c', ', 'h'e del 'rappresentano fiori, rombi, cuori e picche. Se sono consentiti duplicati, il numero totale di stringhe di input è 52 elevato alla potenza settima = 1,028,071,702,528, che è probabile che sia ingestibile nella maggior parte delle situazioni di test. La generazione di impostato AR test inizia con la creazione di un dominio input surrogato, è un sottoinsieme dell'intero dominio input selezionato casualmente. Qui viene utilizzata una dimensione di dominio surrogati artificialmente piccola pari a 10 stringhe per mantenere il mio esempio breve. La dimensione di AR test set è impostata su tre, nuovamente artificialmente piccola a scopo dimostrativo. Il set di test AR è inizialmente vuoto;la prima stringa di valore dal dominio surrogato, "T V 3 h Qd KD 4D 9 d", viene aggiunto il AR impostare. Successivamente, il programma di demo esamina tutte le stringhe nel dominio surrogato per individuare la stringa più diverso dalla stringa singola nel set di AR di. In questo caso, la stringa "3c 9 h 9 3 come 9 c, c 2"è selezionata come più diversi. Verrà spiegato come viene eseguito subito il calcolo della differenza. Successivamente, il programma demo riesegue la scansione del dominio di surrogati per trovare il valore stringa più diverso da entrambe le due stringhe attualmente nel set di test di AR. Dopo tale valore finale, "d 9 Js Js KD 7 h 5 g JC", viene determinato e aggiunto all'insieme AR, il programma di esempio visualizza il set finale. Il risultato è un insieme di input di test che contiene stringhe che rappresentano più diversi tra loro più sarebbe il caso se le stringhe erano stato scelto casualmente.


Nella figura 2 test con AR parziali di stringhe

Nella figura 3 struttura di test AR parziale Imposta generazione

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

Nella schermata in di figura 2 viene mostrato un modo in cui stringhe AR parziale possono essere utilizzate per verificare un sistema. Provando un ipotetico modulo PokerLib.dll che accetta una stringa che rappresenta una mano di carta di sette poker come descritto in precedenza. L'idea è generare set di test AR parziali e inviare che tutti i valori di stringa in ogni test impostati su del sistema sotto test ripetutamente. In questo caso, È possibile imporre un numero di massimo arbitrario di cicli di 1.000.000. La demo illustrata nella figura 2 utilizza una dimensione di input di surrogati di 100 e un test AR parziale impostarne dimensioni di 10. È codificato, il sistema PokerLib.dll ipotetico sottoposta a test per produrre rapidamente un'eccezione per dimostrare la cosa che accade quando l'esecuzione parziale AR test, ovvero per generare un errore.

In questo articolo, È possibile utilizzare le termini AR test, test AR parziale e parziale stringa AR test più o meno in modo intercambiabile. Tuttavia, nella documentazione di ricerca Education, AR verifica in genere intende il processo descritto in cui i valori di input sono binari e l'intero dominio input viene analizzato per determinare i valori di AR test set. Utilizzare il termine "parziale"Per distinguere la tecnica descritta in questo caso, che analizza un dominio di surrogati, da "puro"AR test.

Nelle sezioni che seguono, verrà presentare e spiegare il codice generato le immagini riportate nelle figure 1 di e 2. In particolare, descrive diverse tecniche che è possibile utilizzare per determinare la differenza tra le due stringhe e quando ogni tecnica è appropriato. Verrà inoltre presentate alcune linee guida su come selezionare le dimensioni del dominio di surrogati e il test AR Imposta dimensioni. Supponete di che avere competenze di programmazione all'inizio di livello intermedio. Miei esempi sono codificate con C#, ma dovrebbe essere in grado di recast facilmente il codice in altre lingue, tra cui VB.NET, Java, Perl e PowerShell. Si è certo che si trova parziale AR test di un argomento interessante e che di testare i sistemi che utilizzano stringhe AR parziale possono essere un'aggiunta utile per il kit di strumento di test.

Generazione parziale AR stringhe

Il codice in di figura 3 è la struttura generale del programma che ha generato la schermata illustrata nella di figura 1.

È possibile creare un progetto di applicazione Console C# denominato demo utilizzando Visual Studio 2008. La generazione di AR parziale non utilizza qualsiasi spazi dei nomi .NET Framework specializzati, in modo che non viene eliminato il generata automaticamente utilizzando istruzioni ad eccezione di quello che fa riferimento lo spazio dei nomi radice System. Creare un'istanza di un oggetto di Random utilizzando un valore di inizializzazione pari a 0:

static Random r = new Random(0);

Fornire un valore inizializzazione al costruttore di Random invece di utilizzare il costruttore predefinito senza un valore di inizializzazione, in modo che l'output sarà riproducibile. Per maggiore chiarezza e semplicità, in questo articolo utilizzerò il termine "casuale"anziché maggiori saranno la precisione "pseudocasuale." Dopo aver visualizzato un messaggio di avvio, È possibile utilizzare il metodo Math.Pow() per calcolare il numero totale di stringhe del dominio di input per lo scenario di test. Tecnicamente, queste informazioni non sono necessarie, ma consente di sottolineare che la stringa AR parziale test è in genere utile in situazioni in cui sono presenti troppi input per verificare exhaustively. In questo caso, una stringa di input rappresenta una mano di sette schede e ha il formato "Rs Rs Rs Rs Rs Rs RS", dove R è uno dei valori di rango 13 ("A", "T", "da 2 a 9", "J", "D","K") e "s"è uno dei quattro valori seme ("c", "d", "h", "s"). Ogni scheda di possibili valori sono 4 = 13 * 52 possibilità, e con duplicati consentiti, il numero totale di stringhe possibili è 52 elevato alla potenza settima.

Nella figura 4 generazione di una stringa casuale di scheda

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;
}

Successivamente, È possibile impostare le dimensioni del dominio di surrogati e impostati rispettivamente su otto e tre, il test. Queste dimensioni sono minori rispetto a quelle che normalmente si utilizzerebbe in un ambiente di produzione. Illustrerò i problemi relativi alla scelta di queste dimensioni al più presto. È possibile inizializzare il dominio di surrogati chiamando un metodo di supporto denominato MakeARandomDomainString():

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

Il codice per il metodo di supporto è:

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 si utilizza parziale AR test, è necessario che ogni scenario di test avrà un formato stringa di input diversi. Un estremo, può essere necessario senza vincoli sul formato di stringa di input diversa lunghezza. In tali situazioni, è necessario generare semplicemente delle stringhe completamente casuali. In questo esempio, ha un formato ben strutturato. In generale, l'utilità della stringa di AR parziale test aumenta della struttura dell'input di stringhe aumenta. Il metodo di MakeARandomDomainString() genera semplicemente una stringa che rappresenta le sette schede chiamando modo iterativo un metodo di supporto MakeARandomCard(), come illustrato in di figura 4.

Utilizzare l'oggetto Random creata un'istanza precedente per produrre due numeri interi pseudocasuale compreso nell'intervallo [1,13] e [1,4], rispettivamente. Si noti che due parametri per il metodo Random.Next() rappresentano il limite inferiore inclusivo e il limite superiore esclusivo, in modo r.Next(1,14) genera un numero intero casuale compreso tra uno e 13 inclusi anziché compreso tra 1 e 14. Viene utilizzato l'operatore += di overload per creare la stringa di scheda, anziché la classe StringBuilder più efficiente di spazio dei nomi System.Text. In questo articolo, È necessario utilizzare tecniche di programmazione generiche in modo che più semplice possibile il refactoring del codice di esempio in altri linguaggi di programmazione. Inoltre, dispone di codificato mio esempio utilizzando uno stile di non OOP tradizionale in modo che possono facilmente il refactoring a linguaggi di script con supporto limitato OOP, ad esempio JavaScript e Perl.

Dopo aver creato il dominio di surrogati, è possibile visualizzarlo:

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

In questo esempio, è possibile non controllare valori duplicati nel dominio di surrogati. In generale, lo sforzo richiesto per evitare duplicati nel dominio di surrogati è troppo grande giustificare il vantaggio ottenuto. Tenere presente che il principale attrattiva di tecniche di testing casuale è la semplicità. Inoltre, come vedremo tra breve, i valori duplicati nel dominio di surrogati sono estremamente improbabile essere inserito nel set di test AR. Ora tra si potrà generare il set di test AR parziale. Il codice nella figura 5 mostra come è possibile farlo. Innanzitutto selezionare il valore primo nel dominio di surrogati e inserirla nel set di test AR:

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

Poiché le stringhe del dominio di surrogati sono generate in modo casuale, nella maggior parte delle situazioni non c'è alcun vantaggio in selezionare una determinata stringa. Viene utilizzata una variabile numberValuesInTestSet per tenere traccia di quanti stringhe attualmente nel test AR impostate.

Nella figura 5 codice per generare un test AR parziale impostare

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

Viene utilizzato più esterno per il ciclo con la variabile di indice k per punto e popolare il set di test AR ogni cella. Avvio al valore k = 1, poiché la prima cella del test AR impostare corrispondenza dell'indice 0 con il primo valore nel dominio di surrogati di seeding. Poiché l'obiettivo è trovare la stringa nel dominio surrogati più diverso da tutte le stringhe attualmente nel set di test di AR, È possibile creare largestTotalDeltaForAllI variabile per tenere traccia un valore che rappresenta la più grande differenza trovata. Anche inizializzare una variabile indexOfBestCandidate a record in cui nel dominio di surrogati è stata trovata la stringa con il valore più grande di differenza.

Nella figura 6 Distance Levenshtein

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];
}

Al successivo ciclo con indice variabile i for scorre da ogni stringa candidato nel dominio di surrogati. Dopo l'inizializzazione di una variabile totalDeltaForCurrentI su 0, viene utilizzato il nidificati per ciclo con j la variabile di indice per recuperare tutte le stringhe attualmente nel set di test di AR di. In questo modo, a questo punto, indice k (e variabile numberValuesInTestSet) scegliere cella vuota successiva nel set di test AR indice i punta a una stringa di candidati nel dominio di surrogati, e punti j indice attualmente una stringa nel AR test set. Ora determinare la differenza tra le due stringhe a cui fa riferimento i e j e che si accumulino tale differenza al totale parziale per la stringa corrente del candidato nel dominio di surrogati:

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

La chiamata al metodo di supporto RotateDistance() è importante e verrà illustrato solo a breve. Se la somma di distanze tra la stringa di candidati e tutte le stringhe nel set di test AR è maggiore del valore di somma di distanze più grande corrente, è possibile aggiornare le variabili di rilevamento:

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

È importante ricordare che il punto di stringa AR parziale test intero è per generare stringhe che rappresentano i diverse possibili tra loro. Dopo aver stampato alcuni messaggi di stato per la shell dei comandi, È possibile aggiungere del candidato migliore trovato nel dominio surrogato per il set di test AR e l'aggiornamento il numero di valori nel set di test:

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

Poiché entrambi indice k e variabile numberValuesInTestSet contenere lo stesso valore, Impossibile sono sostituiti k qui. Tuttavia, l'utilizzo della variabile più descrittiva è un po' più leggibile a mio parere.

Calcolo della differenza tra due stringhe

Quando si esegue parziale stringa AR test, è necessario un metodo che calcola la differenza tra le due stringhe. Esattamente come si confrontano due stringhe dipende il formato delle stringhe utilizzate nello scenario di test. Se le stringhe vengono confrontate sempre la stessa lunghezza, una semplice possibilità consiste nell'utilizzare la distanza di Hamming basati su caratteri, ovvero solo il numero di posizioni in una stringa in cui diversi caratteri. Ad esempio, se s = "automobile"e t = "bag", la distanza di Hamming tra s e t è due. Se le due stringhe hanno lunghezze diverse, è possibile utilizzare una distanza Hamming modificata che aggiunge la differenza di dimensioni tra la stringa più lunga e la stringa più breve. Ad esempio se s = "automobile"e t = "cavo", la distanza di Hamming modificata è una (per 'r'VS.' b ") + 2 (per"l"e "e") = 3. Di seguito è un modo per implementare la distanza Hamming per stringhe della stessa dimensione:

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;
}

Un'altra misura semplice della differenza tra le due stringhe è a distanza cartesiana basati su caratteri. Questo è simile alla distanza tra due punti, che è possibile ricordare in merito-scuole algebra geometrica. Si supponga che la stringa s = "bat"e t = "automobile". Il valore ASCII del "b"98 e il valore ASCII del "c"è 99 e pertanto la differenza tra i due caratteri è uno. La differenza tra ' t 'e 'r'è due. La distanza di cartesiana basati su caratteri ad oggetti tra stringhe s e t è sqrt(1^2 + 0^2 + 2^2) = 2.24. Un modo più sofisticato per calcolare la differenza tra le due stringhe è la distanza di Levenshtein. La distanza di Levenshtein tra due stringhe è il numero minimo di caratteri inserimenti, eliminazioni e sostituzioni necessarie per trasformare una stringa a altro. La distanza Levenshtein è un argomento interessante di diritti propri, ma una trattazione completa delle esula dall'ambito di questo articolo. Nella figura 6 elenca una semplice implementazione della distanza Levenshtein che puoi utilizzare per la stringa AR parziale verifica.

Più strutturato le stringhe di input sono, il più probabile è che un metodo personalizzato differenza più metodi di differenze generico, ad esempio la distanza Hamming o la distanza Levenshtein utile. Nello scenario del poker carta consideri ad esempio, questi due stringhe:

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

Si noti che le due stringhe rappresentano mani poker che sono molto simili, con sei di sette schede da identici. Tuttavia, la distanza Hamming tra s e t è 14, e in realtà, la distanza di Levenshtein è sei. In mio scenario, ho implementato un metodo di differenza personalizzato denominato RotateDistance(). Metodo sfrutta la struttura delle stringhe di mano poker e confronta il RotateDistance() dipende dalla scheda valori. Il codice per RotateDistance() è elencato nella figura 7. Il metodo personalizzato differenza inizia calcolando la distanza di Hamming tra gli argomenti di input del metodo:

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

Quindi, RotateDistance(s,t) Ruota stringa s a sinistra di una scheda posizione e calcola la distanza Hamming nuovamente:

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

Il metodo esegue il processo di rotazione-e-confronto tramite tutte le scheda sette posizioni e restituisce la distanza minima trovata, in questo esempio è uno. Il codice per il metodo di supporto RotateLeft() utilizza String.Substring() per interrompere l'argomento di input in due parti e quindi stringa concatenazione per ricombinare le due parti:

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;
}

In base alla mia esperienza, in quando le stringhe di input di test dispongono di una notevole quantità di struttura, alcune variazioni dell'algoritmo ruotare-e-confronto che ho descritto spesso sono molto efficace. Consenti di sottolineare che anche se lo scenario di test è altamente strutturato di stringhe di input, sono in alcun obbligo di scrivere un metodo personalizzato differenza come ho fatto qui. Utilizzando un metodo personalizzato differenza consente di generare stringhe AR più diverse tra loro rispetto a quelli prodotto utilizzando Levenshtein distanza o al Hamming distanza, ma è necessario valutare il vantaggio contro lo sforzo richiesto per creare un metodo personalizzato differenza.

Nella figura 7 personalizzato RotateDistance() metodo

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;
}

Test con stringhe AR parziale

Stringa AR parziale test è realmente una meta-tecnica, ovvero che il metodo è più di un insieme generale di linee guida piuttosto che un approccio di libro di cucina-stile specifico che può essere applicato in tutte le situazioni di test. Uno dei molti possibili modi per eseguire test parziale di stringa AR è illustrato nella schermata nell' di figura 2. L'elenco in di figura 8 è il codice del tasto che ha generato la schermata in di figura 2.

In primo luogo, È possibile visualizzare alcuni messaggi di registrazione alla shell di comando, incluso il nome del sistema sottoposta a test, la dimensione del dominio di surrogati e il AR dimensioni del set di test. Utilizzare l'approccio descritto nella sezione precedente, se il dominio di surrogati ha dimensioni m e la dimensione di test AR corrisponde a n dimensioni, generare il set di test AR è necessario (n * (n-1) * m) / 2 iterazioni. Inoltre, un confronto tra stringhe viene eseguito in ogni iterazione e ogni confronto richiede almeno min(length(s),length(t)) carattere confronti. Il punto di sta generando un insieme di test AR parziale in cui specificare una dimensione di dominio di surrogati di grandi dimensioni, e un grande set AR test è in possibile di richiedere una notevole quantità di tempo di elaborazione. Sono queste due dimensioni maggiori, migliore il set di test AR sarà in termini di diversità di input stringa di test, ma il tempo necessario per generare il set di test AR riduce il numero di input effettivamente inviati al sistema sottoposta a test.

Nella figura 8 esempio di test con AR parziale stringhe

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");
}

Successivamente è necessario specificare il numero massimo di cicli per generare AR test set. In molti scenari di testing, si desidera eseguire AR verifica continuamente;in tali situazioni, è possibile sostituire solo il controllo durante un ciclo con while(true). All'interno del ciclo di controllo AR principale, genera un set di test AR e inviarle ogni stringa dal test impostare come input per il sistema da testare. Ho scritto due metodi di supporto di piccole dimensioni. Il primo metodo, MakeAntiRandomTestSet(), incapsula semplicemente il codice presentato nella sezione precedente:

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;
}

Il secondo metodo di supporto, PerformTest(), accetta una stringa e simula il test del sistema PokerLib.dll ipotetico sottoposta a test:

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);
  }
}

Qui è possibile creare una situazione in cui avrà esito negativo del sistema sotto test se le prime due schede del test case di input sono di fiori. Si noti che è necessario visualizzare l'input di test case che genera l'errore di sistema in modo che il problema può essere riprodotto e infine risolti il team di sviluppo. Sarebbe peccato se, dopo numerosi giorni o anche settimane o mesi dell'esecuzione di test AR estesa, si determineranno un errore grave nel sistema sottoposta a test e che si è dimenticato di registrare l'input che ha generato l'errore.

Esistono molti altri modelli che utilizzabili per test AR parziale. Invece di utilizzare un dominio di piccole surrogati e un piccolo AR insieme combinato con un numero elevato di cicli di test, è consigliabile generare una serie di test AR grandi dimensioni da un dominio surrogato di grandi dimensioni ed eseguire meno cicli di test. Si noti che l'approccio descritto in questa sezione genera un set di test AR e utilizza le stringhe nel set di ma non verrà salvare qualsiasi il AR verificato imposta. Alternativa, è possibile scrivere le stringhe in ogni AR test impostato archiviazione esterna, ad esempio un file di testo, un foglio di calcolo di Excel o una tabella SQL, come le stringhe vengono generati. Quindi se si desidera eseguire il test di regressione, si dispone già pronto il test di input e l'esecuzione dei test sarà molto più rapido rispetto a se è necessario rigenerare l'input.

Conclusioni

Consenti di riepilogare i concetti presentati in questo articolo. Stringa AR parziale test è una tecnica utile in situazioni in cui un sistema da testare accetta input di stringa e la dimensione del dominio di input è troppo grande per eseguire il test exhaustively. Per eseguire parziale stringa AR test, è necessario creare un dominio di surrogati di grandi dimensioni che è un sottoinsieme del dominio input casuale. Successivamente, è possibile generare un insieme di test AR è un sottoinsieme del dominio di surrogati in cui le stringhe nel set di test sono maximally diverse tra loro. Ogni stringa nel set di test AR viene quindi inviato al sistema sottoposta a test. In molti casi non determinare un valore previsto esplicito o lo stato per ogni input di stringa AR. Invece si desidera impedire al sistema sottoposta a test in qualche modo. La distanza Hamming e la distanza Levenshtein sono due tecniche generiche per calcolare un valore di differenza tra le due stringhe. Se lo scenario di test ha stringhe che dispongono di un elevato livello di struttura, è possibile creare un proprio metodo differenza di stringa personalizzata. Tali metodi personalizzati spesso necessaria la rotazione della stringa.

Education ricerca nel campo del software in modo coerente di test produce risultati che suggeriscono che non vi sia singolo migliore tecnica di test. Quando opportuno, aggiungere parziale stringa AR test per l'attività di test consentono produrre software che ha un numero minore di bug, è più affidabile e più sicura.

Dr. James McCaffrey lavora per Volt Information Sciences Inc., dove gestisce la formazione tecnica degli ingegneri software in base a Redmond, WA ’s Microsoft, campus. Ha è occupato di numerosi prodotti Microsoft, inclusi Internet Explorer e MSN Search ed è l'autore di “ .NET automazione di test: Un approccio di soluzione del problema ” (Apress, 2006). Dr. McCaffrey possibile contattarlo all' indirizzo jmccaffrey@volt.com di o v-jammc@microsoft.com di.