Exemplo de teste simples orientado por dados

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 orientado por dados, chamado SimpleDataDrivenExample.

No exemplo gerenciado, você encontrará um arquivo XML com esta aparência:

    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>

Este arquivo XML define os parâmetros de dados para nosso teste orientado por dados consumir. O nó XML principal é a etiqueta <Data>, que pode conter uma ou mais etiquetas <Table> definidas dentro dela. Cada tabela precisa ser associada a um atributo "ID" exclusivo. As funções de teste usam o valor de ID da tabela para identificar a tabela específica que eles usarão no arquivo XML.

Dentro da <marca Table>, tem uma <seção opcional ParameterTypes>. Aqui você pode especificar explicitamente o tipo de dados para um determinado parâmetro usando <tags 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, notará que a única diferença entre os dois é o <bloco ParameterTypes> . O ficheiro XML nativo indica que o tamanho é do tipo inteiro nativo "int" e, ao não o especificar, utiliza o tipo padrão WEX::Common::String para a cor. 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âmetros suportados em código nativo e gerenciado são listados em Tipos de parâmetros em Fontes de dados de tabela.

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

Prosseguindo com os arquivos XML, após o <bloco ParameterTypes> em ambos os arquivos XML, você tem um conjunto idêntico de <Rows>s, que cada um corresponde a um conjunto de dados em nossos exemplos gerenciados e nativos. Neste caso em particular, você tem 4 conjuntos de dados definidos por meio de 4 <blocos de linha> , cada um especificando os valores dos parâmetros usando as <tags Parameter> .

Isso abrange os fundamentos essenciais das várias partes do arquivo da fonte de dados. Agora vamos ver como você pode recuperar os valores que você especificou no arquivo XML acima.

Criação de teste para ser um teste orientado por dados

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

'Tabela:' - 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 delímetro '#', o valor 'Table2' identifica a tabela específica dentro do documento XML a ser usado. Uma única fonte de dados XML Table pode conter várias tabelas. O TAEF procurará no arquivo XML 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 cobre os aspetos 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 acima, você precisa de algumas etapas extras para testes controlados por dados em código gerenciado. Você também precisa definir uma propriedade privada TestContext. Para obter mais informações, consulte TestContext Class. Você também define avaliadores públicos para esta 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 de teste

As APIs de recuperação são diferentes em código gerenciado e nativo. Vamos começar entendendo 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 especial atenção às linhas 4, 11 e 17. Antes de cada uma dessas linhas, defina uma variável local para salvar os dados que serão recuperados. É importante acertar o tipo aqui. Como você definiu "Size" como um tipo "int" no arquivo XML, você deve definir uma variável local do tipo int para recuperá-la. A API de recuperação utiliza o nome do parâmetro a recuperar como um valor String no 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ê olhar no exemplo, também há 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

Certifique-se de que você está ciente de como criar testes orientados 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 a 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 o TAEF. Para executar ambos os exemplos (nativos e gerenciados) descritos acima, basta executar o seguinte comando:

TE.exe Exemplos\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 em que está interessado. Para selecionar quais testes executar de dentro das classes, você deve primeiro 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 os SetsOfMetadataTest e SetsOfDataTest listados acima. Se você está curioso sobre isso, leia mais sobre testes leves orientados por dados. Agora que você conhece as várias propriedades e o nome e os valores do parâmetro Data, você pode selecionar testes específicos com base nisso. Experimente-os e acompanhe-os para confirmar o que selecionou.

Para executar apenas 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, onde 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 listproperties acima. Você pode selecionar o item acima com base no índice.

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

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

Se compreendes os conceitos básicos do teste controlado por dados com o TAEF, acompanha a próxima aula nos mesmos exemplos: Substituindo metadados ao nível de linha, Especificando tipos de parâmetros de matriz.

Feedback

Esta página foi útil?

Last updated on 2025-07-18