Artikel
09/29/2015

Dieser Artikel wurde maschinell übersetzt.

Testlauf

Teilweise Antirandom Zeichenfolge testen

James McCaffrey

Antirandom (AR) testen ist eine Variante der reinen Zufallstests, der zufällige Eingaben generieren und senden, die Eingabe auf einem System unter Test. In den meisten Fällen verfügt über zufällige Test Eingabe keinen zugeordneten expliziten erwarteten zurückgegeben Wert oder System Zustand. In diesen Fällen dient der Zufallstests versuchen, einen Systemfehler Art, z. B. ein hängen oder Abstürzen generieren. Recherche Studien haben gezeigt, dass reine Zufallstests verhältnismäßig weniger effektiv Ermitteln von Fehlern als andere testen Paradigmen wie Äquivalenz Partition testen und Grenze Wert Analyse testen ist. Zufallstests ist jedoch ansprechender, da er i. d. r. schnell und einfach implementieren. Das Konzept der AR testen wird durch das Feld Hardware testen eingeführt wurden. AR testen generiert im Wesentlichen einen Eingaben Satz von zufälligen Werten, wobei die Werte als unterscheiden wie möglich sind. Die Annahme ist, dass ähnliche Eingabe für ein System ähnliche Arten von Fehlern macht und eine Eingabemenge, die Werte enthält, die sehr unterscheiden sind verfügt daher über eine höhere Wahrscheinlichkeit Verfügbarmachen von Fehlern in einem Softwaresystem.

Abbildung 1 erstellen teilweise AR Zeichenfolgen

Hier ein Beispiel: Genommen Sie an, dass ein Hardwaresystem einen Parameter verfügt, der 3-Bit-Werte akzeptiert. Die vollständige input Domäne daher aufweist acht Werte: {000, 001, 010, 011, 100, 101, 110, 111}. Weiter genommen Sie an, Sie einen Satz Test generieren, der vier AR Eingaben, enthält da alle acht Werten umfassende Tests nicht durchführbar aus irgendeinem Grund ist, möchten. Ihre anfängliche AR Test Satz ist leer und Wert {0,0,0} willkürlich aus der Eingabe Domäne ausgewählt und die Test-Gruppe hinzugefügt werden kann. Die nächste Eingabe der AR Test Satz hinzugefügt werden ist der Wert aus der Domäne Speicherplatz, der am häufigsten die aktuellen Werte in den Test unterscheidet. Wert {1,1,1} ist in diesem Fall die meisten anderen {0,0,0} mit nahezu jede rational Definition von unterschiedlich, sodass AR Test nun festlegen enthält {0,0,0} und {1,1,1}. Als Nächstes wird davon gegangen Sie aus, dass der Wert {0,0,1} ausgewählt ist, aus der Eingabe Domäne mit dem Verfahren weiter unten beschrieben und der AR Test festgelegt, sodass Ihre jetzt {0,0,0}, {1,1,1} und {0,0,1 enthält} hinzugefügt. Die verbleibenden fünf Werte in der eingegebenen Domäne sind Kandidaten für den vierten und letzten Member des Test ein. Jedoch hängt genau dem Wert gewählt wird von der Differenz-Funktion verwendet. Eine Candidate-Funktion ist die Hamming Abstand zwischen zwei Werte, der nur die Anzahl der Positionen, die Bits in zwei Werte unterscheiden. Die Summe der Hamming Abständen zwischen jeder Kandidatenschlüssel Wert und der drei aktuellen Mitglieder der AR Test Gruppe sind:

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

Da {1,1,0} die verschiedenen aus den vorhandenen Elementen den DEBITORENKONTEN Test Satz ist, wird der Test-Gruppe hinzugefügt. In diesem Beispiel weist darauf hin, dass reine AR input Testgenerierung eine vollständige Enumeration die gesamte Eingabe Domäne erfordert. Dies kann für bestimmte Typen von Hardware Testen mit einer relativ kleinen input Bit Größe oder für Softwaresysteme mit einer kleinen input Domäne sein. Reine AR testen ist jedoch selten möglich komplexer Softwaresysteme. Diese Spalte stellt einen Ansatz aufgerufen, teilweise AR Zeichenfolge testen, die verwendet werden kann, um eine Vielzahl von Software Systems zu testen.

Die beste Möglichkeit zu erklären, worauf ich hinaus will ist mit beiden Screenshots. Abbildung 1 zeigt ein Beispiel der wie ein teilweiser AR Zeichenfolge Test Satz generiert werden kann.

Das Beispiel in Abbildung 1 basiert auf ein System sieben Karte Poker einige sortieren. Jede Zeichenfolge stellt sieben Karten dar, wobei 'A'Stellt einen Ace;' T 'Stellt eine 10;und 'C', ' d ', 'h'und des "Kreuz, Karo, Herz und Pik dargestellt. Wenn Duplikate zulässig sind, die Gesamtzahl von Eingabezeichenfolgen ist 52 potenziert mit dem siebten = 1,028,071,702,528, das ist wahrscheinlich in den meisten Testsituationen nicht verwaltbar. AR Testgenerierung festgelegt beginnt durch Erstellen einer Eingabe Domäne Ersatzzeichen, die eine zufällig ausgewählte Teilmenge der die gesamte Eingabe Domäne ist. Hier verwenden Sie künstlich kleine Ersatzzeichen Domäne eine Größe von 10 Zeichenfolgen um Mein Beispiel kurz zu halten. AR Test Set Size ist auf drei, erneut künstlich kleine zu Demonstrationszwecken festgelegt. AR ist Test zunächst leer;die erste Zeichenfolge Wert aus der Ersatz-Domäne "Ts Do 3 h Qd KD 4D 9 d", wird die AR hinzugefügt festgelegt. Als Nächstes untersucht das Demoprogramm aller Zeichenfolgen in die Ersatz-Domäne die Zeichenfolge gefunden, die am häufigsten von die einzelne Zeichenfolge in der Gruppe AR abweicht. In diesem Fall die Zeichenfolge "3 c 9 h 9 3 als 9 c 2 c"ist als die meisten anderen ausgewählt. Wird erläutert, wie die Berechnung der Differenz in Kürze durchgeführt wird. Das Demoprogramm Neueinlesen anschließend überprüft die Ersatz-Domäne den Zeichenfolgenwert zu finden, der am unterscheidet beide die beiden Zeichenfolgen derzeit in den DEBITORENKONTEN Test ist. Nach der endgültige Wert "9 d Js Js KD 7 h 5d Jc", ermittelt und zum AR hinzugefügt ist, das Demoprogramm zeigt den endgültigen Satz. Das Ergebnis ist eine Reihe von Tests Eingaben, die Zeichenfolgen enthält, die sind mehr unterscheidet voneinander der Fall wäre, wenn die Zeichenfolgen nach dem Zufallsprinzip ausgewählt hatten.

Abbildung 2 Testing with Partial AR Zeichenfolgen

Abbildung 3 Struktur der teilweise AR Test festlegen generieren

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

Im Bildschirmabbild in Abbildung 2 zeigt eine Möglichkeit in der Teilzeichenfolgen AR verwendet werden können, ein System zu testen. Ich teste einem hypothetischen PokerLib.dll Modul eine Zeichenfolge akzeptiert, eine sieben-Karte Poker Hand darstellt, wie oben beschrieben. Die Idee ist wiederholt teilweise AR Test legt generieren und senden alle Zeichenfolgenwerte in jeder Test auf das System unter Test festgelegt. In dieser Situation aufzuerlegen ich eine beliebige maximale Anzahl von Zyklen von 1.000.000. Die Demo in Abbildung 2 dargestellt verwendet eine Eingabe Ersatzzeichen Größe von 100 und ein partieller AR Test festgelegt Größe von 10. Ich codiert das hypothetische PokerLib.dll System unter Testbedingungen schnell erzeugen eine Ausnahme veranschaulicht, was Sie hoffentlich geschieht, wenn partielle AR testen, ausführen, ist ein Fehler erzeugt.

In dieser Spalte verwende ich Begriffe AR testen, teilweise AR testen und teilweise AR Zeichenfolge testen mehr oder weniger gleichbedeutend. Bezieht jedoch in academic Recherche Vertriebsdokumentation AR Tests normalerweise sich auf die beschriebenen, in dem die gesamte Eingabe Domäne wird überprüft, um zu bestimmen und die Eingabewerte sind binäre Werte in die AR testen festlegen. Verwendung den Begriff "teilweise"zur Unterscheidung der beschriebenen Technik scannt hier die eine Domäne Ersatz von "reinem"AR zu testen.

In den folgenden Abschnitten wird ich präsentieren und Erläutern Sie die Screenshots in Abbildung 1 und 2 gezeigten generierte Code. Insbesondere werde ich unterschiedliche Techniken beschreiben, die Sie zum Bestimmen des Unterschied zwischen zwei Zeichenfolgen und jede Technik eignet verwenden können. Ich werden auch einige Richtlinien zum Auswählen der Ersatz Domäne Größe vorstellen und AR Test festgelegt Größe. Davon ausgegangen, dass Sie Anfang um fortgeschrittene Ebene Programmierkenntnisse verfügen. Meine Beispiele mit c# codiert sind sollten, aber Sie damit mein Code einfach in andere Sprachen, einschließlich VB.NET, Java, Perl und PowerShell recast. Ich bin sicher sein, dass teilweise AR testen ein interessantes Thema findet und, dass die Möglichkeit, Systeme mit Teilzeichenfolgen AR Testen eine wertvolle Ergänzung für Ihre Tests Tool Kit werden kann.

Generieren von teilweise AR-Zeichenfolgen

Der Code im Abbildung 3 ist die allgemeine Struktur des Programms, die im Bildschirmfoto in Abbildung 1 angezeigten generiert.

Ich erstellen Sie ein C#-Konsolenanwendung-Projekt mit dem Namen Demo mithilfe von Visual Studio 2008. Meine teilweise AR Generation verwendet kein spezielle .NET Framework-Namespaces, damit die using-Anweisungen außer für die Stamm-System-Namespace verweist automatisch gelöscht. Ein mit einem Ausgangswert Wert von 0 Random-Objekt instanziiert:

static Random r = new Random(0);

Ich Geben Sie einen Ausgangswert Wert an den Konstruktor zufällig statt den Standardkonstruktor ohne einen Ausgangswert verwenden, damit meine Ausgabe reproduziert werden. Aus Gründen der Übersichtlichkeit und Einfachheit innerhalb dieser Spalte verwenden I den Begriff "random"Anstatt eine genauere "Pseudo". Nach der Anzeige einer Nachricht beginnen, verwende ich die Math.Pow()-Methode, um die Gesamtanzahl der Zeichenfolgen in der Eingabe Domäne für das Testszenario zu berechnen. Technisch, müssen diese Informationen nicht, aber er dient, darauf hinzuweisen, dass die partielle AR Zeichenfolge Tests normalerweise in Situationen nützlich sind, in denen viele Eingaben um exhaustively zu testen. In diesem Fall eine Eingabezeichenfolge eine Hand sieben Karten darstellt, und hat die Form "Rs Rs Rs Rs Rs Rs RS", wobei R einer 13 Rangwerten ist ("A", "T", "2 bis 9", "J", "Q","KB") und "s"ist eines der vier Farbe Werte ("c", "d", "h", "s"). Jede Karte kann eine der 13 * 4 = 52 Möglichkeiten, und daher mit Duplikaten zulässig, die Gesamtzahl der möglichen Zeichenfolgen 52 potenziert mit dem siebten ist.

Abbildung 4 Erstellen einer direkten Karte String

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

Als Nächstes festgelegt die Größe des Ersatz-Domäne und den Test, bzw. Legen Sie acht und drei. Diese Größen sind viel kleiner, als Sie normalerweise in einer Produktionsumgebung verwenden. Besprochen werden die Probleme mit diesen Größen in Kürze auswählen. Ich initialisieren die Ersatz-Domäne, indem Sie eine Hilfsmethode, mit dem Namen MakeARandomDomainString() aufrufen:

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

Der Code für die Hilfsmethode ist:

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

Bei Verwendung von teilweise AR testen wird jedes Tests Szenario ein anderes Eingabezeichenfolge Format haben. Eine extrem haben Sie möglicherweise keine Einschränkungen für Eingabezeichenfolge anderen Format als Länge. In solchen Fällen müssen Sie einfach vollständig zufällige Zeichenfolgen generieren. In meinem Beispiel besteht ein gut strukturierten Format. Im Allgemeinen Zeichenfolgen die Nützlichkeit von partiellen AR Zeichenfolge testen erhöht wie die Struktur der Eingabe erhöht. Die MakeARandomDomainString()-Methode generiert einfach eine Zeichenfolge zurück, der sieben Karten darstellt, indem eine Hilfsmethode, die MakeARandomCard(), iteratives Aufrufen, wie in Abbildung 4 dargestellt.

Ich verwenden Sie das Random-Objekt ich instanziiert früher erzeugt zwei Pseudozufallszahlen Ganzzahlen im Bereich [1,13] und [1,4] bzw.. Beachten Sie, dass die zwei Parameter für die Random.Next()-Methode daher r.Next(1,14) eine zufällige ganze Zahl zwischen 1 und 13 einschließlich anstatt zwischen 1 und 14 generiert die inklusive untere Grenze und die exklusive obere Grenze darstellen. Verwenden Sie den überladenen +=-Operator Meine Karte-Zeichenfolge statt der effizienter StringBuilder-Klasse des System.Text-Namespace zu erstellen. In diesem Artikel verwenden I generische Programmiertechniken, sodass Sie leichter mein Beispielcode in anderen Programmiersprachen umgestalten können. Ich haben darüber hinaus codiert mein Beispiel eine herkömmliche nicht-OOP-Formatvorlage verwenden, sodass Sie problemlos für Skriptsprachen mit eingeschränkter OOP-Unterstützung, wie JavaScript und Perl umgestalten können.

Nach die Ersatz-Domäne erstellen, anzeigen ich es:

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

In diesem Beispiel sollten ich nicht nach doppelten Werten in der Ersatz-Domäne aktivieren. Im Allgemeinen ist der Aufwand damit Duplikate in der Domäne Ersatzzeichen Groß zu rechtfertigen, den Vorteil erzielt. Wie bereits erwähnt, dass main Reiz der zufälligen Testtechniken Einfachheit. Darüber hinaus wie wir in Kürze sehen werden, sind doppelte Werte in der Domäne Ersatzzeichen höchst unwahrscheinlich an AR Test platziert werden. Jetzt bin ich bereit, die partielle AR Test generieren. Der Code in Abbildung 5 zeigt, wie gehe ich vor. Zunächst den ersten Wert in der Ersatz-Domäne auswählen und in den DEBITORENKONTEN Test Satz eingefügt:

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

Da die Zeichenfolgen in der Domäne Ersatzzeichen zufällig generiert werden, in den meisten Fällen ist kein Vorteil bei der Auswahl einer bestimmten Zeichenfolge. Ich verwende eine Variable NumberValuesInTestSet, um nachzuverfolgen wie viele Zeichenfolgen im Test AR aktuell festgelegt sind.

Abbildung 5 Code, um einen teilweisen AR Test generieren festlegen

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

Der äußersten for-Schleife mit Indexvariable k ist zum zeigen in und zum Auffüllen jeder Zelle in der AR Test Satz. Starten bei Wert k = 1, da ich die erste Zelle in dem AR Test am Index 0 mit dem ersten Wert in der Domäne Ersatzzeichen festgelegt Seeding ausgeführt. Da das Ziel die Zeichenfolge in der Domäne Ersatz zu suchen, die sich am besten von alle Zeichenfolgen derzeit in den DEBITORENKONTEN Test unterscheidet, erstellt Variable LargestTotalDeltaForAllI einen Wert zu verfolgen, der den größten Unterschied gefunden darstellt. Ich initialisieren auch eine Variable IndexOfBestCandidate zum Datensatz, in dem in der Ersatz-Domäne die Zeichenfolge mit den größten Unterschied Wert gefunden wurde.

Abbildung 6 Levenshtein Abstand

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

Die nächste for-Schleife mit Indexvariable i durchläuft jede Zeichenfolge Kandidaten in der Domäne Ersatzzeichen. Nach der Initialisierung einer Variablen TotalDeltaForCurrentI auf 0, verwende ich die geschachtelte for-Schleife mit Indexvariable j aller derzeit in der AR Test Satz Zeichenfolgen abzurufen. Also zu diesem Zeitpunkt Index k (und die Variable NumberValuesInTestSet) zeigen Sie auf die nächste leere Zelle in der Gruppe AR Test Index i verweist auf eine Zeichenfolge Kandidaten in der Domäne Ersatzzeichen und Index j verweist auf eine Zeichenfolge derzeit in der AR testen festlegen. Jetzt die Differenz zwischen den zwei Zeichenfolgen auf verweist i und j ermittelt, und diesen Unterschied zu der laufenden Summe für die aktuelle Kandidaten Zeichenfolge in der Domäne Ersatzzeichen sammeln:

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

Der Aufruf der RotateDistance()-Hilfsprogramm-Methode ist wichtig und werden erörtert es gleich. Wenn die Summe von Abständen zwischen Candidate Zeichenfolge und alle Zeichenfolgen in den Test AR Meine aktuellen größten Summe von Entfernungen Wert größer ist, aktualisieren ich meine Variablen verfolgen:

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

Wie bereits erwähnt, dass der gesamte Punkt teilweise AR Zeichenfolge testen um Zeichenfolgen zu generieren, die als möglichst voneinander abweichen. Einige Nachrichten Fortschritt der Befehlsshell drucken, fügen Sie nach ich des beste Kandidaten in der Domäne Ersatz der AR Test festlegen und aktualisieren die Anzahl der Werte in den Test gefunden:

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

Da Index k und Variable NumberValuesInTestSet den gleichen Wert enthalten, konnte ich k hier ersetzt haben. Die Verwendung von beschreibenden Variable ist jedoch in meiner Meinung nach etwas besser lesbar.

Berechnet die Differenz zwischen zwei Zeichenfolgen

Wenn teilweise AR Zeichenfolge Tests durchführen, benötigen Sie eine Methode, die die Differenz zwischen zwei Zeichenfolgen berechnet. Genau wie Sie zwei Zeichenfolgen vergleichen, werden das Format der Zeichenfolgen in Ihrem Szenario testen verwendet abhängig. Die Zeichenfolgen, die immer verglichen werden die gleiche Länge haben, ist eine einfache Möglichkeit Abstand Hamming zeichenbasierten verwenden nur die Anzahl der Positionen in eine Zeichenfolge ist, in denen Zeichen unterscheiden. Beispielsweise, wenn s = "Auto"und t = "Array" der Hamming Abstand zwischen s und t ist zwei. Wenn die beiden Zeichenfolgen unterschiedlicher Länge haben, können Sie eine geänderte Hamming Strecke, die die Differenz in Größe die längere Zeichenfolge und kürzere Zeichenfolge hinzufügt. Beispielsweise wenn s = "Auto"und t = ", Kabel" der geänderte Hamming Abstand eine (für 'R' istVS." b ") + 2 (für 'l'und 'e') = 3. Hier ist eine Möglichkeit zum Implementieren des Hamming Abstand für dieselbe Größe Zeichenfolgen:

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

Eine andere einfache Maßeinheit der Differenz zwischen zwei Zeichenfolgen ist der zeichenbasierten Kartesische Abstand. Dies ähnelt der geometrische Abstand zwischen zwei Punkten, die Sie von High School Algebra erinnern können. Angenommen, String s = "bat"und t = "Auto". Der ASCII-Wert 'b'98 und der ASCII-Wert von 'c'99 ist und so die Differenz zwischen den beiden Zeichen ein. Der Unterschied zwischen "und "R"ist zwei. Der zeichenbasierten Kartesische Abstand zwischen Zeichenfolgen s und t ist sqrt(1^2 + 0^2 + 2^2) = 2,24. Eine komplexere Möglichkeit, die Differenz zwischen zwei Zeichenfolgen zu berechnen ist der Abstand Levenshtein. Der Levenshtein Abstand zwischen zwei Zeichenfolgen beträgt die kleinste Anzahl von Zeichen Einfügungen, Löschungen und Ersetzungen erforderlich, um eine Zeichenfolge zu einem anderen zu transformieren. Levenshtein Abstand ist eine faszinierende Thema in eigene rechts, aber eine gründliche Erörterung ist außerhalb des in diesem Artikel. Abbildung 6 zeigt eine einfache Implementierung der Levenshtein-Entfernung, die Sie zum Testen von partiellen AR Zeichenfolge verwenden können.

Die strukturierter Ihrer Eingaben Zeichenfolgen sind, desto wahrscheinlicher ist es, dass eine benutzerdefinierte Differenz-Methode als generische Unterschiede Methoden wie z. B. den Abstand Hamming oder Levenshtein Abstand nützlicher werden. Betrachten Sie in meinem Szenario Poker Karte beispielsweise diese beiden Zeichenfolgen:

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

Beachten Sie, dass die beiden Zeichenfolgen Poker Hände darstellen, die mit sechs aus sieben Karten werden identische sehr ähnlich sind. Allerdings der Hamming Abstand zwischen s und t 14 ist und wie sich herausstellt, Levenshtein Abstand sechs. In meinem Szenario implementiert ich eine benutzerdefinierte Differenz-Methode mit dem Namen RotateDistance(). Die RotateDistance()-Methode nutzt die Struktur der Poker Hand Zeichenfolgen und vergleicht basierend auf der Karte Werte. Der Code für RotateDistance() ist in Abbildung 7 aufgeführt. Meine benutzerdefinierte Differenz-Methode startet den Hamming Abstand zwischen der Methode Eingabeargumente computing:

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

Nächstes RotateDistance(s,t) Zeichenfolge s, um nach einer Karte Position links dreht und Hamming Abstand erneut berechnet:

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

Die Methode führt diese drehen-und-vergleichen über alle sieben Karte Positionen und gibt den kleinsten gefunden, die in diesem Beispiel wird eine Abstand zurück. Der Code für die RotateLeft()-Hilfsmethode verwendet String.Substring() das Eingabeargument in zwei Teile zu unterteilen und dann Zeichenfolgenverkettung zum Wiederherstellen von zwei Teilen:

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

Aufgrund meiner Erfahrung Wenn Eingabezeichenfolgen Test eine ausreichende Menge an Struktur haben, ist einige Variante der beschriebenen drehen-und-vergleichen Algorithmus häufig sehr effektiv. Lassen Sie mich weisen aus, dass selbst wenn Ihr Szenario Tests sehr Eingabezeichenfolgen strukturiert wurde, Sie sind unter keinerlei Verpflichtung schreiben eine benutzerdefinierten Differenz-Methode, wie ich hier getan haben. Mithilfe einer benutzerdefinierten Unterschied Methode hilft AR Zeichenfolgen generieren, die mehr voneinander diejenigen erzeugt, indem der Abstand von Hamming oder Levenshtein Entfernung unterscheiden, aber Sie müssen die Vorteile gegen den Aufwand zum Erstellen einer benutzerdefinierten Unterschied Methode beurteilen.

Abbildung 7 benutzerdefinierte RotateDistance() Methode

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

Testen mit teilweise AR Zeichenfolgen

Teilweise AR Zeichenfolge testen ist wirklich eine Metadaten-Technik, d. h. die Methode mehrere einen allgemeinen Satz von Richtlinien statt auf einen bestimmten Rezeptbuch-Stil Ansatz, der in allen Tests Situationen angewendet werden können. Eine der vielen möglich Möglichkeiten, teilweise AR Zeichenfolge testen ist in den Screenshot in Abbildung 2 angezeigt dargestellt. Die Auflistung in acht ist der Schlüssel Code, der den Screenshot in Abbildung 2 generiert.

Zunächst wird einige Nachrichten Protokollierung der Befehl Shell, einschließlich des Namens der testende System angezeigt, die Ersatzzeichen Domäne Größe und die DEBITORENKONTEN testen, Set Size. Verwenden des ich im vorherigen Abschnitt, beschrieben Wenn Ersatzzeichen Domäne Größe m hat und die DEBITORENKONTEN Test Größe Größe n, generiert den AR Test Satz Ansatzes erfordert (n * (n-1) * m) / 2 Iterationen. Darüber hinaus ein Zeichenfolgenvergleich wird bei jeder Iteration durchgeführt, und jedem Vergleich erfordert mindestens Zeichenvergleiche min(length(s),length(t)). Der Punkt ist eine Teilmenge der AR-Test generieren, in dem Sie eine große Ersatzzeichen Domäne Größe angeben, und eine große AR Test festgelegt Größe können Sie sehr viel Verarbeitungszeit erforderlich. Je größer diese zwei Größen sind, desto besser der DEBITORENKONTEN Test Satz werden hinsichtlich der Test String input Vielfalt, aber Ihre AR Test Generieren der Zeitaufwand verringert die Anzahl von Eingaben, die tatsächlich an das System die zu testende gesendet.

Abbildung 8 Beispiel testen mit teilweise AR Zeichenfolgen

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

Als Nächstes geben Sie die maximale Anzahl der Zyklen AR Test Mengen generieren. In vielen Szenarios testen möchten Sie AR kontinuierlich; Tests ausführenIn solchen Fällen können Sie nur ersetzen, die Steuerung der while-Schleife mit while(true). Innerhalb der main AR Steuerelement Schleife ich einen Satz AR Test generieren und senden jede Zeichenfolge aus der Test als Eingabe für das System unter Test festlegen. Ich habe zwei kleine Hilfsmethoden geschrieben. Die erste Methode MakeAntiRandomTestSet(), umbrochen wird einfach den Code im vorherigen Abschnitt:

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

Die zweite Hilfsmethode PerformTest(), akzeptiert eine Zeichenfolge und simuliert das hypothetische PokerLib.dll System unter Test testen:

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

Hier erstellen eine Situation, in denen testende System fehl, wenn die ersten zwei Karten den Testfall Eingabe Vereine sind. Beachten Sie, die ich Denken Sie daran, Test Case Eingabe anzuzeigen, die den Systemfehler, generiert so dass das Problem reproduziert und durch das Entwicklungsteam letztendlich behoben werden kann. Es wäre leider, wenn, nachdem Sie mehrere Tage oder sogar Wochen oder Monate des erweiterten AR Tests ausgeführt, Sie auslösen ein schwerwiegenden Fehlers in Ihrem System unter Testbedingungen und, dass Sie vergessen haben, die Eingabe aufzuzeichnen, die den Fehler generiert hat.

Es gibt viele Muster, die Sie zum Testen von partiellen AR verwenden können. Anstelle von einer kleinen Ersatz-Domäne und eine kleine AR festlegen, die zusammen mit einer großen Anzahl von Zyklen testen, können Sie einen großen AR Test Satz aus einer großen Ersatzzeichen Domäne generieren und weniger Testzyklen durchführen. Beachten Sie, dass die in diesem Abschnitt beschriebenen Vorgehensweise einen Test AR generiert und die Zeichenfolgen in der Gruppe verwendet jedoch nicht speichern keines der AR legt fest getestet. Eine Alternative ist, den Zeichenfolgen in jeder AR zu schreiben, legen Sie Test auf externen Speichergerät, wie z. B. eine Textdatei, eine Excel-Kalkulationstabelle oder eine SQL-Tabelle wie die Zeichenfolgen werden generiert. Dann Regressionstests durchzuführen, wenn Sie Sie bereits Test Eingabe bereit und Ihre Testlauf werden viel schneller als die Eingabe erneut generieren.

Zusammenfassung

Lassen Sie mich die in diesem Artikel vorgestellten Ideen zusammenfassen. Teilweise AR Zeichenfolge testen ist eine Technik, die in Situationen nützlich sind, in denen ein System unter Testbedingungen Zeichenfolgeneingabe akzeptiert und die Größe der eingegebenen Domäne ist zu groß für exhaustively testen. Teilweise AR Zeichenfolge Tests durchführen möchten, erstellen Sie zunächst eine große Ersatzzeichen Domäne, die eine zufällige Teilmenge der eingegebenen Domäne ist. Als Nächstes generieren Sie ein AR Test Satz, die eine Teilmenge der Ersatz-Domäne ist, wobei die Zeichenfolgen in den Test Liefermengen also maximal unterscheiden sind. Jede Zeichenfolge in den DEBITORENKONTEN Test wird dann an das System die zu testende gesendet. In den meisten Fällen Sie eine explizite erwarteten Wert oder Status für jeden Zeichenfolgeneingabe AR nicht bestimmen. Stattdessen sind Sie versucht, das System unter Test in irgendeiner Weise fehl. Den Abstand Hamming und Levenshtein Abstand sind zwei allgemeine Techniken, einen Wert Unterschied zwischen zwei Zeichenfolgen zu berechnen. Verfügt Ihr Testszenario Zeichenfolgen, die ein hohes Maß an Struktur verfügen, können Sie Ihre eigene benutzerdefinierte Zeichenfolge Differenz-Methode erstellen. Benutzerdefinierten Methoden umfassen häufig Zeichenfolge Drehung.

Academic Recherche in das Feld der Software ständig testen erzielt Ergebnisse, die vorgeschlagen, dass keine einzelne optimale Verfahren testen vorhanden ist. Bei Bedarf, können hinzufügen teilweise AR Zeichenfolge, die Ihre Bemühungen Test testen Sie Software zu erzeugen, der weniger Fehler enthält, zuverlässiger und sicherer.

Dr. James McCaffrey* arbeitet für Volt Information Sciences Inc. und, wo er technische Schulungen für Softwareentwickler bei Microsoft ’s Redmond, Washington, Campus basiert. Er hat mehrere Microsoft-Produkte, einschließlich Internet Explorer und MSN Suche gearbeitet und ist Autor des “ .NET Test Automation: Ein Ansatz Problem Projektmappen eingeben (Apress, 2006). Dr.. McCaffrey kann unter jmccaffrey@volt.com oder v-jammc@microsoft.com erreicht werden.*