Vérifier l’infrastructure
Pour faciliter l’écriture de tests, TAEF fournit l’infrastructure « Verify » qui tire parti de WexLogger pour signaler des journaux détaillés avec une quantité minimale de code. L’infrastructure De vérification permet aux tests de fournir une sortie de journal structurée : elle génère un journal réussi si une vérification donnée réussit, et génère des informations détaillées en cas d’échec d’une vérification.
Utilisation de La vérification à partir de C++
L’API Verify est exposée en C++ sous la forme d’un ensemble de macros définies dans le fichier d’en-tête « Verify.h » (Remarque : vous n’avez pas besoin d’inclure explicitement Verify.h, vous devez inclure « WexTestClass.h » qui contient tout ce dont vous avez besoin pour marquer les tests C++ et interagir avec les API Verify et WexLogger).
Les macros de vérification suivantes sont disponibles pour les tests C++ natifs :
| Macro | Fonctionnalités |
|---|---|
| VERIFY_ARE_EQUAL(attendu, réel, [message facultatif]) | Vérifie que deux objets spécifiés sont égaux. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_ARE_NOT_EQUAL(attendu, réel, [message facultatif]) | Vérifie que deux objets spécifiés ne sont pas égaux. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_IS_GREATER_THAN(expectedGreater, expectedLess, [facultatif message]) | Vérifie que le premier paramètre est supérieur au deuxième paramètre. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_IS_GREATER_THAN_OR_EQUAL(expectedGreater, expectedLess, [facultatif message]) | Vérifie que le premier paramètre est supérieur ou égal au deuxième paramètre. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_IS_LESS_THAN(expectedLess, expectedGreater, [optional message]) | Vérifie que le premier paramètre est inférieur au deuxième paramètre. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_IS_LESS_THAN_OR_EQUAL(expectedLess, expectedGreater, [optional message]) | Vérifie que le premier paramètre est inférieur ou égal au deuxième paramètre. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_ARE_SAME(attendu, réel, [message facultatif]) | Vérifie que les deux paramètres spécifiés font référence au même objet. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_ARE_NOT_SAME(attendu, réel, [message facultatif]) | Vérifie que les deux paramètres spécifiés ne font pas référence au même objet. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_FAIL ([message facultatif]) | Échoue sans vérifier les conditions. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_IS_TRUE(condition, [message facultatif]) | Vérifie que la valeur bool spécifiée est true. Appelez VERIFY_IS_TRUE(!! __condition) ou VERIFY_WIN32_BOOL_SUCCEEDED(__condition) pour tester une boOL Win32. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_IS_FALSE(condition, [message facultatif]) | Vérifie que le bool spécifié a la valeur false. Appelez VERIFY_IS_FALSE(!! __condition) ou VERIFY_WIN32_BOOL_FAILED(__condition) pour tester une boOL Win32. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_IS_NULL(object, [optional message]) | Vérifie que le paramètre spécifié est NULL. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_IS_NOT_NULL(object, [facultatif message]) | Vérifie que le paramètre spécifié n’est pas NULL. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_SUCCEEDED(hresult, [message facultatif]) | Vérifie que le HRESULT spécifié réussit. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_SUCCEEDED_RETURN(hresult, [message facultatif]) | Vérifie que le HRESULT spécifié réussit et retourne le HRESULT qui a été passé dans la macro. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_FAILED(hresult, [facultatif message]) | Vérifie que le HRESULT spécifié n’a pas réussi. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_FAILED_RETURN(hresult, [message facultatif]) | Vérifie que le HRESULT spécifié n’a pas réussi et retourne le HRESULT qui a été passé dans la macro. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_THROWS(operation, exception, [facultatif message]) | Vérifie que l’opération spécifiée lève le type d’exception donné. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_NO_THROW(operation, [optional message]) | Vérifie que l’opération spécifiée ne lève pas d’exception. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_WIN32_SUCCEEDED(win32Result, [message facultatif]) | Vérifie que le résultat Win32 spécifié a réussi. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_WIN32_SUCCEEDED_RETURN(win32Result, [message facultatif]) | Vérifie que le résultat Win32 spécifié a réussi et retourne la valeur LONG qui a été passée dans la macro. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_WIN32_FAILED(win32Result, [facultatif message]) | Vérifie que le résultat Win32 spécifié a échoué. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_WIN32_FAILED_RETURN(win32Result, [message facultatif]) | Vérifie que le résultat Win32 spécifié a échoué et retourne le LONG qui a été passé dans la macro. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_WIN32_BOOL_SUCCEEDED(win32Bool, [facultatif message]) | Vérifie que le boOL Win32 spécifié a réussi (!= FALSE). Journalisera le résultat de GetLastError() si la vérification échoue. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_WIN32_BOOL_SUCCEEDED_RETURN(win32Bool, [message facultatif]) | Vérifie que la valeur d’ordre d’erreur Win32 spécifiée a réussi (!= FALSE) et retourne la valeur BOOL qui a été passée dans la macro. Journalisera le résultat de GetLastError() si la vérification échoue. Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_WIN32_BOOL_FAILED(win32Bool, [message facultatif]) | Vérifie que la boOL Win32 spécifiée a échoué (== FALSE). N’enregistre pas le résultat de GetLastError(). Enregistre également un message personnalisé s’il est fourni. |
| VERIFY_WIN32_BOOL_FAILED_RETURN(win32Bool, [message facultatif]) | Vérifie que la boOL Win32 spécifiée a échoué (== FALSE) et retourne la valeur d’ordre d’erreur qui a été passée dans la macro. N’enregistre pas le résultat de GetLastError(). Enregistre également un message personnalisé s’il est fourni. |
Utilisation de la vérification basée sur les exceptions
Si votre code source est compilé avec des exceptions C++ activées (en spécifiant le commutateur de ligne de commande « /EHsc » ou la macro « USE_NATIVE_EH=1 » dans un fichier source), les macros Verify enregistrent par défaut une erreur en cas d’échec, puis lèvent une exception C++ native. L’exception levée est une exception WEX::TestExecution::VerifyFailureException. Vous n’avez pas besoin de intercepter cette exception : l’infrastructure TAEF l’intercepte pour vous et passe au cas de test suivant.
Si vous souhaitez effectuer une série de vérifications dans une ligne plutôt que d’annuler le test lors du premier échec de vérification, vous pouvez utiliser la classe DisableVerifyExceptions . La durée de vie de l’objet contrôle la durée pendant laquelle les exceptions sont désactivées.
if (NULL != m_key)
{
DisableVerifyExceptions disable;
VERIFY_WIN32_SUCCEEDED(::RegDeleteKey(HKEY_CURRENT_USER, zTempName));
VERIFY_WIN32_SUCCEEDED(::RegCloseKey(m_key));
}
Dans l’exemple ci-dessus, les exceptions sont désactivées uniquement dans le bloc « if (NULL != m_key) », et si le premier appel de vérification échoue, le deuxième appel de vérification est toujours effectué.
La classe DisableVerifyExceptions est comptabilisée par référence et fonctionne également sur une base par thread.
Utilisation de vérification non basée sur les exceptions
Si votre code source n’est pas compilé avec les exceptions C++ activées, les macros Vérifier ne lèvent pas de C++ natif lorsque les vérifications échouent. En outre, si votre code source est compilé avec les exceptions C++ activées, mais que vous souhaitez désactiver les exceptions Vérifier, il vous suffit de #define NO_VERIFY_EXCEPTIONS avant d’inclure « WexTestClass.h ».
Dans ce modèle, vous devez effectuer une série d’instructions if imbriquées afin de contrôler le flux de votre cas de test, plutôt que de vous fier aux exceptions C++.
if (VERIFY_WIN32_SUCCEEDED(::RegDeleteKey(HKEY_CURRENT_USER, zTempName)))
{
...
}
Vérifier les paramètres de sortie
Si vous souhaitez personnaliser la sortie produite par les API Verify, vous pouvez utiliser la classe SetVerifyOutput . La durée de vie de l’objet contrôle la durée de définition des paramètres de sortie. La classe SetVerifyOutput est comptabilisée par référence et fonctionne sur une base par 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");
Dans l’exemple ci-dessus, les paramètres spécifiés concernent uniquement les appels effectués dans le bloc « if (NULL != m_key) », et seul l’appel de vérification qui échoue est consigné. Toutefois, le troisième appel de vérification sera journalisé même s’il réussit. Cela est dû au fait que la classe SetVerifyOutput est sortie de l’étendue.
Les options suivantes existent pour définir la sortie de vérification :
VerifyOutputSettings::LogOnlyFailures
Seuls les appels ayant échoué sont consignés ; tous les appels réussis sont ignorés.
VerifyOutputSettings::LogFailuresAsBlocked
Consignez toutes les défaillances comme étant bloquées au lieu de journaliser une erreur.
VerifyOutputSettings::LogFailuresAsWarnings
Consignez toutes les défaillances sous forme d’avertissements plutôt que de journaliser une erreur.
VerifyOutputSettings::LogValuesOnSuccess
Consignez les valeurs des paramètres passés, même lorsque l’appel De vérification réussit.
Vérifiez que les paramètres de sortie peuvent être OU ensemble pour activer plusieurs paramètres :
SetVerifyOutput verifySettings(VerifyOutputSettings::LogOnlyFailures | VerifyOutputSettings::LogFailuresAsBlocked);
Fourniture d’une sortie de valeur pour les types personnalisés
L’infrastructure De vérification C++ permet de générer une sortie détaillée pour n’importe quel type personnalisé. Pour ce faire, il faut implémenter une spécialisation du modèle de classe WEX::TestExecution::VerifyOutputTraits .
La spécialisation du modèle de classe WEX::TestExecution::VerifyOutputTraits doit exister dans l’espace de noms WEX::TestExecution . Il est également censé fournir une méthode statique publique appelée ToString, qui prend une référence à votre classe et retourne un WEX::Common::NoThrowString contenant une représentation sous forme de chaîne de sa valeur.
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());
}
};
}}
Fourniture de comparateurs pour les types personnalisés
L’infrastructure De vérification C++ permet de définir des comparateurs pour les types personnalisés qui n’implémentent pas les surcharges d’opérateur correspondantes (opérateur=, opérateur<, etc.). Pour ce faire, il faut implémenter une spécialisation du modèle de classe WEX::TestExecution::VerifyCompareTraits .
La spécialisation de modèle de classe WEX::TestExecution::VerifyCompareTraits doit exister dans l’espace de noms WEX::TestExecution . Il est également censé fournir des méthodes statiques publiques appelées AreEqual, AreSame, IsLessThan, IsGreaterThan et 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;
}
};
}}
Utilisation de La vérification à partir de C #
L’utilisation de la vérification C# est similaire à celle de C++. Toutefois, il est fourni via le WEX. Classe TestExecution.Verify , qui se trouve dans Te.Managed.dll.
Les méthodes De vérification suivantes sont disponibles pour les tests C# :
| Macro | Fonctionnalités |
|---|---|
| AreEqual(objet attendu, objet réel) | Vérifie que deux objets spécifiés sont égaux. |
| AreEqual(objet attendu, objet réel, message de chaîne) | Vérifie que deux objets spécifiés sont égaux ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| AreEqual<T>(T attendu, T réel) | Vérifie que deux objets spécifiés sont égaux. |
| AreEqual<T>(T attendu, T réel, message de chaîne) | Vérifie que deux objets spécifiés sont égaux ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| AreNotEqual(objet attendu, objet réel) | Vérifie que deux objets spécifiés ne sont pas égaux. |
| AreNotEqual(objet attendu, objet réel, message de chaîne) | Vérifie que deux objets spécifiés ne sont pas égaux ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| AreNotEqual<T>(T attendu, T réel) | Vérifie que deux objets spécifiés ne sont pas égaux. |
| AreNotEqual<T>(T attendu, T réel, message de chaîne) | Vérifie que deux objets spécifiés ne sont pas égaux ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| AreSame(objet attendu, objet réel) | Vérifie que les deux paramètres spécifiés font référence au même objet. |
| AreSame(objet attendu, objet réel, message de chaîne) | Vérifie que les deux paramètres spécifiés font référence au même objet ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| AreNotSame(objet attendu, objet réel) | Vérifie que les deux paramètres spécifiés ne font pas référence au même objet. |
| AreNotSame(objet attendu, objet réel, message de chaîne) | Vérifie que les deux paramètres spécifiés ne font pas référence au même objet ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| IsGreaterThan(IComparable expectedGreater, IComparable expectedLess) | Vérifie que le premier paramètre est supérieur au deuxième paramètre. |
| IsGreaterThan(IComparable expectedGreater, IComparable expectedLess, string message) | Vérifie que le premier paramètre est supérieur au deuxième paramètre ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| IsGreaterThanOrEqual(IComparable expectedGreater, IComparable expectedLess) | Vérifie que le premier paramètre est supérieur ou égal au deuxième paramètre. |
| IsGreaterThanOrEqual(IComparable expectedGreater, IComparable expectedLess, string message) | Vérifie que le premier paramètre est supérieur ou égal au deuxième paramètre ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| IsLessThan(IComparable expectedLess, IComparable expectedGreater) | Vérifie que le premier paramètre est inférieur au deuxième paramètre. |
| IsLessThan(IComparable expectedLess, IComparable expectedGreater, string message) | Vérifie que le premier paramètre est inférieur au deuxième paramètre ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| IsLessThanOrEqual(IComparable expectedLess, IComparable expectedGreater) | Vérifie que le premier paramètre est inférieur ou égal au deuxième paramètre. |
| IsLessThanOrEqual(IComparable expectedLess, IComparable expectedGreater, message de chaîne) | Vérifie que le premier paramètre est inférieur ou égal au deuxième paramètre ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| Fail(string message) | Échoue sans vérifier les conditions. |
| IsTrue(bool condition) | Vérifie que la condition spécifiée est vraie. |
| IsTrue(bool condition, string message) | Vérifie que la condition spécifiée est vraie ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| IsFalse(bool condition) | Vérifie que la condition spécifiée est false. |
| IsFalse(bool condition, string message) | Vérifie que la condition spécifiée est false ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| IsNull(object obj) | Vérifie que le paramètre spécifié est NULL. |
| IsNull(object obj, string message) | Vérifie que le paramètre spécifié est NULL ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| IsNotNull(object obj) | Vérifie que le paramètre spécifié n’est pas NULL. |
| IsNotNull(object obj, string message) | Vérifie que le paramètre spécifié n’est pas NULL ; consigne un message personnalisé sur la réussite ou l’échec de la vérification. |
| Lève<T>(opération VerifyOperation) | Vérifie que l’opération spécifiée lève le type d’exception donné. Retourne également l’exception pour une inspection supplémentaire. |
| Lève<T>(opération VerifyOperation, message de chaîne) | Vérifie que l’opération spécifiée lève le type d’exception donné ; enregistre un message personnalisé en cas de réussite ou d’échec de la vérification. Retourne également l’exception pour une inspection supplémentaire. |
| NoThrow(VerifyOperation operation) | Vérifie que l’opération spécifiée ne lève pas d’exception. |
| NoThrow(VerifyOperation operation, string message) | Vérifie que l’opération spécifiée ne lève pas d’exception ; enregistre un message personnalisé en cas de réussite ou d’échec de la vérification. |
Utilisation de la vérification basée sur les exceptions
Lorsque des échecs de vérification se produisent dans des cas de test C#, une erreur est écrite dans l’enregistreur d’événements et une erreur WEX. TestExecution.VerifyFailureException est levée. Tout comme dans le modèle C++ natif, vous n’avez pas à vous soucier d’intercepter ces exceptions. L’infrastructure TAEF l’intercepte pour vous et passe au cas de test suivant.
Si vous souhaitez effectuer une série de vérifications dans une ligne plutôt que d’abandonner le test lors du premier échec de vérification, vous pouvez utiliser la classe DisableVerifyExceptions . La durée de vie de l’objet contrôle la durée de désactivation des exceptions. La classe DisableVerifyExceptions est comptabilisée par réf et fonctionne par thread.
using (new DisableVerifyExceptions())
{
Verify.AreSame(item1, item2);
Verify.AreEqual(item1, item2);
}
Dans l’exemple ci-dessus, si le premier appel de vérification échoue, le deuxième appel de vérification est toujours effectué.
Vous pouvez également obtenir le même résultat en définissant Verify.DisableVerifyExceptions = true avant les opérations De vérification telles que l’exemple ci-dessous.
Verify.DisableVerifyExceptions = true;
try
{
Verify.AreSame(item1, item2);
Verify.AreEqual(item1, item2);
}
finally
{
Verify.DisableVerifyExceptions = false;
}
Notez que même si cette option est disponible, la déclaration de DisableVerifyExeptions en tant qu’objet dans un bloc using est toujours l’option recommandée.
Si vous souhaitez vous arrêter dans le débogueur lorsqu’une erreur de vérification se produit pour afficher la boîte de dialogue d’exceptions (Ctrl+Alt+E), cliquez sur Ajouter, choisissez « Common Language Runtime Exceptions » dans la liste déroulante et mettez « WEX. TestExecution.VerifyFailureException » dans le champ Nom.
Vérifier les paramètres de sortie
Si vous souhaitez personnaliser la sortie produite par les API Verify, vous pouvez utiliser la classe SetVerifyOutput . La durée de vie de l’objet contrôle la durée pendant laquelle les paramètres de sortie sont définis. La classe SetVerifyOutput est comptabilisée et fonctionne par 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");
Dans l’exemple ci-dessus, seul le deuxième appel de vérification doit être journalisé, car il s’agit du seul appel qui échoue dans le bloc using. Toutefois, le troisième appel de vérification sera journalisé même s’il réussit. Cela est dû au fait que la classe SetVerifyOutput est sortie de l’étendue.
Vous pouvez également obtenir le même résultat en définissant Verify.OutputSettings = VerifyOutputSettings.LogOnlyFailures avant les opérations De vérification, comme l’exemple ci-dessous.
Verify.OutputSettings = VerifyOutputSettings.LogFailuresAsWarnings
try
{
Verify.AreSame(item1, item2);
Verify.AreEqual(item1, item2);
}
finally
{
Verify.OutputSettings = VerifyOutputSettings.None;
}
Notez que même si cette option est disponible, la déclaration de SetVerifyOutput en tant qu’objet dans un bloc using est toujours l’option recommandée.
Les options suivantes existent pour définir la sortie de vérification :
VerifyOutputSettings.LogOnlyFailures
Seuls les appels de vérification ayant échoué seront consignés ; tous les appels réussis sont ignorés.
VerifyOutputSettings.LogFailuresAsBlocked
Journalisez toutes les défaillances comme étant bloquées au lieu de journaliser une erreur.
VerifyOutputSettings.LogFailuresAsWarnings
Journalisez tous les échecs en tant qu’avertissements au lieu de journaliser une erreur.
Vérifiez que les paramètres de sortie peuvent être OU ensemble pour activer plusieurs paramètres :
using (new SetVerifyOutput(VerifyOutputSettings.LogFailuresAsBlocked | VerifyOutputSettings.LogOnlyFailures))
{
...
}
Utilisation du script Verify From
L’API Verify est également exposée pour les langages de script, suivant les mêmes modèles d’utilisation que C++ et C#.
Installation
Lors de l’utilisation des API de vérification avec script à partir d’une méthode de test TAEF, aucune installation n’est nécessaire. Les API requises sont inscrites à l’aide de « COM gratuit d’inscription ». Pour utiliser l’API scriptable en dehors d’une méthode de test TAEF (en dehors de TAEF ou dans un processus enfant), il suffit d’inscrire le Te.Common.dll binaire à l’aide de regsvr32 à partir d’une invite de commandes avec élévation de privilèges ; par exemple :
regsvr32 Te.Common.dll
Lors du déploiement de TAEF à l’aide d’un fichier de déploiement pour l’exécution en laboratoire, Te.Common.dll est automatiquement inscrite.
Utilisation
Les API Verify avec script sont exposées via l’TE. Classe COM Common.Verify : instanciez simplement cette classe et appelez des méthodes sur celle-ci. La classe Verify fonctionne automatiquement avec WEXLogger pour écrire des vérifications de réussite et d’échec dans le journal.
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>
Cet exemple définit une classe de test de script TAEF avec une seule méthode « HelloWorld ». La ligne 6 utilise l’élément « object » pour définir la variable Verify dans l’étendue globale. La ligne 8 utilise l’élément « reference » pour inclure toutes les constantes de la bibliothèque de types spécifiée (dans ce cas, la bibliothèque de types de Te.Common.dll) dans l’étendue globale du script ; dans ce cas, elle ajoute les constantes « VerifySettings ». Les lignes 16 et 17 montrent simplement l’utilisation de l’API Verify. Lorsqu’il est exécuté, l’exemple génère la sortie suivante :
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 De vérification avec script
Les méthodes de validation sur l’API Verify avec script sont les suivantes :
| Méthode | Fonctionnalités |
|---|---|
| bool Verify.AreEqual(expected, actual, [optional message]) | Vérifie que les deux valeurs sont égales. Si le paramètre « VerifySettings_CoerceTypes » est activé, cette méthode utilise la définition JScript d’égalité. Si le paramètre « VerifySettings_CoerceTypes » n’est pas activé, la méthode utilise la définition JScript de l’identité. 'VerifySettings_CoerceTypes' est activé par défaut. |
| bool Verify.AreNotEqual(expected, actual, [optional message]) | Vérifie que les deux valeurs ne sont pas égales. Si le paramètre « VerifySettings_CoerceTypes » est activé, cette méthode utilise la définition JScript d’égalité. Si le paramètre « VerifySettings_CoerceTypes » n’est pas activé, la méthode utilise la définition JScript de l’identité. 'VerifySettings_CoerceTypes' est activé par défaut. |
| bool Verify.IsGreaterThan(expectedGreater, expectedLess, [optional message]) | Vérifie que la première valeur est supérieure à la seconde. |
| bool Verify.IsGreaterThanOrEqual(expectedGreater, expectedLess, [optional message]) | Vérifie que la première valeur est supérieure ou égale à la seconde. |
| bool Verify.IsLessThan(expectedLess, expectedGreater, [optional message]) | Vérifie que la première valeur est inférieure à la seconde. |
| bool Verify.IsLessThanOrEqual(expectedLess, expectedGreater, [optional message]) | Vérifie que la première valeur est inférieure ou égale à la seconde. |
| bool Verify.AreSame(expected, actual, [optional message]) | Vérifie que les valeurs sont les mêmes. |
| bool Verify.AreNotSame(expected, actual, [optional message]) | Vérifie que les valeurs ne sont pas les mêmes. |
| bool Verify.Fail([optional message]) | Échoue sans vérifier les conditions. |
| bool Verify.IsTrue(expression, [optional message]) | Vérifie que l’expression donnée prend la valeur true. |
| bool Verify.IsFalse(expression, [optional message]) | Vérifie que l’expression donnée prend la valeur false. |
| bool Verify.IsNull(expected, [optional message]) | Vérifie que la valeur donnée est « null ». |
| bool Verify.IsNotNull(expected, [optional message]) | Vérifie que la valeur donnée n’est pas « null ». |
| bool Verify.Throws(function, [optional message]) | Vérifie que la fonction donnée lève l’exception et . |
| bool Verify.NoThrow(function, [optional message]) | Vérifie que la fonction donnée ne lève pas d’exception et . |
Il existe deux méthodes sur la classe Verify pour contrôler les paramètres :
| Méthode | Fonctionnalités |
|---|---|
| objet Verify.EnableSettings(settings) | Le ou les indicateurs de paramètre spécifiés seront activés. |
| objet Verify.DisableSettings(settings) | Le ou les indicateurs de paramètre spécifiés seront désactivés. |
La valeur des paramètres passée aux méthodes Verify.EnableSettings ou Verify.DisableSettings peut être l’une des valeurs suivantes :
VerifySettings_LogOnlyFailures = 0x01
Seuls les échecs sont enregistrés : il n’y a pas de sortie sur les appels de vérification réussis.
VerifySettings_LogFailuresAsBlocked = 0x02
Les échecs sont enregistrés comme « Bloqué », au lieu de « Erreur » par défaut.
VerifySettings_LogFailuresAsWarnings = 0x04
Les échecs sont enregistrés en tant que « Avertissement », au lieu de « Erreur » par défaut.
VerifySettings_LogValuesOnSuccess = 0x08
Les valeurs des paramètres à vérifier sont écrites dans le cadre du message Vérifier le journal. Cette option est activée par défaut.
VerifySettings_CoerceTypes = 0x1000
Les valeurs passées aux méthodes Verify sont contraintes selon les règles de forçage JScript. Cette option est activée par défaut.
VerifySettings_DisableExceptions = 0x2000
Les exceptions ne sont pas levées en cas d’échec d’une validation.
Vérifier les paramètres
L’API Verify fournit des paramètres pour configurer son comportement. Les méthodes « EnableSettings » et « DisableSettings » peuvent être utilisées pour activer ou désactiver des paramètres spécifiques que la classe Verify gère. Les méthodes prennent un ou plusieurs paramètres pour activer ou désactiver.
Verify.EnableSettings(VerifySettings_LogOnlyFailures);
Pour activer ou désactiver plusieurs paramètres dans un appel, vous pouvez inclure plusieurs indicateurs « VerifySettings » :
Verify.EnableSettings(VerifySettings_LogOnlyFailures | VerifySettings_DisableExceptions);
Les méthodes EnableSettings et DisableSettings retournent un objet qui peut être utilisé pour restaurer les paramètres d’origine, ce qui permet d’activer ou de désactiver les paramètres pour une étendue donnée ;
1 var guard = Verify.EnableSettings(VerifySettings_LogOnlyFailures);
2 try
3 {
4 Verify.AreEqual(10, 0xa);
5 }
6 finally
7 {
8 guard.Restore();
9 }
Dans cet exemple, la méthode Verify.EnableSettings est passée « VerifySettings_LogOnlyFailures », qui sera incorporée aux paramètres déjà présents sur l’objet Verify. Un appel Verify est effectué dans un bloc try-finally, de sorte que pendant le bloc final, l’objet « guard » peut être utilisé pour restaurer les paramètres d’origine.
Utilisation de la vérification basée sur les exceptions
Par défaut, les méthodes Verify lèvent une exception en cas d’échec d’une vérification. Lors de l’exécution sous TAEF si l’exception est levée hors de la méthode de test, le test échoue. Par exemple :
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 }
Dans cet exemple, le deuxième appel De vérification ne sera jamais effectué, car le premier lève une exception et échoue au test. La prise en charge des paramètres sur l’API Verify peut être utilisée pour modifier ce comportement, afin que les vérifications ayant échoué ne soient pas levées, ce qui permettrait d’effectuer les appels De vérification suivants. Cela est particulièrement utile pour vérifier un ensemble de paramètres et vérifier que toutes les vérifications sont écrites.
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 }
Étant donné que les exceptions ont été désactivées, les deux vérifications sont écrites dans le journal.
Utilisation de l’API Vérification scriptable en dehors de TAEF
L’API Verify avec script peut être utilisée en dehors de TAEF. Assurez-vous que le Te.Common.dll est inscrit, comme indiqué dans la section Installation, et créez simplement le « TE ». Common.Verify " classe.
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");
Le code précédent génère la sortie de console suivante lorsqu’il est exécuté via 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
Le 'WEX. L’API Logger.Log peut être utilisée pour configurer l’enregistreur d’événements WEX en fonction des besoins (par exemple, en tant que processus enfant), et l’API Verify avec script tire parti de cette configuration.