VerificarEquivalenciaDeTexto

Verifica si dos textos son equivalentes, utilizando múltiples opciones de comparación, incluidos los siguientes tipos de comparación:

• Comparar palabras.
• Comparar líneas.
• Comparando caracteres como variables char .

VerifyTextEquivalence(string, string, ComparisonType, ComparisonOptions)

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

baselineText Cadena

El texto base que se utiliza como referencia para la comparación.

targetText Cadena

El texto que se compara con el texto base.

comparisonType ComparisonType (opcional)

El tipo de comparación que se utilizará al comparar textos. Las siguientes opciones están disponibles:

• ComparisonType.Char: compara cada carácter (char) en los textos.
• ComparisonType.Line: compara cada línea de los textos.
• ComparisonType.Word: compara cada palabra de los textos.

Opta CompareDocumentsOptions

Las opciones de comparación específicas que deben utilizarse para esta operación. Para crear un objeto de tipo CompareDocumentsOptions, utiliza la clase TestingOptions.CompareText.

ValorDeRetorno

ComparisonResult

El resultado de la acción de comparación, almacenado en una variable ComparisonResult . Puedes llamar a las propiedades AreEquivalent o Differences en ComparisonResult para mostrar si son equivalentes, y si no, para mostrar las diferencias.

Ejemplos

Consulta los siguientes ejemplos para utilizar la API VerifyTextEquivalence :

1. Comparar texto por carácter:
   En este ejemplo, estamos comparando dos variables string , initialText y modifiedText. La comparación se realiza a nivel de carácter. La regla de comodín y la regla de expresión regular proporcionadas junto con los métodos WithIgnoreWildcardRule y WithIgnoreRegexRule se utilizan para ignorar patrones específicos en la comparación. Por ejemplo, la regla comodín R?d y la regla regex (f|F)ox nos permiten ignorar ciertas palabras que están presentes en las variables, como Red y Fox. En este escenario, el parámetro usePlaceholder se estableció en false, porque no queremos tener un nombre de marcador de posición para los patrones ignorados.
   El método WithGenerateHtml genera un informe HTML que destaca las diferencias.

   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 línea:
   En este ejemplo, estamos comparando dos variables string , initialText y modifiedText. La comparación se realiza a nivel de línea. La regla de comodín y la regla de expresión regular proporcionadas junto con los métodos WithIgnoreWildcardRule y WithIgnoreRegexRule se utilizan para ignorar patrones específicos en la comparación. Por ejemplo, la regla comodín R?d y la regla regex (f|F)ox nos permiten ignorar ciertas palabras que están presentes en las variables, como Red y Fox. En este escenario, el parámetro usePlaceholder se estableció en true, porque queremos tener un nombre de marcador de posición para los patrones ignorados.
   El método WithGenerateHtml genera un informe HTML que destaca las diferencias.

   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 palabra:
   En este ejemplo, similar al anterior, estamos comparando dos variables string : initialText y modifiedText. La comparación se realiza a nivel de palabra. La regla de comodín y la regla de expresión regular proporcionadas junto con los métodos WithIgnoreWildcardRule y WithIgnoreRegexRule se utilizan para ignorar patrones específicos en la comparación. Por ejemplo, la regla comodín R?d y la regla regex (f|F)ox nos permiten ignorar ciertas palabras que están presentes en las variables, como Red y Fox.
   El método WithGenerateHtml genera un informe HTML que destaca las diferencias.

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

El resultado devuelto por VerifyTextEquivalence incluye una propiedad Differences , que puedes utilizar para imprimir las diferencias entre los textos.