Source de données PICT

Assurez-vous que vous êtes familiarisé avec l’exécution de base de TAEF et que vous savez comment créer des tests à l’aide de celle-ci, avant de passer à cette section.

Arrière-plan et références PICT

PICT est l’acronyme de Pairwise Independent Combinatorial Testing. PICT vous permet de spécifier des variantes pour chacun de vos paramètres séparément. Par exemple, si le test de l’API dépend de deux paramètres : FileName et FileExtension, vous pouvez penser aux variantes possibles à passer pour FileName et pour FileExtensions séparément comme suit :

• FileName : a, z12390, Realllyreallyreallylonglonglonglonglonglonglonglong, normallength
• FileExtension : txt, png, bat, doc, exe, bmp, wav

Maintenant, vous pouvez voir qu’une expansion combinatoire par force brute de ce qui précède (4 X 7 = 28) pourrait facilement sortir des limites , car vous pensez à d’autres variantes à ajouter à la liste. Dans de tels scénarios de test, PICT peut ajouter beaucoup de valeur en générant un ensemble compact de résultats de paramètres pour obtenir une couverture combinatoire complète sur les paramètres d’entrée.

Prise en charge PICT dans TAEF

TAEF offre une prise en charge intégrée pour les tests PICT.

Pour en tirer parti, écrivez votre fichier de modèle d’entrée pour pict.exe comme vous le feriez normalement. Reportez-vous aux fichiers *.txt dans le dossier exemples mentionné ci-dessus. Il peut être utile d’essayer si PICT s’exécute comme prévu sur votre fichier modèle en l’essayant d’abord à l’invite de commandes comme suit :

pict.exe <model file> [/e:<seed file>]

Pict.exe est disponible avec le reste des fichiers binaires sur le partage de version le plus récent de TAEF.

Une fois que vous avez terminé de créer votre fichier de modèle (et le fichier initial) pour PICT et que vous l’avez vérifié par rapport à pict.exe à l’invite de commandes, vous pouvez maintenant marquer vos tests pour informer TAEF qu’il s’agit de tests pilotés par PICT. Si vous êtes familiarisé avec les tests basés sur les données basés sur des tables disponibles dans TAEF, vous trouverez cela très similaire.

Code natif :

1     class PictExample
2     {
3         TEST_CLASS(PictExample)
4
5         BEGIN_TEST_METHOD(SimpleTest)
6             TEST_METHOD_PROPERTY(L"DataSource", L"pict:PictExample.txt")
7         END_TEST_METHOD()
8
9         BEGIN_TEST_METHOD(TestWithSeed)
10            TEST_METHOD_PROPERTY(L"DataSource", L"pict:TestWithSeed.txt")
11            TEST_METHOD_PROPERTY(L"Pict:SeedingFile", L"TestWithSeed.sed")
12            TEST_METHOD_PROPERTY(L"Pict:Timeout", L"00:01:30")
13        END_TEST_METHOD()
14
15        BEGIN_TEST_METHOD(TestWithFunction)
16            TEST_METHOD_PROPERTY(L"DataSource", L"pict:TestWithFunction.txt")
17        END_TEST_METHOD()
18    };

Code managé :

1     [TestClass]
2     public class CSharpPictExample
3     {
4         [TestMethod]
5         [DataSource("pict:ConstraintsTest.txt")]
6         [TestProperty("Pict:SeedingFile", "ConstraintsTest.seed")]
7         public void ConstraintsTest()
8         {
9             ...
10        }
11
12        [TestMethod]
13        [DataSource("pict:SumofSquareRoots.txt")]
14        public void SumOfSquareRoots()
15        {
16            ...
17        }
18
19        public TestContext TestContext
20        {
21            get { return m_testContext; }
22            set { m_testContext = value; }
23        }
24
25        private TestContext m_testContext;
26    }

Comme indiqué dans les exemples ci-dessus, vous devez spécifier le nom du fichier de modèle en tant que DataSource. Vous devez précéder le nom du fichier de modèle avec « pict: » et le fournir en tant que DataSource pour votre méthode de test. Dans le cas du test managé, comme avec tout autre test piloté par les données avec TAEF, vous devez fournir des méthodes get et set de la propriété TestContext et disposer d’un instance privé de la même dans votre classe.

Si vous souhaitez passer des options de commande à PICT, vous pouvez utiliser des métadonnées à cet effet. Utilisez le tableau suivant pour mapper les options de commande de Pict.exe aux métadonnées TAEF.

L’une des métadonnées ci-dessus peut être définie à l’invite de commandes, dans la propriété DataSource ou en tant que métadonnées de test, de classe ou de module, avec priorité dans cet ordre. Pour le définir à l’invite de commandes, utilisez la syntaxe :

te.exe <test dll> /Pict:Order=3 /Pict:SeedingFile=test.seed

Pour définir des métadonnées dans la propriété DataSource, ajoutez le nom du fichier modèle avec un caractère de point d’interrogation (?), puis un ensemble d’ampères et de noms de métadonnées séparées = paires de valeurs de métadonnées. Lorsque vous utilisez cette méthode, le préfixe « Pict: » pour les noms de métadonnées est facultatif. Voici un exemple :

TEST_METHOD_PROPERTY(L"DataSource", L"Pict:model.txt?Order=3&CaseSensitive=true&Random=true")

En arrière-plan, TAEF fournit votre fichier de modèle d’entrée et les options de commande à PICT et obtient les résultats. Si PICT génère des erreurs ou des avertissements, vous les verrez enregistrés en tant qu’avertissements par TAEF. Pour chaque ligne de sortie résultante produite par PICT, TAEF appelle à nouveau le test en question.

La définition de la valeur « Pict:RandomSeed » modifie la valeur par défaut pour « Pict:Random » de false à true. De cette façon, vous pouvez explicitement définir « Pict:Random » sur false pour que TAEF ignore « Pict:RandomSeed ».

Le délai d’attente par défaut autorisé pour PICT.exe à s’exécuter sur le fichier de modèle et l’entrée de fichier initial spécifiés est de 5 minutes. Si votre fichier modèle est plus impliqué et a besoin de plus de 5 minutes pour PICT.exe de retourner des résultats, vous pouvez remplacer ce délai d’attente comme indiqué dans l’exemple CPP ci-dessus en spécifiant les métadonnées « Pict:Timeout ». Dans l’exemple, un délai d’attente de 1,5 minute est spécifié via le format de délai d’attente TAEF standard. Comme les autres métadonnées PICT, les métadonnées « Pict:Timeout » sont héritées et peuvent donc être spécifiées pour l’ensemble de la classe ou du module.

Vous pouvez accéder aux valeurs de données lors d’un appel donné à partir de votre méthode de test et de ses méthodes d’installation et de nettoyage associées de la même manière que pour les tests basés sur des données basés sur des tables avec TAEF , en utilisant la classe TestData pour le code natif et en utilisant TestContext pour le code managé comme suit :

Code natif :

1     void PictExample::SimpleTest()
2     {
3         String valueA;
4         if (SUCCEEDED(TestData::TryGetValue(L"A", valueA)))
5         {
6           Log::Comment(L"A retrieved was " + valueA);
7         }
8
9         String valueB;
10        if (SUCCEEDED(TestData::TryGetValue(L"B", valueB)))
11        {
12            Log::Comment(L"B retrieved was " + valueB);
13        }
14
15        String valueC;
16        if (SUCCEEDED(TestData::TryGetValue(L"C", valueC)))
17        {
18            Log::Comment(L"C retrieved was " + valueC);
19        }
20
21        unsigned int index;
22        if (SUCCEEDED(TestData::TryGetValue(L"index", index)))
23        {
24            Log::Comment(String().Format(L"At index %d", index));
25        }
26    }

Code managé :

1      [TestClass]
2      public class CSharpPictExample
3      {
4          [TestMethod]
5          [DataSource("pict:ConstraintsTest.txt")]
6          public void ConstraintsTest()
7          {
8              Log.Comment("A is " + m_testContext.DataRow["A"]);
9              Log.Comment("B is " + m_testContext.DataRow["B"]);
10             Log.Comment("C is " + m_testContext.DataRow["C"]);
11             Log.Comment("D is " + m_testContext.DataRow["D"]);
12
13             UInt32 index = (UInt32)m_testContext.DataRow["Index"];
14             Log.Comment("At index " + index.ToString());
15        }
16
17        [TestMethod]
18        [DataSource("pict:SumofSquareRoots.txt")]
19        public void SumOfSquareRoots()
20        {
21             Log.Comment("A is " + m_testContext.DataRow["A"]);
22             Log.Comment("B is " + m_testContext.DataRow["B"]);
23
24             UInt32 index = (UInt32)m_testContext.DataRow["Index"];
25             Log.Comment("At index " + index.ToString());
26        }
27
28        public TestContext TestContext
29        {
30             get { return m_testContext; }
31             set { m_testContext = value; }
32        }
33
34        private TestContext m_testContext;
35    }

Comme pour tous les tests pilotés par les données dans TAEF, « Index » est réservé et ne doit pas être utilisé comme nom de paramètre. Index fait implicitement référence à l’index de l’appel de méthode de test et est accessible à partir de la méthode de test si votre test en a besoin.

Il est également important de noter qu’en cas de tests PICT, le type de données de tous les paramètres est supposé être WEX::Common::String (natif), String (managé) ou VT_BSTR(script). La conversion et l’interprétation sont laissées à l’utilisateur.

Maintenant que vous avez terminé la création du test PICT à l’aide de TAEF, vous pouvez l’appeler à partir de l’invite de commandes et lui appliquer toutes les fonctionnalités de commande proposées par TAEF : comme /list pour obtenir la liste de toutes les méthodes de test qui seront générées à l’aide de la sortie PICT en tant que données, /listproperties pour obtenir une liste des noms des méthodes de test ainsi que les métadonnées et les valeurs de données auxquelles elles sont associées Etc. La chose clé à noter avant de commencer est de vous assurer que pict.exe est sur votre chemin.

Voici quelques exemples :

te Examples\CPP.Pict.Example.dll /list /name:*SimpleTest*
Test Authoring and Execution Framework v2.9.3k for x86
        f:\ Examples\CPP.Pict.Example.dll
            WEX::TestExecution::Examples::PictExample
                WEX::TestExecution::Examples::PictExample::SimpleTest#0
                WEX::TestExecution::Examples::PictExample::SimpleTest#1
                WEX::TestExecution::Examples::PictExample::SimpleTest#2
                WEX::TestExecution::Examples::PictExample::SimpleTest#3
                WEX::TestExecution::Examples::PictExample::SimpleTest#4
                WEX::TestExecution::Examples::PictExample::SimpleTest#5
                WEX::TestExecution::Examples::PictExample::SimpleTest#6
                WEX::TestExecution::Examples::PictExample::SimpleTest#7
                WEX::TestExecution::Examples::PictExample::SimpleTest#8
                WEX::TestExecution::Examples::PictExample::SimpleTest#9
                WEX::TestExecution::Examples::PictExample::SimpleTest#10
                WEX::TestExecution::Examples::PictExample::SimpleTest#11
                WEX::TestExecution::Examples::PictExample::SimpleTest#12
                WEX::TestExecution::Examples::PictExample::SimpleTest#13
                WEX::TestExecution::Examples::PictExample::SimpleTest#14
                WEX::TestExecution::Examples::PictExample::SimpleTest#15
                WEX::TestExecution::Examples::PictExample::SimpleTest#16
                WEX::TestExecution::Examples::PictExample::SimpleTest#17
                WEX::TestExecution::Examples::PictExample::SimpleTest#18
                WEX::TestExecution::Examples::PictExample::SimpleTest#19
                WEX::TestExecution::Examples::PictExample::SimpleTest#20
                WEX::TestExecution::Examples::PictExample::SimpleTest#21
                WEX::TestExecution::Examples::PictExample::SimpleTest#22
                WEX::TestExecution::Examples::PictExample::SimpleTest#23

Pour en savoir plus sur les critères de sélection (/select et /name), reportez-vous à la page wiki sélection.

te Examples\Csharp.Pict.Example.dll /listproperties /select:"@Name='*SumofSquare*'
                    and @Data:index>10
Test Authoring and Execution Framework v2.9.3k for x86
        f:\ Examples\CSharp.Pict.Example.dll
            WEX.Examples.CSharpPictExample
                WEX.Examples.CSharpPictExample.SumOfSquareRoots#11
                        Property[DataSource] = pict:SumofSquareRoots.txt
                        Data[a] = 1
                        Data[b] = ~-1
                WEX.Examples.CSharpPictExample.SumOfSquareRoots#12
                        Property[DataSource] = pict:SumofSquareRoots.txt
                        Data[a] = 2
                        Data[b] = ~-1

L’exemple ci-dessus montre comment sélectionner à l’aide de l’index. Vous pouvez également choisir de sélectionner en fonction de la valeur des données.

te Examples\Csharp.Pict.Example.dll /listproperties /select:"@Name='*SumofSquare*'
                    and (@Data:A='1' and @Data:B='1')"
Test Authoring and Execution Framework v2.9.3k for x86
        f:\ Examples\CSharp.Pict.Example.dll
            WEX.Examples.CSharpPictExample
                WEX.Examples.CSharpPictExample.SumOfSquareRoots#8
                        Property[DataSource] = pict:SumofSquareRoots.txt
                        Data[a] = 1
                        Data[b] = 1

Mise en cache des résultats PICT

Certains fichiers de modèle peuvent devenir très complexes et nécessiter plus de temps pour être traités par Pict.exe. TAEF tente d’atténuer le temps de traitement des résultats en mettant en cache les résultats pendant une exécution donnée de Te.exe. Si un test suivant dans la même exécution fait référence à la même combinaison de modèle et de fichier initial, TAEF utilise les résultats mis en cache. Par défaut, à la fin de chaque exécution, les résultats mis en cache sont supprimés.

Si vous souhaitez continuer à tirer parti des résultats mis en cache dans les exécutions suivantes, vous pouvez spécifier l’option « /persistPictResults » à l’invite de commandes pendant l’exécution. Chaque fois que vous spécifiez « /persistPictResults » pour votre commande, la première exécution s’exécute réellement pict.exe et peut prendre beaucoup de temps, mais toutes les exécutions suivantes utilisent les résultats mis en cache dans les cas où le modèle et le fichier initial n’ont pas été modifiés. Remarque : Vous devez continuer à spécifier « /persistPictResults » pour les exécutions suivantes. Toute exécution ultérieure dans laquelle vous ne le spécifiez pas supprimera les résultats mis en cache à la fin de cette exécution.

Si la persistance des résultats PICT et l’utilisation de données mises en cache sont une chose que vous souhaitez faire par défaut, vous pouvez les définir dans le cadre de votre variable d’environnement te_cmd comme indiqué ci-dessous et éviter d’avoir à la spécifier à chaque exécution. Pour plus d’informations sur te_cmd, consultez Exécution de tests .

set te_cmd = /persistPictResults

Les fichiers de résultats mis en cache sont stockés dans un dossier appelé « TAEF-PICT » dans le répertoire %temp% si Te.exe y a accès ou dans le répertoire d’exécution actuel à partir duquel Te.exe a été lancé. La seule fois où vous pouvez avoir les résultats dans un état incohérent est si vous appuyez sur Ctrl + C pendant l’exécution. Dans ce cas, TAEF tentera de supprimer les résultats mis en cache, mais s’il n’est pas en mesure de le faire, vous verrez une erreur à l’effet. L’erreur vous invite à supprimer l’emplacement des résultats mis en cache. Le fait de ne pas faire peut entraîner un comportement non défini ou erroné dans les tests suivants.

Grâce à la prise en charge intégrée de PICT dans TAEF, vous pouvez désormais tirer le meilleur parti des fonctionnalités dans PICT et des fonctionnalités de TAEF dans votre automatisation de test.

DataSource en tant que ressource

Vous pouvez ajouter des modèles PICT et des fichiers d’amorçage en tant que ressources dans votre module de test.

Dans le code natif, pour cela, spécifiez le nom de la ressource au lieu du nom de fichier dans les métadonnées DataSource. Voici un exemple :

BEGIN_TEST_METHOD(ResourceNameDataSource)
    TEST_METHOD_PROPERTY(L"DataSource", L"Pict:MyModelResourceName?SeedingFile=MySeedingResourceName")
END_TEST_METHOD()

« MyModelResourceName » et « MySeedingResourceName » sont les noms de ressources définis dans un fichier .rc. Le type de ressource doit être DATAFILE, contrairement aux sources de données de table où le type de ressource doit être DATASOURCE_XML.

MyModelResourceName DATAFILE "model.txt"
MySeedingResourceName DATAFILE "seed.txt"

La valeur des métadonnées DataSource restera la même que lorsqu’il s’agissait d’un fichier. De même, dans le code natif, vous pouvez faire en sorte que le nom de la ressource soit identique au nom du fichier. TAEF recherche d’abord la présence du fichier réel avec le nom DataSource. Si le fichier est introuvable, il continue en recherchant dans les ressources du module de test. Étant donné que la modification du DataSource stockée dans la ressource nécessite une recompilation, vous pouvez tirer parti de cette conception en copiant le fichier DataSource vers le même emplacement que la dll de test lors du développement (et en nommant le nom de la ressource comme étant le même nom que le nom de fichier). Une fois le test terminé, déplacez (et non copier) le fichier dans le répertoire de code et recompilez pour incorporer la ressource.