VerifyTextEqualence

Überprüft, ob zwei Texte äquivalent sind, verwendet mehrere Vergleichsoptionen, einschließlich der folgenden Vergleichstypen:

• Vergleichen von Wörtern.
• Vergleichen von Zeilen.
• Vergleichen von Zeichen als char -Variablen.

VerifyTextEquivalence(string, string, ComparisonType, ComparisonOptions)

VerifyTextEquivalence(
    string baselineText,
    string targetText,
    [ComparisonType comparisonType],
    [ComparisonOptions opts]
)

baselineText String

Der Basistext, der als Referenz für den Vergleich verwendet wird.

targetText String

Der Text, der mit dem Basistext verglichen wird.

comparisonType ComparisonType (Optional)

Der Vergleichstyp, der beim Vergleichen von Texten verwendet werden soll. Die folgenden Optionen sind verfügbar:

• ComparisonType.Char: Vergleicht jedes Zeichen (char) in den Texten.
• ComparisonType.Line: Vergleicht jede Zeile in den Texten.
• ComparisonType.Word: Vergleicht jedes Wort in den Texten.

Optionen CompareDocumentsOptions

Die spezifischen Vergleichsoptionen, die für diesen Vorgang verwendet werden sollen. Um ein Objekt vom Typ CompareDocumentsOptions zu erstellen, verwenden Sie die Klasse TestingOptions.CompareText.

Rückgabewert

ComparisonResult

Das Ergebnis der Vergleichsaktion, das in einer ComparisonResult -Variablen gespeichert wird. Sie können die Eigenschaften AreEquivalent oder Differences auf dem ComparisonResult aufrufen, um anzuzeigen, ob sie äquivalent sind, und wenn nicht, um die Unterschiede anzuzeigen.

Beispiele

Überprüfen Sie die folgenden Beispiele für die Verwendung der VerifyTextEquivalence -API:

1. Vergleichen von Text nach Zeichen:
   In diesem Beispiel vergleichen wir zwei string -Variablen, initialText und modifiedText. Der Vergleich erfolgt auf Zeichenebene. Die Platzhalterregel und die Regel für reguläre Ausdrücke, die zusammen mit den Methoden WithIgnoreWildcardRule und WithIgnoreRegexRule bereitgestellt werden, werden verwendet, um bestimmte Muster im Vergleich zu ignorieren. Beispielsweise ermöglichen uns die Platzhalterregel R?d und die Regel für reguläre Ausdrücke (f|F)ox , bestimmte Wörter zu ignorieren, die in den Variablen vorhanden sind, z. B. Red, und Fox. In diesem Szenario wurde der Parameter usePlaceholder auf false festgelegt, da wir keinen Platzhalternamen für die ignorierten Muster haben möchten.
   Die Methode WithGenerateHtml gibt einen HTML-Bericht aus, in dem die Unterschiede hervorgehoben werden.

   var initialText = "Red fox jumps over the lazy fox";
   var modifiedText = "Blue fox leaps over the lazy dog";
   
   var charCompareResult = testing.VerifyTextEquivalence(
       initialText, modifiedText, 
       ComparisonType.Character, 
       TestingOptions.CompareText()
           .WithGenerateHtml(@".\HtmlCompareResults\CharacterTextCompare.html")
           .WithIgnoreWildcardRule("WildcardRule", "R?d", false)
           .WithIgnoreRegexRule("RegexRule", @"(f|F)ox", false)
   );
   
   // Log any differences
   foreach (var diff in charCompareResult.Differences)
   {
       Log(diff.Operation.ToString());
       Console.WriteLine(diff.Text);
       Console.WriteLine("------------------------------------------------------------------------------");
   }

2. Vergleichen von Text nach Zeile:
   In diesem Beispiel vergleichen wir zwei string -Variablen, initialText und modifiedText. Der Vergleich erfolgt auf Zeilenebene. Die Platzhalterregel und die Regel für reguläre Ausdrücke, die zusammen mit den Methoden WithIgnoreWildcardRule und WithIgnoreRegexRule bereitgestellt werden, werden verwendet, um bestimmte Muster im Vergleich zu ignorieren. Beispielsweise ermöglichen uns die Platzhalterregel R?d und die Regel für reguläre Ausdrücke (f|F)ox , bestimmte Wörter zu ignorieren, die in den Variablen vorhanden sind, z. B. Red, und Fox. In diesem Szenario wurde der Parameter usePlaceholder auf true festgelegt, da wir einen Platzhalternamen für die ignorierten Muster haben möchten.
   Die Methode WithGenerateHtml gibt einen HTML-Bericht aus, in dem die Unterschiede hervorgehoben werden.

   var initialText = @"Red fox jumps over the lazy fox";
   var modifiedText = @"Blue fox leaps over the lazy dog";
   
   var lineCompareResult = testing.VerifyTextEquivalence(
       initialText, modifiedText, 
       ComparisonType.Line, 
       TestingOptions.CompareText()
           .WithGenerateHtml(@".\HtmlCompareResults\LineTextCompare.html")
           .WithIgnoreWildcardRule("WildcardRule", "R?d", true)
           .WithIgnoreRegexRule("RegexRule", @"(f|F)ox", true)
   );
   
   // Log any differences
   foreach (var diff in lineCompareResult.Differences)
   {
       Log(diff.Operation.ToString());
       Console.WriteLine(diff.Text);
       Console.WriteLine("------------------------------------------------------------------------------");
   }

3. Vergleichen von Text für Wort:
   In diesem Beispiel vergleichen wir, ähnlich wie im vorherigen, zwei string -Variablen: initialText und modifiedText. Der Vergleich erfolgt auf Wortebene. Die Platzhalterregel und die Regel für reguläre Ausdrücke, die zusammen mit den Methoden WithIgnoreWildcardRule und WithIgnoreRegexRule bereitgestellt werden, werden verwendet, um bestimmte Muster im Vergleich zu ignorieren. Beispielsweise ermöglichen uns die Platzhalterregel R?d und die Regel für reguläre Ausdrücke (f|F)ox , bestimmte Wörter zu ignorieren, die in den Variablen vorhanden sind, z. B. Red, und Fox.
   Die Methode WithGenerateHtml gibt einen HTML-Bericht aus, in dem die Unterschiede hervorgehoben werden.

   var initialText = "Red fox jumps over the lazy fox";
   var modifiedText = "Blue fox leaps over the lazy dog";
   
   var wordCompareResult = testing.VerifyTextEquivalence(
       initialText, modifiedText, 
       ComparisonType.Word, 
       TestingOptions.CompareText()
           .WithGenerateHtml(@".\HtmlCompareResults\LineWordCompare.html")
           .WithIgnoreWildcardRule("WildcardRule", "R?d", false)
           .WithIgnoreRegexRule("RegexRule", @"(f|F)ox", true)
   );
   
   // Log any differences
   foreach (var diff in wordCompareResult.Differences)
   {
       Log(diff.Operation.ToString());
       Console.WriteLine(diff.Text);
       Console.WriteLine("------------------------------------------------------------------------------");
   }

Das von VerifyTextEquivalence zurückgegebene Ergebnis enthält eine Differences -Eigenschaft, mit der Sie die Unterschiede zwischen Texten ausgeben können.