Exemple de test piloté par les données simples

Cette section décrit plusieurs exemples de tests pilotés par les données et couvre des fonctionnalités spécifiques dans chaque exemple.

Le premier exemple est un test piloté par les données de base, appelé SimpleDataDrivenExample.

Dans l’exemple managé, vous trouverez un fichier XML qui ressemble à ceci :

    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>

Ce fichier XML définit les paramètres de données à utiliser pour notre test piloté par les données. Le nœud XML supérieur est la <balise De données> , qui peut contenir une ou plusieurs <balises de table> définies dans celle-ci. Chaque table doit être associée à un attribut « ID » unique. Les fonctions de test utilisent la valeur d’ID de table pour identifier la table particulière qu’elles utiliseront dans le fichier XML.

Dans la <balise Table>, vous disposez d’une section ParameterTypes> facultative<. Ici, vous pouvez spécifier explicitement le type de données d’un paramètre donné à l’aide <de balises ParameterTypes> . Dans l’exemple ci-dessus, vous spécifiez explicitement que le paramètre « Size » est de type « Int32 » et le paramètre « Color » est une chaîne. Pour résumer : la section ParameterTypes est facultative. Par défaut, si les informations de type de paramètre ne sont pas fournies, elles sont enregistrées sous forme de chaîne.

Si vous comparez les exemples managés et natifs, vous remarquerez que la seule différence entre les deux est le <bloc ParameterTypes> . Le fichier XML natif spécifie que la Taille est de type entier natif « int » et utilise le type par défaut WEX::Common::String pour le type de Couleur en l'absence d'une spécification explicite. Pour plus de commodité, l’exemple suivant montre le fichier XML de l’exemple natif.

    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>

Les types de paramètres pris en charge dans le code natif et managé sont répertoriés dans Les types de paramètres dans les sources de données de table.

Si un autre type de données est spécifié, le test lève un avertissement et considère qu’il s’agit d’une chaîne.

Revenez aux fichiers XML, après le bloc <ParameterTypes> dans les deux fichiers XML, vous avez un ensemble identique de <lignes>, qui correspondent chacune à un jeu de données dans nos exemples gérés et natifs. Dans ce cas particulier, vous avez 4 jeux de données définis par le biais de 4 <> blocs de lignes, chacun spécifiant les valeurs des paramètres à l’aide des <balises de paramètre>.

Cela couvre les bases essentielles des différentes parties du fichier de source de données. Voyons maintenant comment récupérer les valeurs que vous avez spécifiées dans le fichier XML ci-dessus.

Création d’un test piloté par les données

Maintenant que les données sont spécifiées, vous avez besoin d’un moyen d’associer le code ou la méthode de test qui consommera les données avec ces données dans le fichier XML. Pour ce faire, dans les exemples managés et natifs, spécifiez les métadonnées « DataSource ». Les métadonnées de DataSource comportent trois parties :

'Table :' : identifie la source de données comme étant une table XML.
'DataDrivenTests.xml' : il s’agit du fichier qui contient la table XML.
'#Table2' : après le délimètre '#', la valeur 'Table2' identifie la table particulière dans le document XML à utiliser. Une seule source de données table XML peut contenir plusieurs tables. TAEF examine le fichier XML d’un élément Table avec un attribut « Id » qui correspond à la valeur spécifiée.

Une fois de plus, examinons rapidement le code qui couvre les aspects ci-dessus.

Code natif

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

Code managé

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

« DataSource » est une propriété connue dans Microsoft.VisualStudio.TestTools.UnitTesting.

En plus de ce qui précède, vous avez besoin de quelques étapes supplémentaires pour les tests pilotés par les données dans le code managé. Vous devez également définir une propriété TestContext privée. Pour plus d’informations, consultez TestContext, classe. Vous définissez également des évaluateurs publics sur cette propriété. En interne, TAEF définit cette propriété TestContext afin de pouvoir accéder aux données via celle-ci. Examinons rapidement cette partie du code :

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

Récupération de données dans la méthode test

Les API de récupération sont différentes dans le code managé et natif. Commençons par comprendre l’API de récupération native :

    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 }

Faites attention aux lignes 4, 11 et 17. Avant chacune de ces lignes, définissez une variable locale pour enregistrer les données que vous allez récupérer. Il est important d'obtenir le bon type ici. Étant donné que vous avez défini « Size » comme étant un type « int » dans le fichier XML, vous devez définir une variable locale de type int pour la récupérer. L’API de récupération prend le nom du paramètre à récupérer en tant que valeur string comme premier paramètre. Le deuxième paramètre est la variable locale passée par référence et définie par le code TAEF.

Cette API de récupération est définie dans TestData.h et incluse par l’en-tête WexTestClass.h que tous les tests TAEF incluent.

Pour récupérer les données dans le code managé, utilisez la propriété TestContext que vous avez définie. Examinez le code ci-dessous (ou dans l’exemple) :

    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 }

Si vous connaissez VSTS, vous constaterez que l’exemple ci-dessus est similaire. Utilisez DataRow et spécifiez le nom de colonne comme nom du paramètre que vous essayez de récupérer.

Si vous regardez dans l’exemple, il existe également un test non piloté par les données dans la même classe. En d’autres termes, vous avez la possibilité de combiner des tests DataDriven et NonDataDriven dans la même classe de test.

Exécution de SimpleDataDrivenExample avec TAEF

Veillez à savoir comment créer des tests pilotés par les données et comment exécuter des tests avec TAEF avant de commencer par des conseils et astuces d’exécution de DataDrivenTests avec TAEF. Il peut être utile d’actualiser votre mémoire sur le fonctionnement de la sélection avec TAEF.

L’invite de commandes pour l’exécution de tests pilotés par les données n’est pas très différente de l’exécution d’un test générique avec TAEF. Pour exécuter les deux exemples (natifs et gérés) décrits ci-dessus, exécutez simplement la commande suivante :

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

Le « /name » ajoute un critère de sélection en fonction du nom et choisit uniquement les classes qui vous intéressent. Pour sélectionner les tests à exécuter à partir des classes, vous devez d’abord répertorier toutes les propriétés de la dll. Ensuite, vous pouvez décider quelles propriétés utiliser pour les critères de sélection.

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

Pour l’instant, nous allons ignorer setsOfMetadataTest et SetsOfDataTest répertoriés ci-dessus. Si vous êtes curieux de ces informations, lisez-en davantage sur les tests pilotés par les données légères. Maintenant que vous connaissez les différentes propriétés et le nom et les valeurs des paramètres de données, vous pouvez sélectionner des tests spécifiques en fonction de cela. Essayez-les et suivez-les pour confirmer ce que vous sélectionnez.

Pour exécuter uniquement les tests non pilotés par les données, exécutez :

TE.exe Exemples\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select :"@Name='*Simple*' Et non(@DataSource=*) »

À présent, pour exécuter uniquement ces tests pilotés par les données, où la couleur est spécifiée en tant que « Noir », exécutez :

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

Comme vous l’avez fait avec « Color », @Data :<DataDrivenParameterName>=<DataDrivenParameterValue> exécute des données spécifiques en fonction de la valeur de paramètre DataDriven spécifiée. Dans le cas ci-dessus, il exécute WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#1 et WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#1

Notez les index de test dans les propriétés de liste ci-dessus. Vous pouvez également sélectionner la valeur ci-dessus en fonction de l’index.

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

Les mêmes deux tests que @Data:Color='Black' a sélectionnés seront exécutés. Vous ajoutez même des gardes à la sélection d’index avec @Data :Index > lowerGuardValue et @Data:index< upperGuardValue

Si vous comprenez les principes de base des tests pilotés par les données avec TAEF, suivez la classe suivante dans les mêmes exemples : Substitution de métadonnées au niveau ligne, spécification des types de paramètres de tableau.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-07-18