Vérifier l'équivalent texte

Vérifie si deux textes sont équivalents, en utilisant plusieurs options de comparaison, y compris les types de comparaison suivants :

• Comparer des mots.
• Comparaison des lignes.
• Comparaison des caractères en tant que variables char .

VerifyTextEquivalence(string, string, ComparisonType, ComparisonOptions)

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

baselineText Chaîne de caractères (string)

Texte de base utilisé comme référence pour la comparaison.

targetText Chaîne de caractères (string)

Le texte comparé au texte de base.

comparisonType ComparisonType (Facultatif)

Type de comparaison à utiliser lors de la comparaison de textes. Les options suivantes sont disponibles :

• ComparisonType.Char: compare chaque caractère (char) dans les textes.
• ComparisonType.Line: Compare chaque ligne dans les textes.
• ComparisonType.Word: Compare chaque mot dans les textes.

Opts CompareDocumentsOptions

Les options de comparaison spécifiques qui doivent être utilisées pour cette opération. Pour créer un objet de type CompareDocumentsOptions, utilisez la classe OptionsTest.CompareText.

RetournerValeur

ComparisonResult

Le résultat de l'action de comparaison, stocké dans une variable ComparisonResult . Vous pouvez appeler les propriétés AreEquivalent ou Differences sur le ComparisonResult pour afficher si elles sont équivalentes, et sinon, pour afficher les différences.

Exemples

Consultez les exemples suivants pour utiliser l'API VerifyTextEquivalence :

1. Comparaison de texte par caractère:
   Dans cet exemple, nous comparez deux variables string , initialText et modifiedText. La comparaison se fait au niveau du caractère. La règle de caractère générique et la règle de regex fournies avec les méthodes WithIgnoreWildcardRule et WithIgnoreRegexRule sont utilisées pour ignorer des modèles spécifiques dans la comparaison. Par exemple, la règle de caractère générique R?d et la règle de regex (f|F)ox nous permettent d'ignorer certains mots présents dans les variables, tels que Red et Fox. Dans ce scénario, le paramètre usePlaceholder a été défini sur false, car nous ne voulons pas avoir de nom d'espace réservé pour les modèles ignorés.
   La méthode WithGenerateHtml génère un rapport HTML mettant en évidence les différences.

   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. Comparaison de texte par ligne:
   Dans cet exemple, nous comparez deux variables string , initialText et modifiedText. La comparaison se fait au niveau de la ligne. La règle de caractère générique et la règle de regex fournies avec les méthodes WithIgnoreWildcardRule et WithIgnoreRegexRule sont utilisées pour ignorer des modèles spécifiques dans la comparaison. Par exemple, la règle de caractère générique R?d et la règle de regex (f|F)ox nous permettent d'ignorer certains mots présents dans les variables, tels que Red et Fox. Dans ce scénario, le paramètre usePlaceholder a été défini sur true, car nous voulons avoir un nom d'espace réservé pour les modèles ignorés.
   La méthode WithGenerateHtml génère un rapport HTML mettant en évidence les différences.

   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. Comparaison de texte par mot:
   Dans cet exemple, similaire au précédent, nous comparez deux variables string : initialText et modifiedText. La comparaison se fait au niveau des mots. La règle de caractère générique et la règle de regex fournies avec les méthodes WithIgnoreWildcardRule et WithIgnoreRegexRule sont utilisées pour ignorer des modèles spécifiques dans la comparaison. Par exemple, la règle de caractère générique R?d et la règle de regex (f|F)ox nous permettent d'ignorer certains mots présents dans les variables, tels que Red et Fox.
   La méthode WithGenerateHtml génère un rapport HTML mettant en évidence les différences.

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

Le résultat renvoyé par VerifyTextEquivalence inclut une propriété Differences , que vous pouvez utiliser pour imprimer les différences entre les textes.