Comprobación del marco
Para facilitar la escritura de pruebas, TAEF proporciona el marco "Verify" que aprovecha WexLogger para notificar registros detallados con una cantidad mínima de código. El marco Verify ayuda a las pruebas a proporcionar una salida de registro estructurada: genera un registro correcto si una comprobación determinada se realiza correctamente y genera información detallada si se produce un error en una comprobación.
Uso de Verify desde C++
La API Verify se muestra en C++ como un conjunto de macros definidas en el archivo de encabezado "Verify.h" (Nota: No es necesario incluir explícitamente Verify.h, debe incluir "WexTestClass.h", que contiene todo lo que necesita para marcar las pruebas de C++ e interactuar con la API verify y WexLogger).
Las siguientes macros verify están disponibles para las pruebas nativas de C++:
| Macro | Funcionalidad |
|---|---|
| VERIFY_ARE_EQUAL(esperado, real, [mensaje opcional]) | Comprueba que dos objetos especificados son iguales. También registra un mensaje personalizado si se proporciona. |
| VERIFY_ARE_NOT_EQUAL(esperado, real, [mensaje opcional]) | Comprueba que dos objetos especificados no son iguales. También registra un mensaje personalizado si se proporciona. |
| VERIFY_IS_GREATER_THAN(expectedGreater, expectedLess, [mensaje opcional]) | Comprueba que el primer parámetro es mayor que el segundo parámetro. También registra un mensaje personalizado si se proporciona. |
| VERIFY_IS_GREATER_THAN_OR_EQUAL(expectedGreater, expectedLess, [mensaje opcional]) | Comprueba que el primer parámetro es mayor o igual que el segundo. También registra un mensaje personalizado si se proporciona. |
| VERIFY_IS_LESS_THAN(expectedLess, expectedGreater, [mensaje opcional]) | Comprueba que el primer parámetro es menor que el segundo parámetro. También registra un mensaje personalizado si se proporciona. |
| VERIFY_IS_LESS_THAN_OR_EQUAL(expectedLess, expectedGreater, [mensaje opcional]) | Comprueba que el primer parámetro es menor o igual que el segundo. También registra un mensaje personalizado si se proporciona. |
| VERIFY_ARE_SAME(esperado, real, [mensaje opcional]) | Comprueba que los dos parámetros especificados hacen referencia al mismo objeto. También registra un mensaje personalizado si se proporciona. |
| VERIFY_ARE_NOT_SAME(esperado, real, [mensaje opcional]) | Comprueba que los dos parámetros especificados no hacen referencia al mismo objeto. También registra un mensaje personalizado si se proporciona. |
| VERIFY_FAIL ([mensaje opcional]) | Se produce un error sin comprobar las condiciones. También registra un mensaje personalizado si se proporciona. |
| VERIFY_IS_TRUE(condition, [mensaje opcional]) | Comprueba que el bool especificado es true. Llame a VERIFY_IS_TRUE(!! __condition) o VERIFY_WIN32_BOOL_SUCCEEDED(__condition) para probar una BOOL de Win32. También registra un mensaje personalizado si se proporciona. |
| VERIFY_IS_FALSE(condition, [mensaje opcional]) | Comprueba que la bool especificada es false. Llame a VERIFY_IS_FALSE(!! __condition) o VERIFY_WIN32_BOOL_FAILED(__condition) para probar una BOOL de Win32. También registra un mensaje personalizado si se proporciona. |
| VERIFY_IS_NULL(object, [optional message]) | Comprueba que el parámetro especificado es NULL. También registra un mensaje personalizado si se proporciona. |
| VERIFY_IS_NOT_NULL(object, [optional message]) | Comprueba que el parámetro especificado no es NULL. También registra un mensaje personalizado si se proporciona. |
| VERIFY_SUCCEEDED(hresult, [mensaje opcional]) | Comprueba que el VALOR HRESULT especificado es correcto. También registra un mensaje personalizado si se proporciona. |
| VERIFY_SUCCEEDED_RETURN(hresult, [mensaje opcional]) | Comprueba que el VALOR HRESULT especificado es correcto y devuelve el VALOR HRESULT que se pasó a la macro. También registra un mensaje personalizado si se proporciona. |
| VERIFY_FAILED(hresult, [mensaje opcional]) | Comprueba que el VALOR HRESULT especificado no es correcto. También registra un mensaje personalizado si se proporciona. |
| VERIFY_FAILED_RETURN(hresult, [mensaje opcional]) | Comprueba que el VALOR HRESULT especificado no es correcto y devuelve el VALOR HRESULT que se pasó a la macro. También registra un mensaje personalizado si se proporciona. |
| VERIFY_THROWS(operation, exception, [optional message]) | Comprueba que la operación especificada produce el tipo de excepción especificado. También registra un mensaje personalizado si se proporciona. |
| VERIFY_NO_THROW(operation, [mensaje opcional]) | Comprueba que la operación especificada no produce una excepción. También registra un mensaje personalizado si se proporciona. |
| VERIFY_WIN32_SUCCEEDED(win32Result, [mensaje opcional]) | Comprueba que el resultado de Win32 especificado se realizó correctamente. También registra un mensaje personalizado si se proporciona. |
| VERIFY_WIN32_SUCCEEDED_RETURN(win32Result, [mensaje opcional]) | Comprueba que el resultado de Win32 especificado se realizó correctamente y devuelve el long que se pasó a la macro. También registra un mensaje personalizado si se proporciona. |
| VERIFY_WIN32_FAILED(win32Result, [mensaje opcional]) | Comprueba que se produjo un error en el resultado de Win32 especificado. También registra un mensaje personalizado si se proporciona. |
| VERIFY_WIN32_FAILED_RETURN(win32Result, [mensaje opcional]) | Comprueba que se produjo un error en el resultado de Win32 especificado y devuelve el long que se pasó a la macro. También registra un mensaje personalizado si se proporciona. |
| VERIFY_WIN32_BOOL_SUCCEEDED(win32Bool, [mensaje opcional]) | Comprueba que la BOOL de Win32 especificada se realizó correctamente (!= FALSE). Registrará el resultado de GetLastError() si se produce un error en la comprobación. También registra un mensaje personalizado si se proporciona. |
| VERIFY_WIN32_BOOL_SUCCEEDED_RETURN(win32Bool, [mensaje opcional]) | Comprueba que la BOOL de Win32 especificada se realizó correctamente (!= FALSE) y devuelve el BOOL que se pasó a la macro. Registrará el resultado de GetLastError() si se produce un error en la comprobación. También registra un mensaje personalizado si se proporciona. |
| VERIFY_WIN32_BOOL_FAILED(win32Bool, [mensaje opcional]) | Comprueba que se produjo un error en el BOOL de Win32 especificado (== FALSE). No registra el resultado de GetLastError(). También registra un mensaje personalizado si se proporciona. |
| VERIFY_WIN32_BOOL_FAILED_RETURN(win32Bool, [mensaje opcional]) | Comprueba que se produjo un error en bool de Win32 especificado (== FALSE) y devuelve el BOOL que se pasó a la macro. No registra el resultado de GetLastError(). También registra un mensaje personalizado si se proporciona. |
Uso de comprobación basada en excepciones
Si el código fuente se compila con excepciones de C++ habilitadas (especificando el modificador de línea de comandos "/EHsc" o la macro "USE_NATIVE_EH=1" en un archivo de orígenes), las macros Verify tendrán como valor predeterminado registrar un error en caso de error, seguido de iniciar una excepción nativa de C++. La excepción producida es WEX::TestExecution::VerifyFailureException. No es necesario detectar esta excepción: el marco TAEF lo capturará para usted y pasará al siguiente caso de prueba.
Opcionalmente, si desea realizar una serie de comprobaciones en una fila en lugar de tener la anulación de la prueba en el primer error de comprobación, puede usar la clase DisableVerifyExceptions . La duración del objeto controla la cantidad de tiempo que se deshabilitan las excepciones.
if (NULL != m_key)
{
DisableVerifyExceptions disable;
VERIFY_WIN32_SUCCEEDED(::RegDeleteKey(HKEY_CURRENT_USER, zTempName));
VERIFY_WIN32_SUCCEEDED(::RegCloseKey(m_key));
}
En el ejemplo anterior, las excepciones solo se deshabilitan dentro del bloque "if (NULL != m_key)" y, si se produce un error en la primera llamada de comprobación, se sigue realizando la segunda llamada de comprobación.
La clase DisableVerifyExceptions es ref-counted y también funciona por subproceso.
Comprobación basada en excepciones
Si el código fuente no está compilado con excepciones de C++ habilitadas, las macros Verify no producirán un error en C++ nativo cuando se produzca un error en las comprobaciones. Además, si el código fuente está compilado con excepciones de C++ habilitadas, pero desea deshabilitar Comprobar excepciones, simplemente #define NO_VERIFY_EXCEPTIONS antes de incluir "WexTestClass.h".
En este modelo, debe realizar una serie de instrucciones if anidadas para controlar el flujo del caso de prueba, en lugar de depender de excepciones de C++.
if (VERIFY_WIN32_SUCCEEDED(::RegDeleteKey(HKEY_CURRENT_USER, zTempName)))
{
...
}
Comprobar la configuración de salida
Si desea personalizar la salida generada por las API verify, puede usar la clase SetVerifyOutput . La duración del objeto controla la cantidad de tiempo que se establecen los valores de salida. La clase SetVerifyOutput es ref-counted y funciona por subproceso.
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");
En el ejemplo anterior, la configuración especificada solo pertenece al bloque "if (NULL != m_key)" y solo se registrará la llamada de comprobación que produce un error. Sin embargo, la tercera llamada de comprobación se registrará aunque se realice correctamente. Esto se debe al hecho de que la clase SetVerifyOutput se ha quedado fuera del ámbito.
Existen las siguientes opciones para establecer la salida de comprobación:
VerifyOutputSettings::LogOnlyFailures
Solo se registrarán las llamadas de comprobación erróneas; se omiten todas las llamadas correctas.
VerifyOutputSettings::LogFailuresAsBlocked
Registre todos los errores como bloqueados en lugar de registrar un error.
VerifyOutputSettings::LogFailuresAsWarnings
Registre todos los errores como advertencias en lugar de registrar un error.
VerifyOutputSettings::LogValuesOnSuccess
Registre los valores de los parámetros pasados, incluso cuando la llamada Verify se realiza correctamente.
Compruebe que la configuración de salida puede ser OR para habilitar varias opciones de configuración:
SetVerifyOutput verifySettings(VerifyOutputSettings::LogOnlyFailures | VerifyOutputSettings::LogFailuresAsBlocked);
Proporcionar salida de valor para tipos personalizados
El marco Verify de C++ proporciona la capacidad de generar resultados detallados para cualquier tipo personalizado. Para ello, debe implementar una especialización de la plantilla de clase WEX::TestExecution::VerifyOutputTraits .
La especialización de la plantilla de clase WEX::TestExecution::VerifyOutputTraits debe existir en el espacio de nombres WEX::TestExecution . También se espera que proporcione un método estático público denominado ToString, que toma una referencia a la clase y devuelve un WEX::Common::NoThrowString que contiene una representación de cadena de su valor.
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());
}
};
}}
Proporcionar comparadores para tipos personalizados
El marco Verify de C++ proporciona la capacidad de definir comparadores para tipos personalizados que no implementan las sobrecargas de operador correspondientes (operator=, operator<, etc.). Para ello, debe implementar una especialización de la plantilla de clase WEX::TestExecution::VerifyCompareTraits .
La especialización de la plantilla de clase WEX::TestExecution::VerifyCompareTraits debe existir en el espacio de nombres WEX::TestExecution . También se espera que proporcione métodos estáticos públicos denominados 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 de Verify from C #
El uso de C# Verify es similar al de C++. Sin embargo, se proporciona a través de WEX. Clase TestExecution.Verify , que se encuentra dentro de Te.Managed.dll.
Los siguientes métodos Verify están disponibles para las pruebas de C#:
| Macro | Funcionalidad |
|---|---|
| AreEqual(object expected, object real) | Comprueba que dos objetos especificados son iguales. |
| AreEqual(object expected, object actual, string message) | Comprueba que dos objetos especificados son iguales; registra un mensaje personalizado en la comprobación correcta o con errores. |
| AreEqual<T>(T expected, T actual) | Comprueba que dos objetos especificados son iguales. |
| AreEqual<T>(T expected, T real, string message) | Comprueba que dos objetos especificados son iguales; registra un mensaje personalizado en la comprobación correcta o con errores. |
| AreNotEqual(object expected, object real) | Comprueba que dos objetos especificados no son iguales. |
| AreNotEqual(object expected, object actual, string message) | Comprueba que dos objetos especificados no son iguales; registra un mensaje personalizado en la comprobación correcta o con errores. |
| AreNotEqual<T>(T expected, T actual) | Comprueba que dos objetos especificados no son iguales. |
| AreNotEqual<T>(T expected, T real, string message) | Comprueba que dos objetos especificados no son iguales; registra un mensaje personalizado en la comprobación correcta o con errores. |
| AreSame(object expected, object actual) | Comprueba que los dos parámetros especificados hacen referencia al mismo objeto. |
| AreSame(object expected, object actual, string message) | Comprueba que los dos parámetros especificados hacen referencia al mismo objeto; registra un mensaje personalizado en la comprobación correcta o con errores. |
| AreNotSame(object expected, object real) | Comprueba que los dos parámetros especificados no hacen referencia al mismo objeto. |
| AreNotSame(object expected, object actual, string message) | Comprueba que los dos parámetros especificados no hacen referencia al mismo objeto; registra un mensaje personalizado en la comprobación correcta o con errores. |
| IsGreaterThan(IComparable expectedGreater, IComparable expectedLess) | Comprueba que el primer parámetro es mayor que el segundo parámetro. |
| IsGreaterThan(IComparable expectedGreater, IComparable expectedLess, string message) | Comprueba que el primer parámetro es mayor que el segundo; registra un mensaje personalizado en la comprobación correcta o con errores. |
| IsGreaterThanOrEqual(IComparable expectedGreater, IComparable expectedLess) | Comprueba que el primer parámetro es mayor o igual que el segundo. |
| IsGreaterThanOrEqual(IComparable expectedGreater, IComparable expectedLess, string message) | Comprueba que el primer parámetro es mayor o igual que el segundo; registra un mensaje personalizado en la comprobación correcta o con errores. |
| IsLessThan(IComparable expectedLess, IComparable expectedGreater) | Comprueba que el primer parámetro es menor que el segundo parámetro. |
| IsLessThan(IComparable expectedLess, IComparable expectedGreater, string message) | Comprueba que el primer parámetro es menor que el segundo; registra un mensaje personalizado en la comprobación correcta o con errores. |
| IsLessThanOrEqual(IComparable expectedLess, IComparable expectedGreater) | Comprueba que el primer parámetro es menor o igual que el segundo. |
| IsLessThanOrEqual(IComparable expectedLess, IComparable expectedGreater, string message) | Comprueba que el primer parámetro es menor o igual que el segundo; registra un mensaje personalizado en la comprobación correcta o con errores. |
| Fail(string message) | Se produce un error sin comprobar las condiciones. |
| IsTrue(bool condition) | Comprueba que la condición especificada es true. |
| IsTrue(bool condition, string message) | Comprueba que la condición especificada es verdadera; registra un mensaje personalizado en la comprobación correcta o con errores. |
| IsFalse(bool condition) | Comprueba que la condición especificada es false. |
| IsFalse(bool condition, string message) | Comprueba que la condición especificada es false; registra un mensaje personalizado en la comprobación correcta o con errores. |
| IsNull(object obj) | Comprueba que el parámetro especificado es NULL. |
| IsNull(object obj, string message) | Comprueba que el parámetro especificado es NULL; registra un mensaje personalizado en la comprobación correcta o con errores. |
| IsNotNull(object obj) | Comprueba que el parámetro especificado no es NULL. |
| IsNotNull(object obj, string message) | Comprueba que el parámetro especificado no es NULL; registra un mensaje personalizado en la comprobación correcta o con errores. |
| Inicia la<operación T>(VerifyOperation) | Comprueba que la operación especificada produce el tipo de excepción especificado. También devuelve la excepción para una mayor inspección. |
| Inicia la<operación T>(VerifyOperation, mensaje de cadena) | Comprueba que la operación especificada produce el tipo de excepción especificado; registra un mensaje personalizado en la comprobación correcta o con errores. También devuelve la excepción para una mayor inspección. |
| NoThrow(VerifyOperation operation) | Comprueba que la operación especificada no produce una excepción. |
| NoThrow(VerifyOperation operation, string message) | Comprueba que la operación especificada no produce una excepción; registra un mensaje personalizado en la comprobación correcta o con errores. |
Uso de comprobación basada en excepciones
Cuando se producen errores de comprobación en los casos de prueba de C#, se escribe un error en el registrador y un WEX. Se produce TestExecution.VerifyFailureException . Al igual que en el modelo nativo de C++, no es necesario preocuparse por detectar estas excepciones. El marco TAEF lo atrapará para usted y pasará al siguiente caso de prueba.
Opcionalmente, si desea realizar una serie de comprobaciones en una fila en lugar de tener la anulación de la prueba en el primer error de comprobación, puede usar la clase DisableVerifyExceptions . La duración del objeto controla la cantidad de tiempo que se deshabilitan las excepciones. La clase DisableVerifyExceptions es ref-counted y funciona por subproceso.
using (new DisableVerifyExceptions())
{
Verify.AreSame(item1, item2);
Verify.AreEqual(item1, item2);
}
En el ejemplo anterior, si se produce un error en la primera llamada de comprobación, se sigue realizando la segunda llamada de comprobación.
Como alternativa, puede lograr el mismo resultado estableciendo Verify.DisableVerifyExceptions = true antes de las operaciones Verify, como el ejemplo que se muestra a continuación.
Verify.DisableVerifyExceptions = true;
try
{
Verify.AreSame(item1, item2);
Verify.AreEqual(item1, item2);
}
finally
{
Verify.DisableVerifyExceptions = false;
}
Tenga en cuenta que aunque esta opción está disponible, declarar DisableVerifyExeptions como un objeto en un bloque using sigue siendo la opción recomendada.
Si desea detener en el depurador cuando se produce un error de comprobación, aparezca el cuadro de diálogo de excepciones (Ctrl+Alt+E), haga clic en Agregar, elija "Excepciones de Common Language Runtime" en la lista desplegable y coloque "WEX. TestExecution.VerifyFailureException" en el campo Nombre.
Comprobar la configuración de salida
Si desea personalizar la salida generada por las API verify, puede usar la clase SetVerifyOutput . La duración del objeto controla la cantidad de tiempo que se establecen los valores de salida. La clase SetVerifyOutput es ref-counted y funciona por subproceso.
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");
En el ejemplo anterior, solo se debe registrar la segunda llamada de comprobación, ya que es la única llamada que produce un error en el bloque using. Sin embargo, la tercera llamada de comprobación se registrará aunque se realice correctamente. Esto se debe al hecho de que la clase SetVerifyOutput se ha quedado fuera del ámbito.
Como alternativa, puede lograr el mismo resultado estableciendo Verify.OutputSettings = VerifyOutputSettings.LogOnlyFailures antes de las operaciones Verify, como el ejemplo que se muestra a continuación.
Verify.OutputSettings = VerifyOutputSettings.LogFailuresAsWarnings
try
{
Verify.AreSame(item1, item2);
Verify.AreEqual(item1, item2);
}
finally
{
Verify.OutputSettings = VerifyOutputSettings.None;
}
Tenga en cuenta que aunque esta opción está disponible, declarar SetVerifyOutput como un objeto en un bloque using sigue siendo la opción recomendada.
Existen las siguientes opciones para establecer la salida de comprobación:
VerifyOutputSettings.LogOnlyFailures
Solo se registrarán las llamadas de comprobación erróneas; se omiten todas las llamadas correctas.
VerifyOutputSettings.LogFailuresAsBlocked
Registre todos los errores como bloqueados en lugar de registrar un error.
VerifyOutputSettings.LogFailuresAsWarnings
Registre todos los errores como advertencias en lugar de registrar un error.
Compruebe que la configuración de salida puede ser OR para habilitar varias opciones de configuración:
using (new SetVerifyOutput(VerifyOutputSettings.LogFailuresAsBlocked | VerifyOutputSettings.LogOnlyFailures))
{
...
}
Uso de Verify From Script
La API Verify también aparece para lenguajes de script, siguiendo los mismos patrones de uso que C++ y C#.
Instalación
Al usar la API de comprobación de scriptable desde dentro de un método de prueba DE TAEF no es necesario realizar ninguna instalación, las API necesarias se registran mediante "Registration Free COM". Para usar la API scriptable desde fuera de un método de prueba DE TAEF (fuera de TAEF o en un proceso secundario) simplemente registre el Te.Common.dll binario mediante regsvr32 desde un símbolo del sistema con privilegios elevados; por ejemplo:
regsvr32 Te.Common.dll
Al implementar TAEF mediante un archivo de implementación para la ejecución del laboratorio, Te.Common.dll se registra automáticamente.
Uso
Las API verify que admiten scripts se muestran a través de "TE". Clase COM de Common.Verify: basta con crear una instancia de esa clase y llamar a métodos en él: la clase Verify funcionará automáticamente con WEXLogger para escribir comprobaciones de paso y error en el registro.
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>
En este ejemplo se define una clase de prueba de script TAEF con un único método "HelloWorld". La línea 6 usa el elemento 'object' para definir la variable Verify en el ámbito global. La línea 8 usa el elemento 'reference' para incluir todas las constantes de la biblioteca de tipos especificada (en este caso, Te.Common.dll biblioteca de tipos) en el ámbito global del script; en este caso agrega las constantes "VerifySettings". Las líneas 16 y 17 muestran simplemente el uso de la API verify. Cuando se ejecute, el ejemplo generará la siguiente salida:
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 comprobación de scriptable
Los métodos para la validación en la API verify que admiten scripts son los siguientes:
| Método | Funcionalidad |
|---|---|
| bool Verify.AreEqual(expected, actual, [optional message]) | Comprueba que los dos valores son iguales. Si la opción "VerifySettings_CoerceTypes" está habilitada, este método usa la definición de igualdad de JScript, si el valor de "VerifySettings_CoerceTypes" no está habilitado, el método usa la definición de JScript de identidad. "VerifySettings_CoerceTypes" está activado de forma predeterminada. |
| bool Verify.AreNotEqual(expected, actual, [optional message]) | Comprueba que los dos valores no son iguales. Si la opción "VerifySettings_CoerceTypes" está habilitada, este método usa la definición de igualdad de JScript, si el valor de "VerifySettings_CoerceTypes" no está habilitado, el método usa la definición de JScript de identidad. "VerifySettings_CoerceTypes" está activado de forma predeterminada. |
| bool Verify.IsGreaterThan(expectedGreater, expectedLess, [mensaje opcional]) | Comprueba que el primer valor es mayor que el segundo. |
| bool Verify.IsGreaterThanOrEqual(expectedGreater, expectedLess, [mensaje opcional]) | Comprueba que el primer valor es mayor o igual que el segundo. |
| bool Verify.IsLessThan(expectedLess, expectedGreater, [mensaje opcional]) | Comprueba que el primer valor es menor que el segundo. |
| bool Verify.IsLessThanOrEqual(expectedLess, expectedGreater, [mensaje opcional]) | Comprueba que el primer valor es menor o igual que el segundo. |
| bool Verify.AreSame(expected, actual, [optional message]) | Comprueba que los valores son los mismos. |
| bool Verify.AreNotSame(expected, actual, [optional message]) | Comprueba que los valores no son los mismos. |
| bool Verify.Fail([mensaje opcional]) | Se produce un error sin comprobar las condiciones. |
| bool Verify.IsTrue(expression, [optional message]) | Comprueba que la expresión especificada se evalúa como true. |
| bool Verify.IsFalse(expression, [optional message]) | Comprueba que la expresión especificada se evalúa como false. |
| bool Verify.IsNull(expected, [optional message]) | Comprueba que el valor especificado es "null". |
| bool Verify.IsNotNull(expected, [optional message]) | Comprueba que el valor especificado no es "null". |
| bool Verify.Throws(function, [optional message]) | Comprueba que la función especificada produce y excepción. |
| bool Verify.NoThrow(function, [optional message]) | Comprueba que la función especificada no inicia y excepción. |
Hay dos métodos en la clase Verify para controlar la configuración:
| Método | Funcionalidad |
|---|---|
| object Verify.EnableSettings(settings) | Se habilitará la marca o marcas de configuración especificadas. |
| object Verify.DisableSettings(settings) | La marca o marcas de configuración especificadas se deshabilitarán. |
El valor de configuración pasado a los métodos Verify.EnableSettings o Verify.DisableSettings puede ser cualquiera de los valores siguientes:
VerifySettings_LogOnlyFailures = 0x01
Solo se registran errores: no hay ninguna salida en las llamadas verify correctas.
VerifySettings_LogFailuresAsBlocked = 0x02
Los errores se registran como "Bloqueados", en lugar del valor predeterminado "Error".
VerifySettings_LogFailuresAsWarnings = 0x04
Los errores se registran como "Advertencia", en lugar del valor predeterminado "Error".
VerifySettings_LogValuesOnSuccess = 0x08
Los valores de los parámetros que se van a comprobar se escriben como parte del mensaje comprobar registro. Esto está activado de forma predeterminada.
VerifySettings_CoerceTypes = 0x1000
Los valores pasados a los métodos Verify se coercirán siguiendo las reglas de coerción de JScript. Esto está activado de forma predeterminada.
VerifySettings_DisableExceptions = 0x2000
Las excepciones no se producirán cuando se produzca un error en una validación.
Comprobar la configuración
La API Verify proporciona opciones para configurar su comportamiento. Los métodos "EnableSettings" y "DisableSettings" se pueden usar para habilitar o deshabilitar configuraciones específicas que mantiene la clase Verify. Los métodos toman una o varias opciones de configuración para habilitar o deshabilitar.
Verify.EnableSettings(VerifySettings_LogOnlyFailures);
Para habilitar o deshabilitar varias configuraciones en una llamada, puede incluir varias marcas "VerifySettings":
Verify.EnableSettings(VerifySettings_LogOnlyFailures | VerifySettings_DisableExceptions);
Los métodos EnableSettings y DisableSettings devuelven un objeto que se puede usar para restaurar la configuración original, lo que permite habilitar o deshabilitar la configuración para un ámbito determinado;
1 var guard = Verify.EnableSettings(VerifySettings_LogOnlyFailures);
2 try
3 {
4 Verify.AreEqual(10, 0xa);
5 }
6 finally
7 {
8 guard.Restore();
9 }
En este ejemplo, el método Verify.EnableSettings se pasa "VerifySettings_LogOnlyFailures", que se incorporará con la configuración que ya está presente en el objeto Verify. Se realiza una llamada Verify dentro de un bloque try-finally, de modo que durante el bloque finally, el objeto "guard" se puede usar para restaurar la configuración original.
Comprobación basada en excepciones
De forma predeterminada, los métodos Verify producirán una excepción cuando se produzca un error en una comprobación. Cuando se ejecuta en TAEF si se produce la excepción fuera del método de prueba, se producirá un error en la prueba. Por ejemplo:
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 }
En este ejemplo, nunca se realizará la segunda llamada Verify, ya que la primera producirá una excepción y producirá un error en la prueba. La compatibilidad con la configuración en verify API se puede usar para cambiar este comportamiento, de modo que las comprobaciones con errores no se inicien, lo que permitiría realizar llamadas verify posteriores. Esto es especialmente útil para comprobar un conjunto de parámetros y asegurarse de que todas las comprobaciones se escriben.
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 }
Dado que las excepciones estaban deshabilitadas, ambas comprobaciones se escribirán en el registro.
Uso de scriptable Verify API fuera de TAEF
La API Verify ejecutable se puede usar fuera de TAEF. Asegúrese de que el Te.Common.dll está registrado, como se indica en la sección Instalación, y cree el "TE". Clase 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");
El código anterior generará la salida de la consola siguiente cuando se ejecute a través de 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
Wex. La API Logger.Log' se puede usar para configurar el registrador WEX según sea necesario (por ejemplo, como un proceso secundario) y la API Verify que se pueda crear con scripts aprovechará esa configuración.