Source de données PICT

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

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

PICT correspond au test combinatorial indépendant Pairwise. PICT vous permet de spécifier des variantes pour chacun de vos paramètres séparément. Par exemple, si le test d’API dépend de deux paramètres : FileName et FileExtension, vous pouvez considérer les variantes possibles à passer pour FileName et pour FileExtensions séparément comme suit :

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

À présent, vous pouvez voir qu’une expansion combinatoire par force brute de ce qui précède (4 X 7 = 28) pourrait facilement dépasser les limites à mesure que vous envisagez d’ajouter plus de variantes à 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 de PICT dans TAEF

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

Pour tirer parti de cela, é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 de 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 dernier partage de version de TAEF.

Une fois que vous avez terminé de créer votre fichier de modèle (et le fichier de départ) pour PICT et que vous l'avez vérifié à l'invite de commande contre pict.exe, vous pouvez ensuite marquer vos tests pour indiquer à TAEF qu'ils sont des tests dirigés par PICT. Si vous êtes familiarisé avec les tests basés sur des données basées 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éfixer 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 propriété TestContext et disposer d’une instance privée identique dans votre classe.

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

Toutes les métadonnées ci-dessus peuvent être définies à 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 suivante :

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 de modèle suivi d’un caractère point d’interrogation (?), puis un ensemble de paires nom de métadonnée = valeur de métadonnée séparées par des esperluettes. 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, ces avertissements sont consignés sous forme d’avertissements par TAEF. Pour chaque ligne de sortie résultante produite par PICT, TAEF réexécute le test en question.

La définition de la valeur « Pict :RandomSeed » modifie la valeur par défaut de « Pict :Random » de false à true. De cette façon, vous pouvez définir explicitement « 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 le fichier de départ spécifié est de 5 minutes. Si votre fichier de modèle est plus complexe et a besoin de plus de 5 minutes pour que PICT.exe retourne les résultats, vous pouvez dépasser 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’expiration 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 façon que pour les tests basés sur des données de table avec TAEF - à l’aide de la classe TestData pour le code natif et à l’aide de 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    }

Tout comme avec 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. L’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 que dans le cas de tests PICT, le type de données de tous les paramètres est supposé être WEX ::Common ::String (natif), String(managed) ou VT_BSTR(script). La conversion et l’interprétation sont laissées à l’utilisateur.

Maintenant que vous avez terminé de créer le test PICT à l’aide de TAEF, vous pouvez l’appeler à partir de l’invite de commandes et appliquer toutes les fonctionnalités de commande proposées par TAEF : comme /list pour obtenir une 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 de méthode de test ainsi que les métadonnées et les valeurs de données auxquelles ils sont associés etc. La chose clé à noter avant de commencer est de s’assurer que pict.exe est dans 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 de 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 être très complexes et nécessiter plus de temps pour être traité 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 ultérieur dans la même exécution d’exécution fait référence à la même combinaison de fichiers de modèle et de départ, 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 de départ n’ont pas été modifiés. Remarque : Vous devez continuer à spécifier « /persistPictResults » pour les exécutions suivantes. Toute exécution ultérieure où vous ne spécifiez pas qu’elle supprime les résultats mis en cache à la fin de cette exécution.

Si vous conservez les résultats PICT et que vous utilisez des données mises en cache, vous pouvez le définir dans le cadre de votre variable d’environnement te_cmd comme indiqué ci-dessous et éliminer la nécessité de 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 %temp% répertoire, 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 tente de supprimer les résultats mis en cache, mais s’il n’est pas en mesure de le faire, une erreur s’affiche à l’effet. L’erreur vous invite à supprimer l’emplacement des résultats mis en cache. L’échec de cette opération peut entraîner un comportement non défini ou erroné dans les tests suivants.

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

Source de données 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, cela s’effectue en spécifiant 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 reste la même qu'elle était lorsque le modèle était un fichier. De même, dans le code natif, vous pouvez rendre le nom de la ressource identique au nom de fichier. TAEF recherche d’abord la présence du fichier réel avec le nom dataSource. Si le fichier est introuvable, il continue en examinant les ressources du module de test. Étant donné que la modification de la source de données stockée dans la ressource nécessite une recompilation, vous pouvez tirer parti de cette conception en copiant sur le fichier DataSource au même emplacement que la dll de test lors du développement (et en nommant le nom de la ressource pour être identique au nom du fichier). Une fois que vous avez terminé le test, déplacez (ne copiez pas) le fichier vers le répertoire de code et recompilez pour incorporer la ressource.