Exemplo de teste baseado em dados simples

Esta seção descreve vários exemplos de testes controlados por dados e aborda recursos específicos em cada exemplo.

O primeiro exemplo é um teste básico controlado por dados, chamado SimpleDataDrivenExample.

No exemplo gerenciado, você encontrará um arquivo XML semelhante a este:

    1  <?xml version="1.0"?>
    2  <Data>
    3    <Table Id="Table1">
    4      <ParameterTypes>
    5        <ParameterType Name="Size">Int32</ParameterType>
    6        <ParameterType Name="Color">String</ParameterType>
    7      </ParameterTypes>
    8      <Row>
    9        <Parameter Name="Size">4</Parameter>
    10       <Parameter Name="Color">White</Parameter>
    11     </Row>
    12     <Row>
    13       <Parameter Name="Size">10</Parameter>
    14       <Parameter Name="Color">Black</Parameter>
    15     </Row>
    16     <Row>
    17       <Parameter Name="Size">9</Parameter>
    18       <Parameter Name="Color">Orange</Parameter>
    19     </Row>
    20     <Row>
    21       <Parameter Name="Size">9</Parameter>
    22       <Parameter Name="Color">Blue</Parameter>
    23     </Row>
    24   </Table>
    25 </Data>

Esse arquivo XML define os parâmetros de dados que o nosso teste orientado por dados irá utilizar. O nó XML superior é a <marca de dados> , que pode conter uma ou mais <marcas de tabela> definidas dentro dele. Cada tabela precisa ser associada a um atributo exclusivo de "ID". As funções de teste usam o valor da ID da tabela para identificar a tabela específica que serão usadas no arquivo XML.

Dentro da <marca Tabela>, você tem uma seção ParameterTypes> opcional<. Aqui você pode especificar explicitamente o tipo de dados para um determinado parâmetro usando <marcas ParameterTypes> . No exemplo acima, você especifica explicitamente que o parâmetro "Size" é do tipo "Int32" e o parâmetro "Color" é uma cadeia de caracteres. Para resumir: a seção ParameterTypes é opcional. Por padrão, se as informações de tipo de parâmetro não forem fornecidas, elas serão salvas como uma cadeia de caracteres.

Se você comparar os exemplos Gerenciado e Nativo, observará que a única diferença entre os dois é o <bloco ParameterTypes> . O arquivo XML nativo especifica que Tamanho seja do tipo inteiro nativo "int" e utiliza o tipo padrão WEX::Common::String como tipo para Cor, ao não especificá-lo. Para sua conveniência, o exemplo a seguir mostra o arquivo XML do exemplo nativo.

    1  <?xml version="1.0"?>
    2  <Data>
    3    <Table Id="SimpleTable">
    4      <ParameterTypes>
    5        <ParameterType Name="Size">int</ParameterType>
    6      </ParameterTypes>
    7      <Row>
    8        <Parameter Name="Size">4</Parameter>
    9        <Parameter Name="Color">White</Parameter>
    10     </Row>
    11     <Row>
    12       <Parameter Name="Size">10</Parameter>
    13       <Parameter Name="Color">Black</Parameter>
    14     </Row>
    15     <Row>
    16       <Parameter Name="Size">9</Parameter>
    17       <Parameter Name="Color">Orange</Parameter>
    18     </Row>
    19     <Row>
    20       <Parameter Name="Size">9</Parameter>
    21       <Parameter Name="Color">Blue</Parameter>
    22     </Row>
    23   </Table>
    24 </Data>

Os tipos de parâmetro com suporte no código nativo e gerenciado são listados em Tipos de Parâmetro em Fontes de Dados de Tabela.

Se qualquer outro tipo de dados for especificado, o teste lançará um aviso e o considerará uma cadeia de caracteres.

Continuando com os arquivos XML, após o <bloco ParameterTypes> em ambos os arquivos XML, você tem um conjunto idêntico de <Linhas>, que correspondem a um conjunto de dados em nossos exemplos gerenciados e nativos. Nesse caso específico, você tem quatro conjuntos de dados definidos por meio de 4 <> blocos de linha, cada um especificando os valores dos parâmetros usando as <marcas de parâmetro>.

Isso abrange as noções básicas essenciais das várias partes do arquivo de fonte de dados. Agora vamos ver como você pode recuperar os valores especificados no arquivo XML acima.

Criar um teste para ser um teste controlado por dados

Agora que os dados são especificados, você precisa de uma maneira de associar o código ou o método de teste que consumirá os dados com esses dados no arquivo XML. Você faz isso - tanto nos exemplos gerenciados quanto nativos - especificando os metadados "DataSource ". Os metadados do DataSource têm três partes:

'Table:' – isso identifica a fonte de dados como sendo uma tabela XML.
'DataDrivenTests.xml' - este é o arquivo que contém a tabela XML.
'#Table2' – Após o delimeter '#', o valor 'Table2' identifica a tabela específica dentro do documento XML a ser usado. Uma única fonte de dados da Tabela XML pode conter várias tabelas. O TAEF irá procurar no arquivo XML por um elemento Table com um atributo 'Id' que corresponda ao valor especificado.

Mais uma vez, vamos dar uma olhada rápida no código que aborda os aspectos acima.

Código nativo

1   class SimpleDataDrivenExample
2   {
3      BEGIN_TEST_CLASS(SimpleDataDrivenExample)
4        TEST_CLASS_PROPERTY(L"Description", L"Simple example in table-based data-driven tests")
5      END_TEST_CLASS()
6   
7      TEST_METHOD_CLEANUP(TestCleanup);
8      TEST_METHOD_SETUP(TestSetup);
9    
10     BEGIN_TEST_METHOD(DataDrivenTest)
11       TEST_METHOD_PROPERTY(L"DataSource", L"Table:SimpleDataDrivenExample.xml#SimpleTable")
11     END_TEST_METHOD()
12     ...

Código gerenciado

    1 [TestMethod]
    2 [DataSource("Table:CSharpDataDrivenSimpleExample.xml#SimpleTable")]
    3 public void DataDrivenTest()
    4 {
    5  ...
    6 }

"DataSource" é uma propriedade conhecida em Microsoft.VisualStudio.TestTools.UnitTesting.

Além do indicado acima, você precisa de algumas etapas adicionais para testes controlados por dados no código gerenciado. Você também precisa definir uma propriedade TestContext privada. Para obter mais informações, consulte a Classe TestContext. Você também define assessores públicos para essa propriedade. Internamente, o TAEF define essa propriedade TestContext para que você possa acessar os dados por meio dela. Vamos dar uma olhada rápida nesta parte do código:

    1 public TestContext TestContext
    2 {
    3     get;
    4     set;
    5 }

Recuperando dados no método test

As APIs de recuperação são diferentes no código gerenciado e nativo. Vamos começar a entender a API de recuperação nativa:

    1  void SimpleDataDrivenExample::DataDrivenTest()
    2  {
    3          int size;
    4          if (SUCCEEDED(TestData::TryGetValue(L"size", size)))
    5          {
    6              VERIFY_ARE_NOT_EQUAL(size, 0);
    7              Log::Comment(String().Format(L"Size retrieved was %d", size));
    8          }
    9
    10         String color;
    11         if (SUCCEEDED(TestData::TryGetValue(L"color", color)))
    12         {
    13             Log::Comment(L"Size retrieved was " + color);
    14         }
    15
    16         unsigned int index;
    17         if (SUCCEEDED(TestData::TryGetValue(L"index", index)))
    18         {
    19             Log::Comment(String().Format(L"At index %d", index));
    20         }
    21 }

Preste atenção especial às linhas 4, 11 e 17. Antes de cada uma dessas linhas, defina uma variável local para salvar os dados que você recuperará. É importante acertar o tipo corretamente aqui. Como você definiu "Size" como um tipo "int" no arquivo XML, você deve definir uma variável local do tipo int para a qual recuperá-lo. A API de recuperação usa o nome do parâmetro a ser recuperado como um valor string como seu primeiro parâmetro. O segundo parâmetro é a variável local passada por referência e definida pelo código TAEF.

Essa API de recuperação é definida em TestData.h e incluída pelo cabeçalho WexTestClass.h que todos os testes TAEF incluem.

Para recuperar os dados no código gerenciado, use a propriedade TestContext que você definiu. Dê uma olhada no código abaixo (ou no exemplo):

    1  public void DataDrivenTest()
    2  {
    3     int size = (int)m_testContext.DataRow["Size"];
    4     Verify.AreNotEqual(size, 0);
    5     Log.Comment("Size is " + size.ToString());
    6
    7     Log.Comment("Color is " + m_testContext.DataRow["Color"]);
    8     UInt32 index = (UInt32)m_testContext.DataRow["Index"];
    9     Log.Comment("At index " + index.ToString());
    10 }

Se você estiver familiarizado com o VSTS, descobrirá que o exemplo acima é semelhante. Use o DataRow e especifique o nome da coluna como o nome do parâmetro que você está tentando recuperar.

Se você examinar o exemplo, também haverá um teste não controlado por dados na mesma classe. Em outras palavras, você tem a flexibilidade de combinar testes DataDriven e NonDataDriven na mesma classe de teste.

Executando SimpleDataDrivenExample com TAEF

Verifique se você está ciente de como criar testes controlados por dados e como executar testes com TAEF antes de começar com dicas e truques de execução de DataDrivenTests com TAEF. Pode ser útil atualizar sua memória sobre como a Seleção funciona com o TAEF.

O prompt de comando para executar testes controlados por dados não é muito diferente da execução de qualquer teste genérico com TAEF. Para executar os dois exemplos (nativos e gerenciados) descritos acima, basta executar o seguinte comando:

exemplos deTE.exe\CPP.DataDriven.Example.dll Examples\CSharp.DataDriven.Example.dll /name:*Simple*

O '/name' adiciona um critério de seleção com base no nome e escolhe apenas as classes nas quais você está interessado. Para selecionar quais testes executar de dentro das classes, primeiro você deve listar todas as propriedades da dll. Em seguida, você pode decidir quais propriedades usar para critérios de seleção.

TE.exe Examples\CPP.DataDriven.Example.dll Examples\CSharp.DataDriven.Example.dll /name:*Simple* /listproperties
f:\Examples\CPP.DataDriven.Example.dll
        WEX::TestExecution::Examples::SimpleDataDrivenExample
                Property[Description] = Simple example in table-based data-driven tests

            WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#0
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable

                    Data[Color] = White
                    Data[Size] = 4

            WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#1
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable

                    Data[Color] = Black
                    Data[Size] = 10

            WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#2
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable

                    Data[Color] = Orange
                    Data[Size] = 9

            WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#3
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable

                    Data[Color] = Blue
                    Data[Size] = 9

            WEX::TestExecution::Examples::SimpleDataDrivenExample::FirstNonDataDrivenTest
                    Setup: TestSetup
                    Teardown: TestCleanup

            WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet0
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[Data:Color] = {Purple, Maroon, Brown}

                    Data[Color] = Purple

            WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet1
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[Data:Color] = {Purple, Maroon, Brown}

                    Data[Color] = Maroon

            WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet2
                    Setup: TestSetup
                    Teardown: TestCleanup
                    Property[Data:Color] = {Purple, Maroon, Brown}

                    Data[Color] = Brown

            WEX::TestExecution::Examples::SimpleDataDrivenExample::SecondNonDataDrivenTest
                    Setup: TestSetup
                    Teardown: TestCleanup


        f:\Examples\CSharp.DataDriven.Example.dll
        WEX.Examples.CSharpDataDrivenSimpleExample
                Setup: MyClassInitialize
                Property[Description] = Simple example in table-based data-driven tests

            WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#0
                    Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable

                    Data[Color] = White
                    Data[Size] = 4

            WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#1
                    Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable

                    Data[Color] = Black
                    Data[Size] = 10

            WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#2
                    Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable

                    Data[Color] = Orange
                    Data[Size] = 9

            WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#3
                    Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable

                    Data[Color] = Blue
                    Data[Size] = 9

            WEX.Examples.CSharpDataDrivenSimpleExample.NonDataDrivenTest
            WEX.Examples.CSharpDataDrivenSimpleExample.SetsOfMetadataTest#metadataSet0
                    Property[Data:Color] = {Red, Green, Blue}

                    Data[Color] = Red

            WEX.Examples.CSharpDataDrivenSimpleExample.SetsOfMetadataTest#metadataSet1
                    Property[Data:Color] = {Red, Green, Blue}

                    Data[Color] = Green

            WEX.Examples.CSharpDataDrivenSimpleExample.SetsOfMetadataTest#metadataSet2
                    Property[Data:Color] = {Red, Green, Blue}

                    Data[Color] = Blue

Por enquanto, vamos ignorar setsOfMetadataTest e SetsOfDataTest listados acima. Se você estiver curioso sobre isso, leia mais sobre testes controlados por dados leves. Agora que você conhece as várias propriedades e os nomes e valores de parâmetros de dados, você pode selecionar testes específicos com base disso. Experimente-os e acompanhe para confirmar o que selecionar.

Para executar somente os testes não controlados por dados, execute:

TE.exe Exemplos\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' And not(@DataSource=*)"

Agora, para executar apenas os testes controlados por dados, em que a cor é especificada como "Preto", execute:

TE.exe exemplos\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' e @Data:Color='Black'"

Assim como você fez com "Color", @Data:<DataDrivenParameterName>=<DataDrivenParameterValue> executará dados específicos com base no valor do parâmetro DataDriven especificado. No caso acima, ele executará WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#1 e WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#1

Observe os índices de teste nas propriedades de lista acima. Você também pode selecionar o valor acima com base no índice.

TE.exe Exemplos\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' And @Data:Index=1"

O acima executará os mesmos dois testes que @Data:Color='Black' selecionou. Você ainda adiciona guardas à seleção de índice com @Data:Index > lowerGuardValue e @Data:index< upperGuardValue

Se você entende as noções básicas de teste orientado por dados com TAEF, acompanhe a próxima aula nos mesmos exemplos: Substituindo metadados no nível de linha, especificando tipos de parâmetro de matriz.

Comentários

Esta página foi útil?

Last updated on 2025-07-18