Macro

Panoramica

Nei metodi degli oggetti ETEST sono disponibili macro specifiche, che possono essere usate per controllare l'esecuzione del test e determinare il risultato di un caso di test.

Le macro vengono richiamate come i metodi. A differenza di una chiamata di funzione, una chiamata di macro può scrivere variabili del metodo chiamante e far restituire un risultato al metodo chiamante.

È consentito l'uso delle macro nei seguenti metodi di casi di test e risorse:

Prepare
Execute
CleanUp

È inoltre possibile usare le macro nei metodi chiamati con ASSERT_SUBMETHOD.

NOTA: Se le macro vengono utilizzate in altri metodi di casi di test e risorse, si possono verificare errori. In particolare, non usare le macro nel metodo Finalize.

Le macro in oggetti di altro tipo non hanno alcun effetto, come viene indicato da un messaggio riportato nella vistaMessaggi.

Macro nei metodi di casi di test e risorse

Nei metodi di casi di test e risorse, sono possibili le seguenti macro:

Chiamata di macro	Descrizione
`ASSERT(condition)`	FALSE: l'esecuzione non è stata completata correttamente. TRUE: l'esecuzione è stata completata correttamente.
`ASSERT(condition, message)`	FALSE: l'esecuzione non è stata completata correttamente. TRUE: l'esecuzione è stata completata correttamente. `message` è il messaggio di diagnostica che viene visualizzato come risultato.
`ASSERT_INCONCLUSIVE(condition, message)`	FALSE: il risultato del test è inconcludente. Il risultato del test è inconcludente per indicare che un test non ha potuto essere eseguito. Il motivo potrebbe essere, ad esempio, un dispositivo hardware non disponibile sul sistema di test. TRUE: il test è stato completato correttamente.
`ASSERT_SUBMETHOD(method_call(i_xFirstCall, i_ifErrorLogger))`	Con `Method_call` è possibile richiamare metodi che a loro volta possono richiamare macro, per influenzare il flusso di controllo del metodo chiamante. FALSE: è stato rilevato un errore durante la chiamata del metodo. Un `ASSERT` in un metodo richiamato da `ASSERT_SUBMETHOD` che restituisce FALSE ha lo stesso effetto di un `ASSERT` che restituisce FALSE direttamente nel metodo chiamante. Al contrario, un `ASSERT` in un metodo richiamato senza usare `ASSERT_SUBMETHOD` non ha effetto sul metodo chiamante. Quando si usa il `ASSERT_SUBMETHOD`, fare attenzione a usare la sintassi esatta per la dichiarazione del parametro e il tipo restituito (consultare anche , esempio 2): Dichiarare `i_ifErrorLogger` nel metodo secondario del metodo `Execute`. Dichiarare e usare il tipo restituito `ET_TestReturn` nel metodo secondario del metodo `Execute`. Anche `i_ifErrorLogger` deve essere trasferito al metodo secondario.
`TEST_DONE()`	Il test è stato completato correttamente (senza errori). Un semplice `RETURN` termina il ciclo corrente. Il metodo può quindi essere chiamato di nuovo nel ciclo successivo.

Macro che arrestano l'esecuzione di metodi

I metodi Prepare, Execute e CleanUp di un caso di test o una risorsa vengono richiamati ciclicamente fino a quando un ASSERT restituisce FALSE o fino a quando viene richiamato TEST_DONE. Se viene richiamato TEST_DONE o se un ASSERT restituisce FALSE, l'esecuzione del metodo viene interrotta, annullando la parte restante.

Se...	In questo caso...
l'esecuzione di un test viene terminata con `TEST_DONE`	il test è stato completato senza errori.
un'asserzione nel metodo `Execute` o `Prepare` restituisce FALSE	il caso di test non è stato completato correttamente.

NOTA: Se un'asserzione nel metodo CleanUp restituisce FALSE, l'esecuzione del test viene interrotta. Questa situazione viene categorizzata come errore durante l'inizializzazione o la deinizializzazione. Viene visualizzato un messaggio in Logic Builder che indica che il test è stato annullato ed è necessario un reset del controller.

Esempio 1

Nel seguente esempio di codice di programma, le macro ASSERT e TEST_DONE vengono utilizzate nella parte di implementazione del metodo Execute.

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

Esempio 2

Nel seguente esempio di codice di programma, le macro ASSERT e TEST_DONE vengono utilizzate per testare la funzione my_add (una aggiunta semplice).

Nel caso di test è stato creato un metodo TestMyAdd che viene richiamato più volte dal metodo Execute del caso di test per testare la funzione my_add in condizioni diverse e con parametri diversi.

(* 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;