activities
latest
false
Importante :
A tradução automática foi aplicada parcialmente neste conteúdo.
UiPath logo, featuring letters U and I in white
Atividades do fluxo de trabalho
Last updated 26 de nov de 2024

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

Esta página foi útil?

Obtenha a ajuda que você precisa
Aprendendo RPA - Cursos de automação
Fórum da comunidade da Uipath
Uipath Logo White
Confiança e segurança
© 2005-2024 UiPath. Todos os direitos reservados.