Groupes d’exécution

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. Vous souhaiterez peut-être également passer par quelques exemples de test pilotés par les données répertoriés dans le Guide de l’utilisateur.

test deScenario-Based avec TAEF

Lorsque vous parlez de tests au niveau du scénario, vous parlez vraiment d’une série de tests, où l’exécution du test suivant n’est logique que si le test précédent dans le scénario a réussi. Dans certains cas, vous n’avez peut-être même pas toutes les informations dont vous avez besoin pour exécuter le test suivant si le test précédent a échoué. Vers cette fin, tout en conservant l’unité d’exécution en tant que méthode de test et en permettant des scénarios de test, TAEF prend en charge ce qu’on appelle « ExecutionGroup ». Vous pouvez avoir des tests basés sur des scénarios dans TAEF tout en utilisant également des fonctionnalités telles que les tests pilotés par données. Si vous concevez votre scénario pour tirer parti des tests pilotés par les données, vous pouvez appliquer la prise en charge pilotée par les données au niveau de la classe à l’aide des fonctionnalités de classe pilotées par les données offertes par TAEF. En appliquant la prise en charge pilotée par les données au niveau de la classe, vous pouvez exécuter tous les tests au sein de votre classe de manière séquentielle pour chaque ligne.

Cette page se concentre sur la façon de spécifier une séquence de tests au sein d’une classe en tant que « ExecutionGroup ».

Groupes d’exécution

Avant de discuter des groupes d’exécution, il est important de noter et de se rappeler que dans TAEF, l’ordre d’exécution des tests au sein d’une classe est l’ordre dans lequel vous les avez qualifiés comme un TEST_METHOD(...) en cas de code natif, ou ajouté [TestMethod] propriété avant la méthode en cas de code managé. TAEF ne garantit pas l’ordre d’exécution des classes elles-mêmes.

Maintenant, dans les tests basés sur des scénarios, il peut ne pas suffire de garantir simplement l’ordre d’exécution, vous devez également garantir que tous les tests précédents du scénario ont réussi avant de passer au test suivant dans le scénario. C’est là que le concept de « ExecutionGroup » vous sera utile.

Prenons un exemple natif :

1     class ExecutionDependencyExample
2     {
3         BEGIN_TEST_CLASS(ExecutionDependencyExample)
4             TEST_CLASS_PROPERTY(L"ExecutionGroup", L"DependentTests")
5         END_TEST_CLASS()
6
7         TEST_METHOD(Test1)
8         {
9             Log::Comment(L"Test1 passes.");
10        }
11
12        TEST_METHOD(Test2)
13        {
14            Log::Comment(L"Test2 fails.");
15            VERIFY_ARE_EQUAL(2, 3);
16        }
17
18        TEST_METHOD(Test3)
19        {
20            Log::Comment(L"Test3 is blocked; so you shouldn't see this.");
21        }
22    };

Consultez la ligne 4 dans l’extrait de code de fichier C++ ci-dessus. Dans ce cas particulier, vous qualifiez tous les tests au sein de la classe ExecutionDependencyExample pour appartenir à un « ExecutionGroup » appelé « DependentTests ». Cela signifie que « Test1 », « Test2 » et « Test3 » font partie du groupe d’exécution « DependentTests ». Comme mentionné précédemment, Test2 est exécuté si et uniquement si Test1 est exécuté avec succès et réussit. De même, Test3 est exécuté si et uniquement si Test2 est exécuté correctement et réussit.

Vous verrez que Test2 a été conçu pour échouer (voir les lignes 14 et 15 ci-dessus).

Étant donné que Test2 échoue dans notre « DependentTests » « ExecutionGroup », Test3 n’est pas exécuté et sera marqué comme bloqué. Essayons d’exécuter le test ci-dessus et de voir si c'est effectivement vrai.

te Examples\CPP.ExecutionDependency.Example.dll
Test Authoring and Execution Framework v2.93k for x86

StartGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test1
Test1 passes.
EndGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test1 
    [Passed]

StartGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test2
Test2 fails.
Error: Verify: AreEqual(2, 3) - Values (2, 3) [File: >f:source\executiondependencyexample\executiondependencyexample.cpp,
Function: WEX::TestExecution::Examples::ExecutionDependencyExample::Test2, Line:21] 
EndGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test2[Failed] 

StartGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test3
Blocked: This test belongs to an execution group and depends on the previous test being executed in the same environment successfully. The dependent test must be selected for execution, must request the same execution environment (e.g. 'ThreadingModel') and must be executed successfully.
EndGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test3 [Blocked]

Non-passing Tests:
    WEX::TestExecution::Examples::ExecutionDependencyExample::Test2 [Failed]
    WEX::TestExecution::Examples::ExecutionDependencyExample::Test3 [Blocked]

Summary: Total=3, Passed=1, Failed=1, Blocked=1, Not Run=0, Skipped=0

Notez que, comme prévu, Test1 réussi, Test2 a échoué et Test3 a été bloqué. Avec Test3, TAEF enregistre un message indiquant que Test3 appartient à un groupe d’exécution et que le test précédent n’a pas réussi à s’exécuter.

Ce message d’erreur indique également que tous les tests avant l’exécution du test actuel qui appartiennent au même ExecutionGroup doivent être sélectionnés. En d’autres termes, si vous essayez d’exécuter uniquement Test2 à l’aide d’un critère de sélection lors de l’exécution, vous constaterez que Test2 sera bloqué, car il dépend de Test1, faisant partie du même Groupe d’exécution.

te Examples\CPP.ExecutionDependency.Example.dll /name:*Test2*
Test Authoring and Execution Framework v2.9.3k for x86

StartGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test2
Blocked: This test belongs to an execution group and depends on the previous test being executed in the same environment successfully. The dependent test must be selected for execution, must request the same execution environment (e.g. 'ThreadingModel') and must be executed successfully.

EndGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test2 [Blocked]

Summary: Total=1, Passed=0, Failed=0, Blocked=1, Not Run=0, Skipped=0

Si toutefois, vous sélectionnez Test1, qui est le premier test dans executionGroup, il s’exécute correctement.

te Examples\CPP.ExecutionDependency.Example.dll /name:*Test1*
Test Authoring and Execution Framework v2.9.3k for x86
StartGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test1
Test1 passes.
EndGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test1 [Passed]

Summary: Total=1, Passed=1, Failed=0, Blocked=0, Not Run=0, Skipped=0

En outre, si vous avez des tests qui n’appartiennent pas au groupe d’exécution, ils sont exécutés indépendamment du résultat d’exécution des tests au sein du groupe d’exécution qui les poursuivent. Il est également possible d’avoir plusieurs ExecutionGroup au sein d’une classe. Notez toutefois que ExecutionGroup ne peut pas s’étendre sur plusieurs classes. Si vous le faites, ils seront considérés comme deux ExecutionGroups distincts, un dans chaque classe.

Le message indique également que Test3 doit être exécuté dans le même environnement que Test2. Essayons de comprendre cet aspect en un peu plus de détails. Puisqu'être membre d'un groupe d'exécution signifie vraiment faire partie du test basé sur le scénario, il devient crucial que tous les tests soient demandés et s'exécutent donc dans le même environnement. Par exemple, si le modèle de thread change dans un groupe d’exécution, vous verrez des tests bloqués. Par exemple, dans l’exemple ci-dessus, Test2 a été conçu pour s’exécuter correctement, mais si la propriété « ThreadingModel » définie sur « MTA », Test3 est toujours bloquée.

Prenons un autre exemple : Exemples\TAEF\CSharp\ExecutionDependentGroupsExample (reportez-vous au dernier partage de version TAEF)

1     [TestClass]
2     public class CSharpExecutionDependentGroupsExample
3     {
4         //First Execution Group: Test1, Test2
5         [TestMethod]
6         [TestProperty("ExecutionGroup", "First Execution Group")]
7         public void Test1()
8         {
9             Log.Comment("Part of First Execution Group");
10        }
11        [TestMethod]
12        [TestProperty("ExecutionGroup", "First Execution Group")]
13        public void Test2()
14        {
15            Log.Comment("Part of First Execution Group");
16        }
17
18        //Second Execution Group: Test3, Test4. Test4 fails
19        [TestMethod]
20        [TestProperty("ExecutionGroup", "Second Execution Group")]
21        public void Test3()
22        {
23            Log.Comment("Part of Second Execution Group");
24        }
25        [TestMethod]
26        [TestProperty("ExecutionGroup", "Second Execution Group")]
27        public void Test4()
28        {
29            Log.Comment("Part of Second Execution Group - last in group fails");
30            Verify.IsTrue(false);
31        }
32
33        //Third Execution Group: Test5, Test6, Test7. Test6 fails, Test7 will be blocked.
34        [TestMethod]
35        [TestProperty("ExecutionGroup", "Third Execution Group")]
36        public void Test5()
37        {
38            Log.Comment("Part of Third Execution Group");
39        }
40        [TestMethod]
41        [TestProperty("ExecutionGroup", "Third Execution Group")]
42        public void Test6()
43        {
44            Log.Comment("Part of Third Execution Group - middle in this set of 3 fails");
45            Verify.IsTrue(false);
46        }
47        [TestMethod]
48        [TestProperty("ExecutionGroup", "Third Execution Group")]
49        public void Test7()
50        {
51            Log.Comment("Part of Third Execution Group");
52        }
53
54        //Fourth Execution Group: Test8, Test9
55        [TestMethod]
56        [TestProperty("ExecutionGroup", "Fourth Execution Group")]
57        public void Test8()
58        {
59            Log.Comment("Part of Fourth Execution Group");
60        }
61        [TestMethod]
62        [TestProperty("ExecutionGroup", "Fourth Execution Group")]
63        public void Test9()
64        {
65            Log.Comment("Part of Fourth Execution Group");
66        }
67    }

Cet exemple comporte 4 groupes d’exécution différents :

« Premier groupe d'exécution » contient Test1, Test2 ; tous deux doivent réussir avec succès.
« Second Execution Group » contient Test3 et Test4. Test4 est le dernier test de ce Groupe d’exécution et échoue.
« Troisième groupe d’exécution » contient Test5, Test6 et Test7. Test5 s’exécute et réussit bien que Test4 de l’ancien ExecutionGroup ait échoué. Test6 est conçu pour échouer, ce qui entraîne le blocage de Test7.
« Quatrième groupe d’exécution » contient Test8 et Test9. Une fois de plus, bien que Test7 du groupe d'exécution précédent ait été bloqué en raison de l'échec de Test6, Test8 s'exécutera avec succès et Test9 s'exécutera également avec succès.

Pour mieux comprendre les ExecutionGroups de cet exemple, nous allons répertorier les propriétés de cet exemple.

te Examples\CSharp.ExecutionDependentGroups.Example.dll /listproperties
Test Authoring and Execution Framework v2.9.3k for x86

        F:\ \Examples\CSharp.ExecutionDependentGroups.Example.dll
            WEX.Examples.CSharpExecutionDependentGroupsExample
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test1
                        Property[ExecutionGroup] = First Execution Group
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test2
                        Property[ExecutionGroup] = First Execution Group

                WEX.Examples.CSharpExecutionDependentGroupsExample.Test3
                        Property[ExecutionGroup] = Second Execution Group
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test4
                        Property[ExecutionGroup] = Second Execution Group

                WEX.Examples.CSharpExecutionDependentGroupsExample.Test5
                        Property[ExecutionGroup] = Third Execution Group
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test6
                        Property[ExecutionGroup] = Third Execution Group
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test7
                        Property[ExecutionGroup] = Third Execution Group

                WEX.Examples.CSharpExecutionDependentGroupsExample.Test8
                        Property[ExecutionGroup] = Fourth Execution Group
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test9
                        Property[ExecutionGroup] = Fourth Execution Group

Lorsque vous exécutez le test ci-dessus, la sortie suivante confirme l’ordre d’exécution prédit.

te Examples\CSharp.ExecutionDependentGroups.Example.dll
Test Authoring and Execution Framework v2.9.3k for x86

StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test1

Part of First Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test1 [Passed]
StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test2

Part of First Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test2 [Passed]

StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test3

Part of Second Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test3 [Passed]
StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test4

Part of Second Execution Group - last in group fails
Error: Verify: IsTrue [File: Need_Symbols, Function: Test4, Line: 0] 
Error: [HRESULT: 0x80131604]. Operation failed: 'WEX.Examples.CSharpExecutionDependentGroupsExample.Test4'.
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test4 [Failed]

StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test5

Part of Third Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test5 [Passed]
StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test6

Part of Third Execution Group - middle in this set of 3 fails
Error: Verify: IsTrue [File: Need_Symbols, Function: Test6, Line: 0] 
Error: [HRESULT: 0x80131604]. Operation failed: 'WEX.Examples.CSharpExecutionDependentGroupsExample.Test6'.
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test6 [Failed] 
Error: WEX.Examples.CSharpExecutionDependentGroupsExample.Test7 belongs to an execution group and depends
       on the previous test being executed in the same environment successfully.
Error: Please make sure that the dependent test is selected for execution, requests the same execution .
       environment metadata(e.g. 'ThreadingModel') and that it executed successfully.
StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test7
Blocked EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test7 [Blocked]

StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test8

Part of Fourth Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test8 [Passed]
StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test9

Part of Fourth Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test9 [Passed]

Failed Tests:
    WEX.Examples.CSharpExecutionDependentGroupsExample.Test4
    WEX.Examples.CSharpExecutionDependentGroupsExample.Test6

Summary: Total=9, Passed=6, Failed=2, Blocked=1, Not Run=0, Skipped=0

Notez que l’ordre d’exécution du test est comme prévu.

Commentaires

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

Last updated on 2025-07-18

Partager via

Groupes d’exécution

test deScenario-Based avec TAEF

Groupes d’exécution

Commentaires

Ressources supplémentaires