Verify Text Email

Verifica se dois textos são equivalentes, usando várias opções de comparação, incluindo os seguintes tipos de comparação:

• Comparando palavras.
• Comparando linhas.
• Comparando caracteres como variáveis char .

VerifyTextEquivalence(string, string, ComparisonType, ComparisonOptions)

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

baselineText String

O texto base usado como referência para comparação.

targetText String

O texto que é comparado ao texto base.

comparisonType ComparisonType (Opcional)

O tipo de comparação a ser usado ao comparar textos. As seguintes opções estão disponíveis:

• ComparisonType.Char: compara cada caractere (char) nos textos.
• ComparisonType.Line: compara cada linha nos textos.
• ComparisonType.Word: compara cada palavra nos textos.

Opts CompareDocumentsOptions

As opções de comparação específicas que devem ser usadas para esta operação. Para criar um objeto do tipo CompareDocumentsOptions, use TestingOptions.CompareText Class.

RetornarValor

ComparisonResult

O resultado da ação de comparação, armazenado em uma variável ComparisonResult . Você pode chamar as propriedades AreEquivalent ou Differences no ComparisonResult para exibir se elas são equivalentes e, se não, para exibir as diferenças.

Exemplos

Verifique os seguintes exemplos para usar a API VerifyTextEquivalence :

1. Comparar texto por caractere:
   Neste exemplo, estamos comparando duas variáveis string , initialText e modifiedText. A comparação é feita no nível do caractere. As regras do curinga e do regex fornecidas juntamente com os métodos WithIgnoreWildcardRule e WithIgnoreRegexRule são usadas para ignorar padrões específicos na comparação. Por exemplo, a regra do curinga R?d e a regra regex (f|F)ox permitem ignorar certas palavras presentes nas variáveis, como Red e Fox. Neste cenário, o parâmetro usePlaceholder foi definido como false, porque não queremos ter um nome de espaço reservado para os padrões ignorados.
   O método WithGenerateHtml gera um relatório HTML que destaca as diferenças.

   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. Comparar texto por linha:
   Neste exemplo, estamos comparando duas variáveis string , initialText e modifiedText. A comparação é feita no nível da linha. As regras do curinga e do regex fornecidas juntamente com os métodos WithIgnoreWildcardRule e WithIgnoreRegexRule são usadas para ignorar padrões específicos na comparação. Por exemplo, a regra do curinga R?d e a regra regex (f|F)ox permitem ignorar certas palavras presentes nas variáveis, como Red e Fox. Neste cenário, o parâmetro usePlaceholder foi definido como true, porque queremos ter um nome de espaço reservado para os padrões ignorados.
   O método WithGenerateHtml gera um relatório HTML que destaca as diferenças.

   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. Comparar texto por palavra:
   Neste exemplo, semelhante ao anterior, estamos comparando duas variáveis string : initialText e modifiedText. A comparação é feita no nível da palavra. As regras do curinga e do regex fornecidas juntamente com os métodos WithIgnoreWildcardRule e WithIgnoreRegexRule são usadas para ignorar padrões específicos na comparação. Por exemplo, a regra do curinga R?d e a regra regex (f|F)ox permitem ignorar certas palavras presentes nas variáveis, como Red e Fox.
   O método WithGenerateHtml gera um relatório HTML que destaca as diferenças.

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

O resultado retornado de VerifyTextEquivalence inclui uma propriedade Differences , que você pode usar para imprimir as diferenças entre os textos.