Condividi tramite

Esempio di test basato su dati semplice

Questa sezione descrive diversi esempi di test basati sui dati e illustra funzionalità specifiche in ogni esempio.

Il primo esempio è un test basato sui dati di base, denominato SimpleDataDrivenExample.

Nell'esempio gestito è presente un file XML simile al seguente:

    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>

Questo file XML definisce i parametri di dati da utilizzare per il test basato sui dati. Il nodo XML principale è il <tag Data> , che può contenere uno o più <tag table> definiti al suo interno. Ogni tabella deve essere associata a un attributo "ID" univoco. Le funzioni di test usano il valore id tabella per identificare la tabella specifica che useranno nel file XML.

All'interno del <tag Table> è disponibile una sezione ParameterTypes> facoltativa<. Qui è possibile specificare in modo esplicito il tipo di dati per un determinato parametro usando <i tag ParameterTypes> . Nell'esempio precedente si specifica in modo esplicito che il parametro "Size" è di tipo "Int32" e Parameter "Color" è una stringa. Per riepilogare: la sezione ParameterTypes è facoltativa. Per impostazione predefinita, se le informazioni sul tipo di parametro non vengono fornite, verranno salvate come stringa.

Se si confrontano gli esempi gestiti e nativi, si noterà che l'unica differenza tra i due è il <blocco ParameterTypes> . Il file XML nativo specifica che Size deve essere del tipo integer nativo "int" e usa il tipo predefinito WEX::Common::String per essere il tipo per Color senza specificarlo. Per praticità, nell'esempio seguente viene illustrato il file XML dell'esempio 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>

I tipi di parametro supportati in Codice nativo e gestito sono elencati in Tipi di parametro nelle origini dati della tabella.

Se viene specificato un altro tipo di dati, il test genererà un avviso e considererà string.

Continuando con i file XML, dopo il <blocco ParameterTypes in entrambi i> file XML, è disponibile un set identico di <righe>, che corrispondono a un set di dati sia negli esempi gestiti che nativi. In questo caso specifico sono presenti 4 set di dati definiti tramite 4 <blocchi row> , ognuno dei quali specifica i valori dei parametri usando i <tag Parameter> .

Che illustra le nozioni di base essenziali delle varie parti del file di origine dati. Si vedrà ora come recuperare i valori specificati nel file XML precedente.

Creazione di un test basato sui dati

Ora che i dati vengono specificati, è necessario un modo per associare il codice o il metodo di test che utilizzerà i dati con questi dati nel file XML. A tale scopo, sia negli esempi gestiti che nativi, specificare i metadati "DataSource". I metadati di DataSource hanno tre parti al suo interno:

  1. 'Table:': identifica l'origine dati come tabella XML.
  2. 'DataDrivenTests.xml': si tratta del file che contiene la tabella XML.
  3. '#Table2': dopo il delimeter '#', il valore 'Table2' identifica la tabella specifica all'interno del documento XML da usare. Una singola origine dati tabella XML può contenere più tabelle. TAEF esaminerà il file XML per un elemento Table con un attributo 'Id' che corrisponde al valore specificato.

Ancora una volta, esaminiamo rapidamente il codice che copre gli aspetti precedenti.

Codice 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     ...

Codice gestito

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

"DataSource" è una proprietà nota in Microsoft.VisualStudio.TestTools.UnitTesting.

Oltre a quanto sopra riportato, sono necessari alcuni passaggi aggiuntivi per i test basati sui dati nel codice gestito. È anche necessario definire una proprietà TestContext privata. Per altre informazioni, vedere Classe TestContext. Si definiscono anche i valutatori pubblici per questa proprietà. Internamente TAEF imposta questa proprietà TestContext in modo da poter accedere ai dati tramite di esso. Esaminiamo rapidamente questa parte di codice:

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

Recupero dei dati nel metodo Test

Le API di recupero sono diverse nel codice gestito e nativo. Si inizierà a comprendere l'API di recupero 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 }

Prestare particolare attenzione alle righe 4, 11 e 17. Prima di ognuna di queste righe, definire una variabile locale per salvare i dati che verranno recuperati. È importante ottenere il tipo proprio qui. Poiché "Size" è stato definito come tipo "int" nel file XML, è necessario definire una variabile locale di tipo int per recuperarla. L'API di recupero accetta il nome del parametro da recuperare come valore String come primo parametro. Il secondo parametro è la variabile locale passata per riferimento e impostata dal codice TAEF.

Questa API di recupero viene definita in TestData.h e inclusa nell'intestazione WexTestClass.h inclusa in tutti i test TAEF.

Per recuperare i dati nel codice gestito, utilizzare la proprietà TestContext definita. Esaminare il codice seguente (o ad esempio):

    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 si ha familiarità con VSTS, si noterà che l'esempio precedente è simile. Usare DataRow e specificare il nome della colonna come nome del parametro che si sta tentando di recuperare.

Se si esamina l'esempio, è presente anche un test non basato sui dati nella stessa classe. In altre parole, è possibile combinare i test DiDriven e NonDataDriven nella stessa classe di test.

Esecuzione di SimpleDataDrivenExample con TAEF

Assicurarsi di conoscere come creare test basati sui dati e come eseguire test con TAEF prima di iniziare con suggerimenti e consigli per l'esecuzione di DataDrivenTest con TAEF. Potrebbe essere utile aggiornare la memoria sul funzionamento di Selection con TAEF.

Il prompt dei comandi per l'esecuzione di test basati sui dati non è molto diverso dall'esecuzione di alcun test generico con TAEF. Per eseguire entrambi gli esempi (nativi e gestiti) descritti in precedenza, eseguire il comando seguente:

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

"/name" aggiunge criteri di selezione in base al nome e sceglie solo le classi a cui si è interessati. Per selezionare i test da eseguire all'interno delle classi, è necessario innanzitutto elencare tutte le proprietà della dll. È quindi possibile decidere quali proprietà usare per i criteri di selezione.

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

Per il momento, si ignorerà setOfMetadataTest e SetsOfDataTest elencati in precedenza. Per altre informazioni, leggere altre informazioni sui test basati sui dati di peso leggero. Ora che si conoscono le varie proprietà e il nome e i valori dei parametri di dati, è possibile selezionare test specifici in base a tale proprietà. Provali e segui la procedura per confermare ciò che selezioni.

Per eseguire solo i test non basati sui dati, eseguire:

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

A questo momento, per eseguire solo i test basati sui dati, in cui il colore viene specificato come "Nero", eseguire:

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

Proprio come per "Color", @Data:<DataDrivenParameterName>=<DataDrivenParameterValue> eseguirà dati specifici in base al valore del parametro DataDriven specificato. Nel caso precedente, verrà eseguito WEX::TestExecution::Examples::SimpleDataDrivenExample::D ataDrivenTest#1 e WEX. Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#1

Si notino gli indici di test nelle proprietà dell'elenco precedente. È anche possibile selezionare l'oggetto precedente in base all'indice.

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

In precedenza verranno eseguiti gli stessi due test @Data:Color=selezionati da "Nero". È anche possibile aggiungere guardie alla selezione dell'indice con @Data:Index > lowerGuardValue e @Data:index< upperGuardValue

Se si conoscono le nozioni di base dei test basati sui dati con TAEF, seguire la classe successiva negli stessi esempi: Override dei metadati a livello di riga, Specifica dei tipi di parametri di matrice.