Voorbeeld van eenvoudige gegevensgestuurde test

In deze sectie worden verschillende voorbeelden van gegevensgestuurde tests beschreven en worden specifieke functies in elk voorbeeld behandeld.

Het eerste voorbeeld is een eenvoudige gegevensgestuurde test met de naam SimpleDataDrivenExample.

In het beheerde voorbeeld ziet u een XML-bestand dat er als volgt uitziet:

    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>

Dit XML-bestand definieert de gegevensparameters voor onze gegevensgestuurde test voor gebruik. Het bovenste XML-knooppunt is de <gegevenstag> , die mogelijk een of meer <tabeltags> bevat die erin zijn gedefinieerd. Elke tabel moet worden gekoppeld aan een uniek id-kenmerk. De testfuncties gebruiken de waarde van de tabel-id om de specifieke tabel te identificeren die ze in het XML-bestand gaan gebruiken.

Binnen de <Table-tag> is er een optionele <ParameterTypes-sectie>. Hier kunt u expliciet het gegevenstype voor een bepaalde parameter opgeven met behulp van <ParameterTypes-tags> . In het bovenstaande voorbeeld geeft u expliciet op dat de parameter 'Grootte' van het type 'Int32' is en parameter 'Kleur' een tekenreeks is. Samenvattend: de sectie ParameterTypes is optioneel. Als er geen informatie over het parametertype wordt opgegeven, wordt deze standaard opgeslagen als een tekenreeks.

Als u de beheerde en systeemeigen voorbeelden vergelijkt, ziet u dat het enige verschil tussen de twee het <blok ParameterTypes> is. Het systeemeigen XML-bestand specificeert de grootte als van het systeemeigen gehele getaltype 'int' en gebruikt het standaardtype WEX::Common::String voor het type Kleur, omdat deze niet is gespecificeerd. Voor uw gemak toont het volgende voorbeeld het XML-bestand uit het systeemeigen voorbeeld.

    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>

De parametertypen die worden ondersteund in systeemeigen en beheerde code, worden vermeld in parametertypen in tabelgegevensbronnen.

Als er een ander gegevenstype is opgegeven, genereert de test een waarschuwing en beschouwt deze als een tekenreeks.

Als u verdergaat met de XML-bestanden, hebt u, na het <blok ParameterTypes> in beide XML-bestanden, identieke set <rijen>, die elk overeenkomen met één set gegevens in zowel onze beheerde als systeemeigen voorbeelden. In dit specifieke geval hebt u 4 sets gegevens gedefinieerd door middel van vier <rijblokken> , die elk de waarden van de parameters opgeven met behulp van de <parametertags> .

Dit omvat de essentiële basisbeginselen van de verschillende onderdelen van het gegevensbronbestand. Laten we nu eens kijken hoe u de waarden kunt ophalen die u hebt opgegeven in het bovenstaande XML-bestand.

Ontwerptest om een gegevensgestuurde test te zijn

Nu de gegevens zijn opgegeven, hebt u een manier nodig om de code of testmethode te koppelen waarmee de gegevens worden gebruikt met deze gegevens in het XML-bestand. U doet dit in zowel de beheerde als de systeemeigen voorbeelden door de metagegevens 'DataSource' op te geven. De metagegevens van DataSource hebben er drie onderdelen voor:

'Tabel:': hiermee wordt de gegevensbron geïdentificeerd als een XML-tabel.
'DataDrivenTests.xml' - dit is het bestand dat de XML-tabel bevat.
'#Table2': na de delimeter '#' identificeert de waarde Tabel2 de specifieke tabel in het XML-document dat moet worden gebruikt. Een gegevensbron voor één XML-tabel kan meerdere tabellen bevatten. TAEF doorzoekt het XML-bestand voor een tabelelement met een id-kenmerk dat overeenkomt met de opgegeven waarde.

Nogmaals, laten we eens kijken naar de code die betrekking heeft op de bovenstaande aspecten.

Systeemeigen code

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

Beheerde code

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

DataSource is een bekende eigenschap in Microsoft.VisualStudio.TestTools.UnitTesting.

Naast het bovenstaande hebt u enkele extra stappen nodig voor gegevensgestuurde tests in beheerde code. U moet ook een privé-eigenschap TestContext definiëren. Zie TestContext Class voor meer informatie. U definieert ook openbare beoordelaars voor deze eigenschap. Intern stelt TAEF deze eigenschap TestContext in, zodat u toegang hebt tot de gegevens. Laten we dit gedeelte van de code eens kort bekijken:

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

Gegevens ophalen in de testmethode

De ophaal-API's verschillen in beheerde en systeemeigen code. Laten we beginnen met het begrijpen van de systeemeigen ophaal-API:

    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 }

Let vooral op regels 4, 11 en 17. Definieer vóór elk van deze regels een lokale variabele om de gegevens op te slaan die u wilt ophalen. Het is belangrijk om het juiste type te kiezen. Omdat u 'Grootte' hebt gedefinieerd als een 'int'-type in het XML-bestand, moet u een lokale variabele van het type int definiëren om het op te halen. De ophaal-API gebruikt de naam van de parameter om op te halen als een tekenreekswaarde als de eerste parameter. De tweede parameter is de lokale variabele die door verwijzing wordt doorgegeven en door TAEF-code is ingesteld.

Deze ophaal-API wordt gedefinieerd in TestData.h en opgenomen in de WexTestClass.h-header die alle TAEF-tests bevatten.

Als u de gegevens in beheerde code wilt ophalen, gebruikt u de eigenschap TestContext die u hebt gedefinieerd. Bekijk de onderstaande code (of in het voorbeeld):

    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 }

Als u bekend bent met VSTS, zult u merken dat het bovenstaande voorbeeld vergelijkbaar is. Gebruik DataRow en geef de kolomnaam op als de naam van de parameter die u wilt ophalen.

Als u in het voorbeeld kijkt, is er ook een niet-gegevensgestuurde test in dezelfde klasse. Met andere woorden, u hebt de flexibiliteit om DataDriven- en NonDataDriven-tests in dezelfde testklasse te combineren.

SimpleDataDrivenExample uitvoeren met TAEF

Zorg ervoor dat u op de hoogte bent van het schrijven van gegevensgestuurde tests en het uitvoeren van tests met TAEF voordat u begint met tips en trucs voor het uitvoeren van DataDrivenTests met TAEF. Het kan handig zijn om uw geheugen te vernieuwen over de werking van Selectie met TAEF.

De opdrachtprompt voor het uitvoeren van gegevensgestuurde tests verschilt niet erg van het uitvoeren van een algemene test met TAEF. Als u beide voorbeelden (systeemeigen en beheerd) wilt uitvoeren die hierboven worden beschreven, voert u de volgende opdracht uit:

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

De '/name' voegt een selectiecriteria toe op basis van naam en kiest alleen de klassen waarin u geïnteresseerd bent. Als u wilt selecteren welke tests moeten worden uitgevoerd vanuit de klassen, moet u eerst alle eigenschappen van de DLL weergeven. Vervolgens kunt u bepalen welke eigenschappen moeten worden gebruikt voor selectiecriteria.

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

Voorlopig gaan we de setsOfMetadataTest en SetsOfDataTest negeren die hierboven worden vermeld. Als u hier nieuwsgierig naar bent, lees dan meer over lichtgewicht gegevensgestuurde tests. Nu u de verschillende eigenschappen en gegevensparameternaam en -waarden kent, kunt u specifieke tests selecteren op basis hiervan. Probeer ze uit en volg deze om te bevestigen wat u selecteert.

Als u alleen de niet-gegevensgestuurde tests wilt uitvoeren, voert u het volgende uit:

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

Als u nu alleen die gegevensgestuurde tests wilt uitvoeren, waarbij de kleur is opgegeven als 'Zwart', voert u het volgende uit:

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

Net zoals je deed met 'Kleur', zal @Data:<DataDrivenParameterName>=<DataDrivenParameterValue> specifieke gegevens uitvoeren op basis van de opgegeven waarde van de parameter DataDriven. In het bovenstaande geval worden WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#1 en WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#1 uitgevoerd.

Let op de testindexen in de bovenstaande lijstproperties. U kunt het bovenstaande ook selecteren op basis van de index.

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

In het bovenstaande worden dezelfde twee tests uitgevoerd die @Data:Color='Black' heeft geselecteerd. U voegt zelfs bewakers toe aan de indexselectie met @Data:Index > lowerGuardValue en @Data:index< upperGuardValue

Als u de basisbeginselen van gegevensgestuurde tests met TAEF begrijpt, volgt u de volgende klasse in dezelfde voorbeelden: metagegevens op rijniveau overschrijven, waarbij u matrixparametertypen opgeeft.

Feedback

Is deze pagina nuttig?

Last updated on 2025-07-18