Verificare il framework

Per semplificare la scrittura di test, TAEF fornisce il framework "Verify" che sfrutta WexLogger per segnalare log dettagliati con una quantità minima di codice. Il framework Verify consente ai test di fornire un output del log strutturato, che restituisce un log riuscito se una determinata verifica ha esito positivo e restituisce informazioni dettagliate in caso di esito negativo di una verifica.

Utilizzo di Verify da C++

L'API Verify viene visualizzata in C++ come set di macro definite nel file di intestazione "Verify.h" (Nota: Non è necessario includere in modo esplicito Verify.h, è necessario includere "WexTestClass.h" che contiene tutto ciò che serve per contrassegnare i test C++ e interagire con l'API Verify e WexLogger).

Per i test C++ nativi sono disponibili le macro verify seguenti:

Macro	Funzionalità
VERIFY_ARE_EQUAL(previsto, effettivo, [messaggio facoltativo])	Verifica che due oggetti specificati siano uguali. Registra anche un messaggio personalizzato, se specificato.
VERIFY_ARE_NOT_EQUAL(valore previsto, valore effettivo, [messaggio opzionale])	Verifica che due oggetti specificati non siano uguali. Registra anche un messaggio personalizzato, se specificato.
VERIFY_IS_GREATER_THAN(expectedGreater, expectedLess, [optional message])	Verifica che il primo parametro sia maggiore del secondo parametro. Registra anche un messaggio personalizzato, se specificato.
VERIFY_IS_GREATER_THAN_OR_EQUAL(expectedGreater, expectedLess, [messaggio facoltativo])	Verifica che il primo parametro sia maggiore o uguale al secondo parametro. Registra anche un messaggio personalizzato, se specificato.
VERIFICA_È_MINORE_DI(attesoMinore, attesoMaggiore, [messaggio opzionale])	Verifica che il primo parametro sia minore del secondo parametro. Registra anche un messaggio personalizzato, se specificato.
VERIFY_IS_LESS_THAN_OR_EQUAL(expectedLess, expectedGreater, [messaggio opzionale])	Verifica che il primo parametro sia minore o uguale al secondo parametro. Registra anche un messaggio personalizzato, se specificato.
VERIFY_ARE_SAME(previsto, effettivo, [messaggio facoltativo])	Verifica che i due parametri specificati facciano riferimento allo stesso oggetto. Registra anche un messaggio personalizzato, se specificato.
VERIFY_ARE_NOT_SAME(previsto, effettivo, [messaggio facoltativo])	Verifica che i due parametri specificati non facciano riferimento allo stesso oggetto. Registra anche un messaggio personalizzato, se specificato.
VERIFY_FAIL ([messaggio facoltativo])	Fallisce senza controllare nessuna condizione. Registra anche un messaggio personalizzato, se specificato.
VERIFY_IS_TRUE(condizione, [messaggio facoltativo])	Verifica che il valore bool specificato sia true. Chiama VERIFY_IS_TRUE(!!__condition) o VERIFY_WIN32_BOOL_SUCCEEDED(__condition) per testare un valore BOOL Win32. Registra anche un messaggio personalizzato, se specificato.
VERIFY_IS_FALSE(condizione, [messaggio facoltativo])	Verifica che il valore bool specificato sia false. Chiama VERIFY_IS_FALSE(!!__condition) o VERIFY_WIN32_BOOL_FAILED(__condition) per verificare un BOOL Win32. Registra anche un messaggio personalizzato, se specificato.
VERIFY_IS_NULL(oggetto, [messaggio facoltativo])	Verifica che il parametro specificato sia NULL. Registra anche un messaggio personalizzato, se specificato.
VERIFY_IS_NOT_NULL(oggetto, [messaggio facoltativo])	Verifica che il parametro specificato non sia NULL. Registra anche un messaggio personalizzato, se specificato.
VERIFY_SUCCEEDED(hresult, [messaggio facoltativo])	Verifica che l'oggetto HRESULT specificato sia riuscito. Registra anche un messaggio personalizzato, se specificato.
VERIFY_SUCCEEDED_RETURN(hresult, [messaggio facoltativo])	Verifica che il valore HRESULT specificato sia riuscito e restituisce il valore HRESULT passato nella macro. Registra anche un messaggio personalizzato, se specificato.
VERIFY_FAILED(hresult, [messaggio facoltativo])	Verifica che l'HRESULT specificato non abbia avuto successo. Registra anche un messaggio personalizzato, se specificato.
VERIFY_FAILED_RETURN(hresult, [messaggio facoltativo])	Verifica che l'HRESULT specificato non abbia esito positivo e restituisce l'HRESULT passato nella macro. Registra anche un messaggio personalizzato, se specificato.
VERIFY_THROWS(operazione, eccezione, [messaggio facoltativo])	Verifica che l'operazione specificata generi il tipo di eccezione specificato. Registra anche un messaggio personalizzato, se specificato.
VERIFY_NO_THROW(operazione, [messaggio facoltativo])	Verifica che l'operazione specificata non generi un'eccezione. Registra anche un messaggio personalizzato, se specificato.
VERIFY_WIN32_SUCCEEDED(win32Result, [messaggio facoltativo])	Verifica che il risultato Win32 specificato sia riuscito. Registra anche un messaggio personalizzato, se specificato.
VERIFY_WIN32_SUCCEEDED_RETURN(win32Result, [messaggio facoltativo])	Verifica che il risultato Win32 specificato sia riuscito e restituisca il valore LONG passato nella macro. Registra anche un messaggio personalizzato, se specificato.
VERIFY_WIN32_FAILED(win32Result, [messaggio facoltativo])	Verifica che il risultato Win32 specificato non sia riuscito. Registra anche un messaggio personalizzato, se specificato.
VERIFY_WIN32_FAILED_RETURN(win32Result, [messaggio facoltativo])	Verifica che il risultato Win32 specificato non sia riuscito e restituisca il valore LONG passato nella macro. Registra anche un messaggio personalizzato, se specificato.
VERIFY_WIN32_BOOL_SUCCEEDED(win32Bool, [messaggio facoltativo])	Verifica che l'oggetto BOOL Win32 specificato abbia avuto successo (!= FALSE). Registra il risultato di GetLastError() se la verifica non riesce. Registra anche un messaggio personalizzato, se specificato.
VERIFY_WIN32_BOOL_SUCCEEDED_RETURN(win32Bool, [messaggio facoltativo])	Verifica che il BOOL Win32 specificato abbia avuto successo (!= FALSE) e restituisce il valore BOOL passato nella macro. Registra il risultato di GetLastError() se la verifica non riesce. Registra anche un messaggio personalizzato, se specificato.
VERIFY_WIN32_BOOL_FAILED(win32Bool, [messaggio facoltativo])	Controlla che il BOOL Win32 specificato abbia fallito (== FALSE). Non registra il risultato di GetLastError(). Registra anche un messaggio personalizzato, se specificato.
VERIFY_WIN32_BOOL_FAILED_RETURN(win32Bool, [messaggio facoltativo])	Verifica che il BOOL Win32 specificato non abbia avuto successo (== FALSE) e restituisce il BOOL passato nella macro. Non registra il risultato di GetLastError(). Registra anche un messaggio personalizzato, se specificato.

Verifica dell'utilizzo basata su eccezioni

Se il codice sorgente viene compilato con eccezioni C++ abilitate (specificando l'opzione della riga di comando "/EHsc" o la macro "USE_NATIVE_EH=1" in un file di origini), per impostazione predefinita le macro Verify registrano un errore in caso di errore, seguito dalla generazione di un'eccezione C++ nativa. L'eccezione generata è un'eccezione WEX::TestExecution::VerifyFailureException. Non è necessario intercettare questa eccezione: il framework TAEF la intercetterà al posto tuo e passerà al test case successivo.

Facoltativamente, se si vuole eseguire una serie di verifiche in una riga anziché l'interruzione del test al primo errore di verifica, è possibile usare la classe DisableVerifyExceptions . La durata dell'oggetto controlla la quantità di tempo di disabilitazione delle eccezioni.

if (NULL != m_key)
{
    DisableVerifyExceptions disable;
    VERIFY_WIN32_SUCCEEDED(::RegDeleteKey(HKEY_CURRENT_USER, zTempName));
    VERIFY_WIN32_SUCCEEDED(::RegCloseKey(m_key));
}

Nell'esempio precedente le eccezioni vengono disabilitate solo all'interno del blocco "if (NULL != m_key)" e, se la prima chiamata di verifica ha esito negativo, viene comunque eseguita la seconda chiamata di verifica.

La classe DisableVerifyExceptions è a conteggio di riferimenti e funziona anche su base per thread.

Verifica dell'uso non basato su eccezioni

Se il codice sorgente non viene compilato con eccezioni C++ abilitate, le macro Verify non generano un C++ nativo quando le verifiche hanno esito negativo. Inoltre, se il codice sorgente viene compilato con le eccezioni C++ abilitate, ma si vuole disabilitare Verifica eccezioni, è sufficiente #define NO_VERIFY_EXCEPTIONS prima di includere "WexTestClass.h".

In questo modello è necessario eseguire una serie di istruzioni if annidate per controllare il flusso del test case anziché basarsi sulle eccezioni C++.

if (VERIFY_WIN32_SUCCEEDED(::RegDeleteKey(HKEY_CURRENT_USER, zTempName)))
{
    ...
}

Verificare le impostazioni di output

Se si vuole personalizzare l'output prodotto dalle API Verify, è possibile usare la classe SetVerifyOutput . La durata dell'oggetto determina per quanto tempo le impostazioni di output rimangono attive. La classe SetVerifyOutput è basata sul conteggio dei riferimenti e funziona su base per-thread.

if (NULL != m_key)
{
    SetVerifyOutput verifySettings(VerifyOutputSettings::LogOnlyFailures);
    VERIFY_IS_TRUE(true, L"Should NOT log a comment");
    VERIFY_IS_TRUE(false, L"Should log an error");
}
VERIFY_IS_TRUE(true, L"Should log a comment");

Nell'esempio precedente, le impostazioni specificate riguardano solo le chiamate effettuate all'interno del blocco "if (NULL != m_key)" e solo la chiamata di verifica che non riesce verrà registrata. Tuttavia, la terza chiamata di verifica verrà registrata anche se ha esito positivo. Ciò è dovuto al fatto che la classe SetVerifyOutput è uscita dall'ambito.

Per impostare l'output di verifica sono disponibili le opzioni seguenti:

VerifyOutputSettings::LogOnlyFailures
Verranno registrate solo le chiamate di verifica non riuscite; tutte le chiamate riuscite vengono ignorate.

VerifyOutputSettings::LogFailuresAsBlocked
Registrare tutti gli errori come bloccati anziché registrare un errore.

VerificaImpostazioniOutput::RegistraErroriComeAvvisi
Registrare tutti gli errori come avvisi anziché registrare un errore.

VerifyOutputSettings::LogValuesOnSuccess
Registrare i valori dei parametri passati, anche quando la chiamata Verify ha esito positivo.

Verificare che le impostazioni di output possano essere combinate mediante OR per abilitare più configurazioni.

SetVerifyOutput verifySettings(VerifyOutputSettings::LogOnlyFailures | VerifyOutputSettings::LogFailuresAsBlocked);

Fornire valore di output per i tipi personalizzati

Il framework di verifica C++ offre la possibilità di generare output dettagliato per qualsiasi tipo personalizzato. A tale scopo, è necessario implementare una specializzazione del modello di classe WEX::TestExecution::VerifyOutputTraits .

La specializzazione del modello di classe WEX::TestExecution::VerifyOutputTraits deve essere presente nello spazio dei nomi WEX::TestExecution. Si prevede inoltre di fornire un metodo statico pubblico denominato ToString, che accetta un riferimento alla classe e restituisce un WEX::Common::NoThrowString contenente una rappresentazione di stringa del relativo valore.

    class MyClass
    {
    public:
        MyClass(int value)
            : m_myValue(value)
        {
        }

        int GetValue()
        {
            return m_myValue;
        }

    private:
        int m_myValue;
    }

    namespace WEX { namespace TestExecution
    {
        template <>
        class VerifyOutputTraits<MyClass>
        {
        public:
            static WEX::Common::NoThrowString ToString(const MyClass& myClass)
            {
                return WEX::Common::NoThrowString().Format(L"%d", myClass.GetValue());
            }
        };
    }}

Fornitura di comparatori per tipi personalizzati

Il framework di verifica C++ offre la possibilità di definire i comparatori per i tipi personalizzati che non implementano il sovraccarico degli operatori corrispondenti (operator=, operator<, ecc.). A tale scopo, è necessario implementare una specializzazione del modello di classe WEX::TestExecution::VerifyCompareTraits .

La specializzazione del modello di classe WEX::TestExecution::VerifyCompareTraits deve esistere nello spazio dei nomi WEX::TestExecution . Si prevede inoltre di fornire metodi statici pubblici denominati AreEqual, AreSame, IsLessThan, IsGreaterThan e IsNull.

    class MyClass
    {
    public:
        MyClass(int value)
            : m_myValue(value)
        {
        }

        int GetValue()
        {
            return m_myValue;
        }

    private:
        int m_myValue;
    }

    namespace WEX { namespace TestExecution
    {
        template <>
        class VerifyCompareTraits<MyClass, MyClass>
        {
        public:
            static bool AreEqual(const MyClass& expected, const MyClass& actual)
            {
                return expected.GetValue() == actual.GetValue();
            }

            static bool AreSame(const MyClass& expected, const MyClass& actual)
            {
                return &expected == &actual;
            }

            static bool IsLessThan(const MyClass& expectedLess, const MyClass& expectedGreater)
            {
                return (expectedLess.GetValue() < expectedGreater.GetValue());
            }

            static bool IsGreaterThan(const MyClass& expectedGreater, const MyClass& expectedLess)
            {
                return (expectedGreater.GetValue() > expectedLess.GetValue());
            }

            static bool IsNull(const MyClass& object)
            {
                return object.GetValue() == 0;
            }
        };
    }}

Uso di Verify from C#

L'utilizzo di C# Verify è simile a quello di C++. Tuttavia, viene fornito tramite la classe WEX.TestExecution.Verify, che si trova all'interno Te.Managed.dll.

Per i test C# sono disponibili i metodi Verify seguenti:

Macro	Funzionalità
SonoUguali(oggetto previsto, oggetto effettivo)	Verifica che due oggetti specificati siano uguali.
AreEqual(oggetto atteso, oggetto reale, stringa messaggio)	Verifica che due oggetti specificati siano uguali; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
AreEqual<T>(T expected, T actual)	Verifica che due oggetti specificati siano uguali.
AreEqual<T>(T expected, T actual, string message)	Verifica che due oggetti specificati siano uguali; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
AreNotEqual(oggetto previsto, oggetto effettivo)	Verifica che due oggetti specificati non siano uguali.
AreNotEqual(oggetto previsto, oggetto effettivo, stringa messaggio)	Verifica che due oggetti specificati non siano uguali; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
NonSonoUguali<T>(T atteso, T reale)	Verifica che due oggetti specificati non siano uguali.
AreNotEqual<T>(T expected, T actual, messaggio stringa)	Verifica che due oggetti specificati non siano uguali; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
SonoUguali(object expected, object actual)	Verifica che i due parametri specificati facciano riferimento allo stesso oggetto.
SonoUguali(object expected, object actual, string message)	Verifica che i due parametri specificati facciano riferimento allo stesso oggetto; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
AreNotSame(object expected, object actual)	Verifica che i due parametri specificati non facciano riferimento allo stesso oggetto.
No changes are necessary; the translation should remain as "AreNotSame(object expected, object actual, string message)" for code consistency.	Verifica che i due parametri specificati non facciano riferimento allo stesso oggetto; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
IsGreaterThan(IComparable maggioreAtteso, IComparable minoreAtteso)	Verifica che il primo parametro sia maggiore del secondo parametro.
IsGreaterThan(IComparable expectedGreater, IComparable expectedLess, string message)	Verifica che il primo parametro sia maggiore del secondo parametro; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
IsGreaterThanOrEqual(IComparable expectedGreater, IComparable expectedLess)	Verifica che il primo parametro sia maggiore o uguale al secondo parametro.
IsGreaterThanOrEqual(IComparable expectedGreater, IComparable expectedLess, string message)	Verifica che il primo parametro sia maggiore o uguale al secondo parametro; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
IsLessThan(IComparable expectedLessLess, IComparable expectedGreater)	Verifica che il primo parametro sia minore del secondo parametro.
IsLessThan(IComparable expectedLess, IComparable expectedGreater, string message)	Verifica che il primo parametro sia minore del secondo parametro; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
IsLessThanOrEqual(IComparable previstoMinore, IComparable previstoMaggiore)	Verifica che il primo parametro sia minore o uguale al secondo parametro.
IsLessThanOrEqual(IComparable expectedLess, IComparable expectedGreater, string message)	Verifica che il primo parametro sia minore o uguale al secondo parametro; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
Errore(messaggio stringa)	Fallisce senza verificare nessuna condizione.
IsTrue(bool condition)	Verifica che la condizione specificata sia vera.
IsTrue(bool condition, string message)	Verifica che la condizione specificata sia true; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
IsFalse(condizione booleana)	Verifica che la condizione specificata sia falsa.
IsFalse(bool condition, string message)	Verifica che la condizione specificata sia false; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
IsNull(object obj)	Verifica che il parametro specificato sia NULL.
IsNull(object obj, string message)	Verifica che il parametro specificato sia NULL; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
IsNotNull(object obj)	Verifica che il parametro specificato non sia NULL.
IsNotNull(oggetto obj, stringa messaggio)	Verifica che il parametro specificato non sia NULL; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.
<Genera T>(operazione VerifyOperation)	Verifica che l'operazione specificata generi il tipo di eccezione specificato. Restituisce anche l'eccezione per un'ulteriore ispezione.
<Genera T>(operazione VerifyOperation, messaggio stringa)	Verifica che l'operazione specificata generi il tipo di eccezione specificato; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica. Restituisce anche l'eccezione per un'ulteriore ispezione.
NoThrow(Operazione VerifyOperation)	Verifica che l'operazione specificata non generi un'eccezione.
NoThrow(VerifyOperation operation, string message)	Verifica che l'operazione specificata non generi un'eccezione; registra un messaggio personalizzato in caso di esito positivo o negativo della verifica.

Verifica dell'utilizzo basata sulle eccezioni

Quando si verificano errori di verifica nei casi di test C#, viene scritto un errore nel logger e viene generata un'eccezione WEX.TestExecution.VerifyFailureException. Proprio come nel modello C++ nativo, non è necessario preoccuparsi di intercettare queste eccezioni. Il framework TAEF lo intercetta e passa al test case successivo.

Facoltativamente, se si vuole eseguire una serie di verifiche in una riga anziché l'interruzione del test al primo errore di verifica, è possibile usare la classe DisableVerifyExceptions . La durata dell'oggetto controlla la quantità di tempo di disabilitazione delle eccezioni. La classe DisableVerifyExceptions viene conteggiata tramite riferimento, e funziona su base per-thread.

using (new DisableVerifyExceptions())
{
    Verify.AreSame(item1, item2);
    Verify.AreEqual(item1, item2);
}

Nell'esempio precedente, se la prima chiamata di verifica ha esito negativo, viene comunque eseguita la seconda chiamata di verifica.

In alternativa, è possibile ottenere lo stesso risultato impostando Verify.DisableVerifyExceptions = true prima delle operazioni Verify, ad esempio l'esempio illustrato di seguito.

Verify.DisableVerifyExceptions = true;
try
{
    Verify.AreSame(item1, item2);
    Verify.AreEqual(item1, item2);
}
finally
{
    Verify.DisableVerifyExceptions = false;
}

Si noti che, anche se tale opzione è disponibile, dichiarare DisableVerifyExeptions come oggetto in un blocco using è comunque l'opzione consigliata.

Se vuoi interrompere nel debugger quando si verifica un errore di verifica, apri la finestra di dialogo delle eccezioni (Ctrl+Alt+E), fai clic su Aggiungi, scegli "Common Language Runtime Exceptions" nell'elenco a discesa e inserisci "WEX.TestExecution.VerifyFailureException" nel campo Nome.

Verificare le impostazioni di output

Se si vuole personalizzare l'output prodotto dalle API Verify, è possibile usare la classe SetVerifyOutput . La durata dell'oggetto determina per quanto tempo le impostazioni di output sono mantenute. La classe SetVerifyOutput viene conteggiata in base al conteggio dei riferimenti e le funzioni per ogni thread.

using (new SetVerifyOutput(VerifyOutputSettings.LogOnlyFailures))
{
    Log.Comment("Only the following error should be logged:");
    Verify.IsTrue(true, "Should NOT log a comment");
    Verify.IsTrue(false, "Should log an error");
}
Verify.IsTrue(true, "Should log a comment");

Nell'esempio precedente, è necessario registrare solo la seconda chiamata di verifica perché è l'unica chiamata che ha esito negativo all'interno del blocco using. Tuttavia, la terza chiamata di verifica verrà registrata anche se ha esito positivo. Ciò è dovuto al fatto che la classe SetVerifyOutput è uscita dall'ambito.

In alternativa, è possibile ottenere lo stesso risultato impostando Verify.OutputSettings = VerifyOutputSettings.LogOnlyFailures prima delle operazioni Verify, ad esempio l'esempio illustrato di seguito.

Verify.OutputSettings = VerifyOutputSettings.LogFailuresAsWarnings
try
{
    Verify.AreSame(item1, item2);
    Verify.AreEqual(item1, item2);
}
finally
{
    Verify.OutputSettings = VerifyOutputSettings.None;
}

Si noti che, anche se tale opzione è disponibile, dichiarare SetVerifyOutput come oggetto in un blocco using è ancora l'opzione consigliata.

Per impostare l'output di verifica sono disponibili le opzioni seguenti:

ImpostazioniVerificaUscita.SoloLogErrori
Verranno registrate solo le chiamate di verifica non riuscite; tutte le chiamate riuscite vengono ignorate.

ImpostaDiVerifica.LogfallimentiComeBloccati
Registrare tutti gli errori come bloccati anziché registrare un errore.

VerifyOutputSettings.LogFailuresAsWarnings
Registrare tutti gli errori come avvisi anziché registrare un errore.

Verifica che le impostazioni di output possano essere combinate per abilitare più impostazioni:

using (new SetVerifyOutput(VerifyOutputSettings.LogFailuresAsBlocked | VerifyOutputSettings.LogOnlyFailures))
{
...
}

Uso di Verify From Script

Viene anche visualizzata l'API Verify per i linguaggi di script, seguendo gli stessi modelli di utilizzo di C++ e C#.

Installazione

Quando si usa l'API di verifica scriptabile dall'interno di un metodo di test TAEF non è necessaria alcuna installazione: l'API richiesta viene registrata usando "Registration Free COM". Per usare l'API scriptabile dall'esterno di un metodo di test TAEF (all'esterno di TAEF o in un processo figlio) è sufficiente registrare il file binario Te.Common.dll usando regsvr32 da un prompt dei comandi con privilegi elevati; Per esempio:

regsvr32 Te.Common.dll

Quando si distribuisce TAEF usando un file di distribuzione per l'esecuzione del lab, Te.Common.dll viene registrato automaticamente.

Uso

L'API Verify configurabile tramite script viene visualizzata tramite l'te. Classe COM Common.Verify' : è sufficiente creare un'istanza di tale classe e chiamare metodi su di essa, la classe Verify funzionerà automaticamente con WEXLogger per scrivere verifiche passate e non superate nel log.

1   <?xml version="1.0" ?>
2   <?component error="false" debug="false"?>
3   <package>
4     <component id="Example">
5       <object id="Log" progid="Wex.Logger.Log" />
6       <object id="Verify" progid="Te.Common.Verify" />
7       <reference guid="e65ef678-a232-42a7-8a36-63108d719f31" version="1.0"/>
8       <reference guid="f8bb9db9-e54e-4555-b3e5-e3ddf2fef401" version="1.0"/>
9
10      <public>
11        <method name="HelloWorld"/>
12      </public>
13
14      <script language="JScript">
15          function HelloWorld() {
16              Verify.IsTrue(true);
17              Verify.IsFalse(false);
18          }
19      </script>
20    </component>
21  </package>

Questo esempio definisce una classe di test di script TAEF con un singolo metodo 'HelloWorld'. La riga 6 usa l'elemento 'object' per definire la variabile Verify nell'ambito globale. La riga 8 usa l'elemento 'reference' per includere tutte le costanti della libreria dei tipi specificata (in questo caso, Te.Common.dlllibreria dei tipi) nell'ambito globale dello script; in questo caso aggiunge le costanti 'VerifySettings'. Le righe 16 e 17 mostrano semplicemente l'utilizzo dell'API Verify. Quando viene eseguito, l'esempio genererà l'output seguente:

Test Authoring and Execution Framework v2.7 Build 6.2.7922.0 (fbl_esc_end_dev(mschofie).110202-1000) For x86

StartGroup: Example::HelloWorld
Verify: IsTrue
Verify: IsFalse
EndGroup: Example::HelloWorld [Passed]

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

API Verifica scriptabile

I metodi per la convalida nell'API Verify scriptable sono i seguenti:

Metodo	Funzionalità
bool Verify.AreEqual(expected, actual, [optional message])	Verifica che i due valori siano uguali. Se l'impostazione "VerifySettings_CoerceTypes" è abilitata, questo metodo usa la definizione JScript di uguaglianza, se l'impostazione "VerifySettings_CoerceTypes" non è abilitata, il metodo usa la definizione JScript dell'identità. 'VerifySettings_CoerceTypes' è attivato per impostazione predefinita.
bool Verify.AreNotEqual(expected, actual, [messaggio opzionale])	Verifica che i due valori non siano uguali. Se l'impostazione "VerifySettings_CoerceTypes" è abilitata, questo metodo usa la definizione JScript di uguaglianza, se l'impostazione "VerifySettings_CoerceTypes" non è abilitata, il metodo usa la definizione JScript dell'identità. 'VerifySettings_CoerceTypes' è attivato per impostazione predefinita.
bool Verify.IsGreaterThan(expectedGreater, expectedLess, [messaggio opzionale])	Verifica che il primo valore sia maggiore del secondo.
bool Verify.IsGreaterThanOrEqual(expectedGreater, expectedLess, [messaggio facoltativo])	Verifica che il primo valore sia maggiore o uguale al secondo.
bool Verify.IsLessThan(expectedLess, expectedGreater, [messaggio opzionale])	Verifica che il primo valore sia minore del secondo.
bool Verify.IsLessThanOrEqual(expectedLess, expectedGreater, [optional message])	Verifica che il primo valore sia minore o uguale al secondo.
bool Verify.AreSame(expected, actual, [optional message])	Verifica che i valori siano uguali.
bool Verifica.NonSonoUguali(expected, actual, [messaggio opzionale])	Verifica che i valori non siano uguali.
bool Verify.Fail([optional message])	Non riesce senza controllare le condizioni.
bool Verify.IsTrue(expression, [optional message])	Verifica che l'espressione specificata restituisca true.
bool Verify.IsFalse(expression, [optional message])	Verifica che l'espressione specificata restituisca false.
bool Verify.IsNull(expected, [optional message])	Verifica che il valore specificato sia 'null'.
bool Verify.IsNotNull(expected, [messaggio opzionale])	Verifica che il valore specificato non sia 'null'.
bool Verify.Throws(function, [optional message])	Verifica che la funzione specificata generi un'eccezione.
bool Verify.NoThrow(function, [optional message])	Verifica che la funzione specificata non generi un'eccezione.

Esistono due metodi nella classe Verify per controllare le impostazioni:

Metodo	Funzionalità
object Verify.EnableSettings(settings)	Verrà abilitato il flag o i flag di impostazione specificati.
oggetto Verify.DisableSettings(impostazioni)	Gli indicatori di impostazione specificati verranno disabilitati.

Il valore delle impostazioni passato ai metodi Verify.EnableSettings o Verify.DisableSettings può essere uno dei valori seguenti:

VerifySettings_LogOnlyFailures = 0x01
Vengono registrati solo gli errori: non è presente alcun output per le chiamate di verifica riuscite.

VerifySettings_LogFailuresAsBlocked = 0x02
Gli errori vengono registrati come "Bloccati", anziché come "Errore" predefinito.

VerifySettings_LogFailuresAsWarnings = 0x04
Gli errori vengono registrati come "Avviso", anziché come "Errore" predefinito.

VerifySettings_LogValuesOnSuccess = 0x08
I valori dei parametri da verificare vengono scritti come parte del messaggio Verifica log. Questa opzione è attivata per impostazione predefinita.

VerifySettings_CoerceTypes = 0x1000
I valori passati ai metodi Verify verranno forzati seguendo le regole di coercizione JScript. Questa opzione è attivata per impostazione predefinita.

VerifySettings_DisableExceptions = 0x2000
Le eccezioni non verranno generate quando una validazione non riesce.

Verificare le impostazioni

L'API Verify fornisce le impostazioni per configurarlo. I metodi 'EnableSettings' e 'DisableSettings' possono essere usati per abilitare o disabilitare impostazioni specifiche che la classe Verify gestisce. I metodi accettano una o più impostazioni per abilitare o disabilitare.

    Verify.EnableSettings(VerifySettings_LogOnlyFailures);

Per abilitare o disabilitare più impostazioni in una chiamata, è possibile includere più flag "VerifySettings":

    Verify.EnableSettings(VerifySettings_LogOnlyFailures | VerifySettings_DisableExceptions);

I metodi EnableSettings e DisableSettings restituiscono un oggetto che può essere utilizzato per ripristinare le impostazioni originali, consentendo l'abilitazione o la disabilitazione delle impostazioni per un determinato ambito;

1    var guard = Verify.EnableSettings(VerifySettings_LogOnlyFailures);
2    try
3    {
4        Verify.AreEqual(10, 0xa);
5    }
6    finally
7    {
8        guard.Restore();
9    }

In questo esempio, viene passato come parametro al metodo Verify.EnableSettings il valore 'VerifySettings_LogOnlyFailures', che verrà incorporato nelle impostazioni già presenti nell'oggetto Verify. Viene eseguita una chiamata Verify all'interno di un blocco try-finally, in modo che durante il blocco finally, l'oggetto 'guard' possa essere usato per ripristinare le impostazioni originali.

Uso della verifica basata su eccezioni

Per impostazione predefinita, i metodi Verify genereranno un'eccezione quando una verifica non riesce. Quando un test viene eseguito sotto il framework TAEF, se viene generata un'eccezione al di fuori del metodo di test, il test non verrà superato. Per esempio:

1    var guard = Verify.EnableSettings(VerifySettings_CoerceTypes);
2    try
3    {
4        Verify.AreEqual(1, "1");
5        Verify.AreEqual("1", 1);
6    }
7    finally
8    {
9        guard.Restore();
10   }

In questo esempio la seconda chiamata Verify non verrà mai eseguita, poiché la prima genererà un'eccezione e non riuscirà il test. Il supporto delle impostazioni nell'API Verify può essere usato per modificare questo comportamento, in modo che le verifiche non riuscite non vengano generate, consentendo di effettuare chiamate di verifica successive. Ciò è particolarmente utile per verificare un set di parametri e assicurarsi che tutte le verifiche siano scritte.

1    var guard = Verify.EnableSettings(VerifySettings_CoerceTypes | VerifySettings_DisableExceptions);
2    try
3    {
4        Verify.AreEqual(1, "1");
5        Verify.AreEqual("1", 1);
6    }
7    finally
8    {
9        guard.Restore();
10   }

Poiché le eccezioni sono state disabilitate, entrambe le verifiche verranno scritte nel log.

Uso dell'API Verifica scriptabile all'esterno del TAEF

L'API Verify configurabile tramite script può essere usata all'esterno del TAEF. Assicurarsi che il Te.Common.dll sia registrato, come indicato nella sezione Installazione, e creare la classe "TE.Common.Verify".

var VerifySettings_DisableExceptions = 0x2000;

var Verify = new ActiveXObject("TE.Common.Verify");
var Log = new ActiveXObject("WEX.Logger.Log");

Verify.EnableSettings(VerifySettings_DisableExceptions);

Log.StartGroup("Group A");
Verify.AreEqual(1, 2);
Log.EndGroup("Group A");

Log.StartGroup("Group B");
Verify.AreEqual(2, 2);
Log.EndGroup("Group B");

Il codice precedente genererà l'output della console seguente quando viene eseguito tramite cscript:

StartGroup: Group A
Error: Verify: AreEqual - Values (1, 2)
EndGroup: Group A [Failed]

StartGroup: Group B
Verify: AreEqual - Values (2, 2)
EndGroup: Group B [Passed]

Non-passing Tests:

    Group A [Failed]

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

Il 'WEX.Logger.Log' API può essere utilizzato per configurare il logger WEX secondo le necessità (ad esempio, come processo figlio), e l'API scriptable Verify sfrutterà tale configurazione.