Dies sind maschinell übersetzte Inhalte, die von den Mitgliedern der Community bearbeitet werden können. Sie können die Übersetzung verbessern, indem Sie auf den jeweils zum Satz gehörenden Link "Bearbeiten" klicken.Mithilfe des Dropdown-Steuerelements "Inhalt anzeigen" links oben auf der Seite können Sie zudem bestimmen, ob nur der englische Originaltext, nur die deutsche Übersetzung oder beides nebeneinander angezeigt werden.
Antirandom (AR) testing is a variation of pure random testing, which is the process of generating random input and sending that input to a system under test.
In most situations, random test input does not have an associated explicit expected return value or system state.
In such situations, the purpose of random testing is to try to generate a system failure of some sort, such as a hang or crash.
Research studies have shown that pure random testing is relatively less effective at discovering bugs than other testing paradigms, such as equivalence partition testing and boundary value analysis testing.
However, random testing is appealing because it is typically quick and easy to implement.
The idea of AR testing appears to have been introduced by the field of hardware testing.
Essentially, AR testing generates an input set of random values, where the values are as different as possible from each other.
The assumption is that similar input to a system will expose similar types of bugs, and therefore an input set that contains values that are very different from each other has a higher likelihood of exposing errors in a software system.
.png)
Figure 1 Generating Partial AR Strings
Here's an example.
Suppose that a hardware system has a parameter that accepts 3-bit values.
The complete input domain, therefore, has eight values: {000, 001, 010, 011, 100, 101, 110, 111}.
Further, suppose you want to generate a test set that contains four AR inputs because exhaustive testing of all eight values is not feasible for some reason.
Your initial AR test set is empty, and value {0,0,0} can be arbitrarily selected from the input domain and added to the test set.
The next input to be added to the AR test set is the value from the domain space that is most different from the current values in the test set.
In this case, value {1,1,1} is the most different from {0,0,0} using virtually any rational definition of different, so the AR test set now contains {0,0,0} and {1,1,1}.
Next, assume that value {0,0,1} is selected from the input domain using the procedure described below and added to the AR test set so that your set now contains {0,0,0}, {1,1,1}, and {0,0,1}.
Any of the remaining five values in the input domain are candidates for the fourth and final member of the test set.
However, exactly which value is chosen depends upon the difference function used.
One candidate function is the Hamming distance between two values, which is just the number of positions where the bits in the two values differ.
The sum of Hamming distances between each candidate value and the three current members of the AR test set are:
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
Because {1,1,0} is the most different from the existing members of the AR test set, it is added to the test set.
This example points out that pure AR test input generation requires a complete enumeration of the entire input domain.
This may be possible for certain types of hardware testing with a relatively small input bit size or for software systems with a small input domain.
However, pure AR testing is rarely possible for complex software systems.
This column presents an approach I call partial AR string testing, which can be used to test a wide range of software systems.
The best way to explain where I'm headed is with two screenshots.
Figure 1 shows an example of how a partial AR string test set can be generated.
The example shown in Figure 1 is based on a seven-card poker system of some sort.
Each string represents seven cards where 'A' represents an ace; 'T' represents a 10; and 'c', 'd', 'h' and 's' represent clubs, diamonds, hearts and spades.
If duplicates are allowed, the total number of input strings is 52 raised to the seventh power = 1,028,071,702,528, which is likely to be unmanageable in most testing situations.
AR test set generation begins by creating a surrogate input domain, which is a randomly selected subset of the entire input domain.
Here I use an artificially small surrogate domain size of 10 strings to keep my example short.
The AR test set size is set to three, again artificially small for demonstration purposes.
The AR test set is initially empty; the first string value from the surrogate domain, "Ts Th 3h Qd Kd 4d 9d", is added to the AR set.
Next, the demo program examines each of the strings in the surrogate domain to find the string that is most different from the single string in the AR set.
In this case, the string "3c 9h 9s 3s As 9c 2c" is selected as the most different.
I will explain how the difference computation is performed shortly.
Next, the demo program rescans the surrogate domain to find the string value that is most different from both of the two strings currently in the AR test set.
After that final value, "9d Js Js Kd 7h 5d Jc", is determined and added to the AR set, the demo program displays the final set.
The result is a set of test inputs that contains strings that are more different from each other than would be the case if the strings had been chosen randomly.
.png)
Figure 2 Testing with Partial AR Strings
Figure 3 Structure of Partial AR Test Set Generation
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
The screenshot in Figure 2 shows one way in which partial AR strings can be used to test a system.
I am testing a hypothetical PokerLib.dll module that accepts a string representing a seven-card poker hand as described earlier.
The idea is to repeatedly generate partial AR test sets and send all the string values in each test set to the system under test.
In this situation, I impose an arbitrary maximum number of cycles of 1,000,000.
The demo shown in Figure 2 uses a surrogate input size of 100 and a partial AR test set size of 10.
I coded the hypothetical PokerLib.dll system under test to quickly produce an Exception to demonstrate what you hope happens when performing partial AR testing, which is to produce an error.
In this column, I use the terms AR testing, partial AR testing, and partial AR string testing more or less interchangeably.
However, in academic research literature, AR testing usually refers to the process I described where the input values are binary and the entire input domain is scanned to determine the values in the AR test set.
I use the term "partial" to distinguish the technique described here, which scans a surrogate domain, from "pure" AR testing.
In the sections that follow, I will present and explain the code that generated the screenshots shown in Figures 1 and 2.
In particular, I will describe different techniques that you can use to determine the difference between two strings and when each technique is appropriate.
I will also present some guidelines on how to select the surrogate domain size and the AR test set size.
I assume you have beginning- to intermediate-level programming skills.
My examples are coded with C#, but you should be able to easily recast my code into other languages, including VB.NET, Java, Perl and PowerShell.
I'm confident that you will find partial AR testing an interesting topic and that the ability to test systems using partial AR strings can be a valuable addition to your testing tool kit.
Generating Partial AR Strings
The code in Figure 3 is the overall structure of the program that generated the screenshot shown in Figure 1.
I create a C# Console Application project named Demo using Visual Studio 2008.
My partial AR generation does not use any specialized .NET Framework namespaces, so I deleted the autogenerated using statements except for the one that references the root System namespace.
I instantiate a Random object using a seed value of 0:
static Random r = new Random(0);
I supply a seed value to the Random constructor rather than use the default constructor without a seed, so that my output will be reproducible.
For clarity and simplicity, throughout this column I use the term "random" rather than the more accurate "pseudorandom." After displaying a start message, I use the Math.Pow() method to compute the total number of strings in the input domain for the test scenario.
Technically, I don't need this information, but it serves to point out that partial AR string testing is typically useful in situations where there are too many inputs to test exhaustively.
In this situation, an input string represents a hand of seven cards and has the form "Rs Rs Rs Rs Rs Rs Rs", where R is one of 13 rank values ("A", "T", "2 thru 9", "J", "Q", "K") and "s" is one of four suit values ("c", "d", "h", "s").
Each card can be one of 13 * 4 = 52 possibilities, and so with duplicates allowed, the total number of possible strings is 52 raised to the seventh power.
Figure 4 Generating a Random Card 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;
}
Next, I set the sizes of the surrogate domain and the test set to eight and three, respectively.
These sizes are much smaller than ones you would normally use in a production environment.
I will discuss the issues related to choosing these sizes shortly.
I initialize the surrogate domain by calling a helper method named MakeARandomDomainString():
Console.WriteLine("\nGenerating surrogate domain");
for (int i = 0; i < surrogateDomain.Length; ++i)
surrogateDomain[i] = MakeARandomDomainString();
The code for the helper method is:
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;
}
When using partial AR testing, each testing scenario will have a different input string format.
At one extreme, you may have no constraints on input string format other than length.
In such situations, you will need to simply generate completely random strings.
In my example, I have a well-structured format.
In general, the usefulness of partial AR string testing increases as the structure of the input strings increases.
The MakeARandomDomainString() method simply generates a string representing seven cards by iteratively calling a helper method MakeARandomCard(), as shown in Figure 4.
I use the Random object I instantiated earlier to produce two pseudorandom integers in the range [1,13] and [1,4], respectively.
Note that the two parameters to the Random.Next() method represent the inclusive lower bound and the exclusive upper bound, so r.Next(1,14) generates a random integer between one and 13 inclusive rather than between one and 14.
I use the overloaded += operator to build up my card string, rather than the more efficient StringBuilder class of the System.Text namespace.
Throughout this article, I use generic programming techniques so that you can more easily refactor my example code into other programming languages.
Additionally, I have coded my example using a traditional non-OOP style so that you can easily refactor to scripting languages with limited OOP support, such as JavaScript and Perl.
After creating the surrogate domain, I display it:
Console.WriteLine("\nThe surrogate domain is: \n");
for (int i = 0; i < surrogateDomain.Length; ++i)
Console.WriteLine("[" + i + "] " + surrogateDomain[i]);
In this example, I do not check for duplicate values in the surrogate domain.
In general, the effort required to prevent duplicates in the surrogate domain is too great to justify the benefit gained.
Recall that the main appeal of random testing techniques is simplicity.
Furthermore, as we'll see shortly, duplicate values in the surrogate domain are highly unlikely to be placed into the AR test set.
Now I am ready to generate the partial AR test set.
The code in Figure 5 shows how I do this.
I begin by selecting the first value in the surrogate domain and placing it into the AR test set:
Console.WriteLine("Adding " + surrogateDomain[0] + " to AR test set");
antiRandomTestSet[0] = surrogateDomain[0];
int numberValuesInTestSet = 1;
Because the strings in the surrogate domain are generated randomly, in most situations there is no advantage in selecting a particular string.
I use a variable numberValuesInTestSet to keep track of how many strings are currently in the AR test set.
Figure 5 Code to Generate a Partial AR Test Set
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
The outermost for loop with index variable k is used to point into and populate each cell in the AR test set.
I start at value k = 1 because I seeded the first cell in the AR test set at index 0 with the first value in the surrogate domain.
Because the goal is to find the string in the surrogate domain that is most different from all strings currently in the AR test set, I create variable largestTotalDeltaForAllI to track a value that represents the largest difference found.
I also initialize a variable indexOfBestCandidate to record where in the surrogate domain the string with the largest difference value was found.
Figure 6 Levenshtein Distance
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];
}
The next for loop with index variable i iterates through each candidate string in the surrogate domain.
After initializing a variable totalDeltaForCurrentI to 0, I use the nested for loop with index variable j to fetch each of the strings currently in the AR test set.
So, at this point, index k (and variable numberValuesInTestSet) point to the next empty cell in the AR test set, index i points to a candidate string in the surrogate domain, and index j points to a string currently in the AR test set.
Now I determine the difference between the two strings pointed to by i and j and accumulate that difference to the running total for the current candidate string in the surrogate domain:
totalDeltaForCurrentI +=
RotateDistance(surrogateDomain[i], antiRandomTestSet[j]);
The call to the RotateDistance() helper method is important, and I will discuss it in just a moment.
If the sum of distances between the candidate string and all strings in the AR test set is larger than my current largest sum-of-distances value, I update my tracking variables:
if (totalDeltaForCurrentI > largestTotalDeltaForAllI) {
largestTotalDeltaForAllI = totalDeltaForCurrentI;
indexOfBestCandidate = i;
}
Recall that the whole point of partial AR string testing is to generate strings that are as different as possible from each other.
After printing some progress messages to the command shell, I add the best candidate found in the surrogate domain to the AR test set and update the number of values in the test set:
antiRandomTestSet[numberValuesInTestSet++] =
surrogateDomain[indexOfBestCandidate];
Because both index k and variable numberValuesInTestSet hold the same value, I could have substituted k here.
However, the use of the more descriptive variable is a bit more readable in my opinion.
Computing the Difference Between Two Strings
When performing partial AR string testing, you need a method that computes the difference between two strings.
Exactly how you compare two strings will depend upon the format of the strings used in your testing scenario.
If the strings that are being compared always have the same length, one simple possibility is to use the character-based Hamming distance, which is just the number of positions in either string where characters differ.
For example, if s = "car" and t = "bag", the Hamming distance between s and t is two.
If your two strings have different lengths, you can use a modified Hamming distance that adds the difference in size between the longer string and the shorter string.
For example if s = "car" and t = "cable", the modified Hamming distance is one (for the 'r' vs. '
b') + 2 (for the 'l' and 'e') = 3.
Here is one way to implement the Hamming distance for same-size strings:
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;
}
Another simple measure of the difference between two strings is the character-based Cartesian distance.
This is similar to the geometric distance between two points, which you may remember from high-school algebra.
Suppose string s = "bat" and t = "car".
The ASCII value of 'b' is 98 and the ASCII value of 'c' is 99, and so the difference between the two characters is one.
The difference between 't' and 'r' is two.
The character-based Cartesian distance between strings s and t is sqrt(1^2 + 0^2 + 2^2) = 2.24.
A more sophisticated way to compute the difference between two strings is the Levenshtein distance.
The Levenshtein distance between two strings is the smallest number of character insertions, deletions and substitutions required to transform one string to the other.
The Levenshtein distance is a fascinating topic in its own right, but a thorough discussion of it is outside the scope of this article.
Figure 6 lists a simple implementation of the Levenshtein distance that you can use for partial AR string testing.
The more structured your input strings are, the more likely it is that a custom difference method will be more useful than generic differences methods, such as the Hamming distance or the Levenshtein distance.
For example, in my poker-card scenario, consider these two strings:
s = "Ac Kd Qh Js Tc 9d 8h"
t = "Kd Qh Js Tc 9d 8h 7c"
Notice that the two strings represent poker hands that are very similar, with six out of seven cards being identical.
However, the Hamming distance between s and t is 14, and as it turns out, the Levenshtein distance is six.
In my scenario, I implemented a custom difference method named RotateDistance().
The RotateDistance() method takes advantage of the structure of the poker hand strings and compares based on card values.
The code for RotateDistance() is listed in Figure 7.
My custom difference method starts by computing the Hamming distance between the method input arguments:
s = "Ac Kd Qh Js Tc 9d 8h"
t = "Kd Qh Js Tc 9d 8h 7c"
distance = 14
Next, RotateDistance(s,t) rotates string s to the left by one card position and computes the Hamming distance again:
s = "Kd Qh Js Tc 9d 8h Ac"
t = "Kd Qh Js Tc 9d 8h 7c"
distance = 1
The method performs this rotate-and-compare process through all seven card positions and returns the smallest distance found, which in this example is one.
The code for the RotateLeft() helper method uses String.Substring() to break the input argument into two parts and then string concatenation to recombine the two parts:
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;
}
Based on my experience, when test input strings have a fair amount of structure, some variation of the rotate-and-compare algorithm I've described is often highly effective.
Let me point out that even if your testing scenario has highly structured input strings, you are under no obligation to write a custom difference method as I've done here.
Using a custom difference method will help to generate AR strings that are more different from each other than those produced by using the Hamming distance or Levenshtein distance, but you must gauge the benefit against the effort required to create a custom difference method.
Figure 7 Custom RotateDistance() Method
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;
}
Testing with Partial AR Strings
Partial AR string testing is really a meta-technique, meaning the method is more of a general set of guidelines rather than a specific cookbook-style approach that can be applied in all testing situations.
One of many possible ways to perform partial AR string testing is illustrated in the screenshot shown in Figure 2.
The listing in Figure 8 is the key code that generated the screenshot in Figure 2.
First, I display some logging messages to the command shell, including the name of the system under test, the surrogate domain size and the AR test set size.
Using the approach I described in the previous section, if the surrogate domain has size m, and the AR test size has size n, generating the AR test set requires (n * (n-1) * m) / 2 iterations.
Furthermore, a string comparison is performed in each iteration, and each comparison requires at least min(length(s),length(t)) character comparisons.
The point is generating a partial AR test set where you specify a large surrogate domain size, and a large AR test set size can require a significant amount of processing time.
The larger these two sizes are, the better your AR test set will be in terms of test string input diversity, but the time required to generate your AR test set reduces the number of inputs actually sent to the system under test.
Figure 8 Example of Testing with Partial AR Strings
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");
}
Next, I specify the maximum number of cycles to generate AR test sets.
In many testing scenarios, you want to run AR testing continuously; in such situations, you can just replace the controlling while loop with while(true).
Inside the main AR control loop, I generate an AR test set, and then send each string from the test set as input to the system under test.
I wrote two small helper methods.
The first method, MakeAntiRandomTestSet(), simply wraps the code presented in the previous section:
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;
}
The second helper method, PerformTest(), accepts a string and simulates testing the hypothetical PokerLib.dll system under 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);
}
}
Here I create a situation where the system under test will fail if the first two cards of the test case input are clubs.
Notice that I remember to display the test case input that generates the system failure so that the problem can be reproduced and ultimately fixed by the development team.
It would be unfortunate if, after several days or even weeks or months of running extended AR testing, you induce a catastrophic failure in your system under test and find that you forgot to record the input that generated the error.
There are many other patterns you can use for partial AR testing.
Instead of using a small surrogate domain and a small AR test set combined with a large number of cycles, you may want to generate one large AR test set from a large surrogate domain and perform fewer test cycles.
Notice that the approach described in this section generates an AR test set and uses the strings in the set, but does not save any of the AR test sets.
An alternative is to write the strings in each AR test set to external storage, such as a text file, an Excel spreadsheet, or a SQL table, as the strings are generated.
Then, if you wish to perform regression testing, you will already have the test input ready and your test run will be much quicker than if you had to regenerate the input.
Wrapping Up
Let me summarize the ideas presented in this article.
Partial AR string testing is a technique that is useful in situations where a system under test accepts string input and the size of the input domain is too large to test exhaustively.
To perform partial AR string testing, you first create a large surrogate domain that is a random subset of the input domain.
Next, you generate an AR test set that is a subset of the surrogate domain where the strings in the test set are maximally different from each other.
Each string in the AR test set is then sent to the system under test.
In most situations, you do not determine an explicit expected value or state for each AR string input.
Instead, you are attempting to cause the system under test to fail in some way.
The Hamming distance and the Levenshtein distance are two generic techniques to compute a difference value between two strings.
If your test scenario has strings that have a high degree of structure, you can create your own custom string difference method.
Such custom methods often involve string rotation.
Academic research in the field of software testing consistently produces results that suggest that there is no single best testing technique.
When appropriate, adding partial AR string testing to your test effort can help you produce software that has fewer bugs, is more reliable and is more secure.
Dr.
James McCaffrey
works for Volt Information Sciences Inc., where he manages technical training for software engineers based at Microsoft’s Redmond, Wash., campus.
He has worked on several Microsoft products, including Internet Explorer and MSN Search, and is the author of “.NET Test Automation: A Problem-Solution Approach” (Apress, 2006).
Dr.
McCaffrey can be reached at jmccaffrey@volt.com or v-jammc@microsoft.com.
|
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.
|
|
| Tip: Click the printer button in your browser toolbar to get the printer friendly version of this article. |
|