Macros

Présentation

Certaines macros sont disponibles dans les méthodes des objets ETEST. Vous pouvez utiliser ces macros pour contrôler l'exécution des tests et déterminer le résultat d'un scénario de test.

Les macros sont appelées de la même manière que les méthodes. Contrairement à un appel de fonction, un appel de macro peut écrire des variables de la méthode d'appel et déclencher un retour de la méthode d'appel.

Les macros sont autorisées dans les méthodes suivantes de scénarios et de ressources de test :

Prepare
Execute
CleanUp

Vous pouvez également utiliser les macros dans des méthodes appelées avec ASSERT_SUBMETHOD.

NOTE : l'utilisation de macros dans d'autres méthodes de scénarios et ressources de test peut générer des erreurs. En particulier, n'utilisez pas de macros dans la méthode Finalize.

Dans d'autres objets, les macros sont sans effet. Ceci est indiqué par un message qui s'affiche dans la vue Messages.

Macros dans des méthodes de scénarios et de ressources de test

Dans les méthodes de scénarios et de ressources de test, les macros suivantes sont possibles :

Appel de macro	Description
`ASSERT(condition)`	FALSE : l'exécution échoue. TRUE : l'exécution aboutit.
`ASSERT(condition, message)`	FALSE : l'exécution échoue. TRUE : l'exécution aboutit. `message` est le message de diagnostic qui s'affiche comme résultat.
`ASSERT_INCONCLUSIVE(condition, message)`	FALSE : le résultat du test n'est pas concluant. Le résultat ne permet pas de savoir si un test n'a pas pu être effectué. La cause peut être, par exemple, qu'un équipement matériel obligatoire n'est pas disponible sur le système de test. TRUE : le test s'exécute correctement.
`ASSERT_SUBMETHOD(method_call(i_xFirstCall, i_ifErrorLogger))`	`Method_call` permet d'appeler les méthodes qui, à leur tour, peuvent utiliser les macros pour influencer le flux de contrôle de la méthode d'appel. FALSE : une erreur a été détectée pendant l'appel de la méthode. Dans une méthode appelée par `ASSERT_SUBMETHOD` et qui a été évaluée comme FALSE, `ASSERT` a le même effet que `ASSERT` qui a été évaluée comme FALSE directement dans la méthode d'appel. En revanche, dans une méthode appelée sans `ASSERT_SUBMETHOD`, `ASSERT` est sans effet sur la méthode d'appel. Lorsque vous utilisez `ASSERT_SUBMETHOD`, veillez à respecter la syntaxe concernant la déclaration des paramètres et le type de retour (consultez également l'exemple 2) : Déclarez `i_ifErrorLogger` dans la sous-méthode similaire à la méthode `Execute`. Déclarez et utilisez le type de retour `ET_TestReturn` dans la sous-méthode similaire à la méthode `Execute`. `i_ifErrorLogger` doit également être transféré à la sous-méthode.
`TEST_DONE()`	L'exécution du test aboutit (sans aucune erreur détectée). Une méthode `RETURN` arrête simplement le cycle en cours. La méthode sera ensuite rappelée dans le cycle suivant.

Macros arrêtant l'exécution de méthodes

Les méthodes Prepare, Execute et CleanUp d'un scénario ou d'une ressource de test sont appelées de manière cyclique tant qu'un ASSERT est évalué comme FALSE ou qu'un TEST_DONE est appelé. Si un TEST_DONE est appelé ou si un ASSERT est évalué comme FALSE, l'exécution de la méthode est interrompue, annulant le reste de l'exécution de la méthode.

Si...	Alors…
l'exécution d'un test se termine avec `TEST_DONE`	le test a abouti.
une assertion de la méthode `Execute` ou `Prepare` est évaluée comme FALSE.	l'exécution du scénario de test a échoué.

NOTE : si une assertion de la méthode CleanUp est évaluée comme FALSE, l'exécution du test est interrompue. Ce cas de figure est catégorisé comme une erreur pendant l'initialisation ou la désinitialisation. Un message s'affiche dans Logic Builder. Il indique que le test a été annulé et qu'une réinitialisation du contrôleur est requise.

Exemple 1

Dans l'exemple de code de programme ci-dessous, les macros ASSERT et TEST_DONE sont utilisées dans la partie mise en œuvre de la méthode Execute.

diResult := MyAdditionFunction(4, 3);
ASSERT(diResult = 7,  'MyAdditionFunction addition result not correct');
TEST_DONE();

Exemple 2

Dans l'exemple de code de programme suivant, les macros ASSERT et TEST_DONE sont utilisées pour tester la fonction my_add (une simple addition).

Dans ce scénario de test, une méthode TestMyAdd a été créée. La méthode Execute du scénario de test l'appelle plusieurs fois pour tester la fonction my_add dans différentes conditions limites et avec différents paramètres.

(* Methode Execute *)
(* Declaration part*)
METHOD Execute : PD_ETest.ET_TestReturn
VAR_INPUT
   i_xFirstCall : Bool;
   i_ifErrorLogger : PD_ETest.IF_ErrorLogger;
END_VAR
VAR_OUTPUT
   q_rProgress : REAL;
   q_sState . STRING[255];
END_VAR
VAR
END_VAR
(* Implementation part*)
ASSERT_SUBMETHOD (TestMyAdd(12, 2, 14, i_ifErrorLogger));
ASSERT_SUBMETHOD (TestMyAdd(12, 3, 15, i_ifErrorLogger));
ASSERT_SUBMETHOD (TestMyAdd(12, 4, 16, i_ifErrorLogger));
TEST_DONE();
 
(* Submethod TestMyAdd *)
(* Declaration part *)
METHOD TestMyAdd : PD_ETest.ET_TestReturn
VAR_INPUT
   i_a : INT;
   i_b : INT;
   i_result : INT;
   i_ifErrorLogger : PD_ETest.IF_ErrorLogger;
END_VAR
VAR
   iResult : INT;
END_VAR
(* Implementation part *)
iResult : my_add(i_a, i_b);
ASSERT(iresult = i_result);
 
(* Function my_add *)
(* Declaration part *)
FUNCTION my_add : INT
VAR_INPUT
   a : INT;
   b : INT;
END_VAR
VAR
END_VAR
(* Implementation part *)
iResult : my_add := a + b;