Exempel på enkelt datadrivet test

I det här avsnittet beskrivs flera exempel på datadriven testning och specifika funktioner i varje exempel.

Det första exemplet är ett grundläggande datadrivet test som kallas SimpleDataDrivenExample.

I det hanterade exemplet hittar du en XML-fil som ser ut så här:

    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>

Den här XML-filen definierar dataparametrarna för vårt datadrivna test som ska användas. Den översta XML-noden är taggen< Data>, som kan innehålla en eller flera <tabelltaggar> som definierats i den. Varje tabell måste associeras med ett unikt "ID"-attribut. Testfunktionerna använder tabell-ID-värdet för att identifiera den tabell som de ska använda i XML-filen.

I tabelltaggen <> har du ett valfritt <ParameterTypes-avsnitt>. Här kan du uttryckligen ange datatypen för en viss parameter med hjälp av <ParameterTypes-taggar> . I exemplet ovan anger du uttryckligen att parametern "Size" är av typen "Int32" och Parametern "Color" är en sträng. Sammanfattning: Avsnittet ParameterTypes är valfritt. Om parametertypsinformation inte anges sparas den som en sträng som standard.

Om du jämför de hanterade och interna exemplen ser du att den enda skillnaden mellan de två är <ParameterTypes-blocket> . Den interna XML-filen anger Storlek som ska vara av den interna heltalstypen "int" och använder standardtypen WEX::Common::String för att vara typen för Färg genom att inte ange den. För din bekvämlighet visar följande exempel XML-filen från det interna exemplet.

    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>

Parametertyperna som stöds i intern och hanterad kod visas i Parametertyper i Tabelldatakällor.

Om någon annan datatyp anges utlöser testet en varning och anser att det är en sträng.

När du fortsätter tillbaka med XML-filerna, efter <ParameterTypes-blocket> i båda XML-filerna, har du identisk uppsättning <rad>s, vilket var och en motsvarar en uppsättning data i både våra hanterade och interna exempel. I det här fallet har du 4 uppsättningar data som definierats med hjälp av 4 <radblock> , var och en anger värdena för parametrarna med hjälp <av parametertaggar> .

Det omfattar de grundläggande grunderna i de olika delarna av datakällans fil. Nu ska vi se hur du kan hämta de värden som du angav i XML-filen ovan.

Redigeringstest som ett datastyrt test

Nu när data har angetts behöver du ett sätt att associera den kod eller testmetod som ska använda data med dessa data i XML-filen. Du gör detta – både i de hanterade och interna exemplen – genom att ange metadata för "DataSource" . DataSource-metadata har tre delar:

"Table:" – detta identifierar datakällan som en XML-tabell.
"DataDrivenTests.xml" – det här är filen som innehåller XML-tabellen.
"#Table2" – Efter delimetern #identifierar värdet "Table2" den specifika tabell i XML-dokumentet som ska användas. En enskild XML-tabelldatakälla kan innehålla flera tabeller. TAEF söker igenom XML-filen efter ett tabellelement med ett ID-attribut som matchar det angivna värdet.

Än en gång kan vi ta en snabb titt på koden som täcker ovanstående aspekter.

Intern kod

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

Hanterad kod

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

"DataSource" är en känd egenskap i Microsoft.VisualStudio.TestTools.UnitTesting.

Utöver ovanstående behöver du några extra steg för datadrivna tester i hanterad kod. Du måste också definiera en privat TestContext-egenskap. Mer information finns i TestContext-klass. Du definierar också offentliga utvärderare för den här egenskapen. Internt anger TAEF den här Egenskapen TestContext så att du kan komma åt data via den. Låt oss ta en snabb titt på den här delen av koden:

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

Hämta data i testmetoden

API:erna för hämtning skiljer sig åt i hanterad och intern kod. Vi börjar med att förstå api:et för intern hämtning:

    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 }

Var särskilt uppmärksam på raderna 4, 11 och 17. Innan var och en av dessa rader definierar du en lokal variabel för att spara de data som du kommer att hämta. Det är viktigt att få rätt typ här. Eftersom du har definierat "Storlek" som en "int"-typ i XML-filen måste du definiera en lokal variabel av typen int som du vill hämta den till. Hämtnings-API:et tar namnet på parametern för att hämta som ett strängvärde som den första parametern. Den andra parametern är den lokala variabel som skickas in av referens och anges med TAEF-kod.

Det här hämtnings-API:et definieras i TestData.h och ingår i rubriken WexTestClass.h som alla TAEF-tester innehåller.

Om du vill hämta data i hanterad kod använder du egenskapen TestContext som du har definierat. Ta en titt på koden nedan (eller i exempel):

    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 }

Om du är bekant med VSTS ser du att exemplet ovan är liknande. Använd DataRow och ange kolumnnamnet som namnet på parametern som du försöker hämta.

Om du tittar i exemplet finns det också ett icke-datadrivet test i samma klass. Med andra ord har du flexibiliteten att kombinera DataDriven- och NonDataDriven-tester i samma testklass.

Köra SimpleDataDrivenExample med TAEF

Se till att du är medveten om hur du skapar datadrivna tester och hur du kör tester med TAEF innan du börjar med tips och knep för att köra DataDrivenTests med TAEF. Det kan vara bra att uppdatera minnet om hur val fungerar med TAEF.

Kommandotolken för att köra datadrivna tester skiljer sig inte särskilt mycket från att köra ett allmänt test med TAEF. Kör följande kommando för att köra båda exemplen (interna och hanterade) som beskrivs ovan:

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

"/name" lägger till ett urvalsvillkor baserat på namn och väljer endast de klasser som du är intresserad av. Om du vill välja vilka tester som ska köras inifrån klasserna bör du först lista alla egenskaper för dll-filen. Sedan kan du bestämma vilka egenskaper som ska användas för urvalskriterier.

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

För tillfället ska vi ignorera SetsOfMetadataTest och SetsOfDataTest som anges ovan. Om du är nyfiken på dessa kan du läsa mer om datadriven testning med låg vikt. Nu när du känner till de olika egenskaperna och dataparameterns namn och värden kan du välja specifika tester baserat på det. Prova dem och följ med för att bekräfta vad du väljer.

Kör bara de icke datadrivna testerna genom att köra:

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

Om du nu bara vill köra de datadrivna testerna, där färgen anges som "Svart", kör du:

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

Precis som du gjorde med "Color" kör @Data:<DataDrivenParameterName>=<DataDrivenParameterValue> specifika data baserat på angivet DataDriven-parametervärde. I ovanstående fall körs WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#1 och WEX::Examples::CSharpDataDrivenSimpleExample::DataDrivenTest#1

Observera testindexen i listegenskaperna ovan. Du kan också välja ovanstående baserat på indexet.

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

Ovanstående kör samma två tester som @Data:Color='Black' valt. Du lägger till till och med vakter i indexmarkeringen med @Data:Index > lowerGuardValue och @Data:index< upperGuardValue

Om du förstår grunderna i datadriven testning med TAEF följer du med nästa klass i samma exempel: Åsidosätta metadata på radnivå, Ange matrisparametertyper.

Feedback

Var den här sidan hjälpsam?

Last updated on 2025-07-18