Compartir a través de

WexLogger

  • Artículo

WexLogger proporciona una API coherente para el registro que abarca código nativo, código administrado y script. También se escala desde la ejecución de pruebas unitarias en un símbolo del sistema hasta pruebas de esfuerzo de larga distancia.

Registro a través del marco de comprobación

La mayoría del registro dentro de un caso de prueba se debe realizar a través del marco Verify . Esto garantizará que las pruebas se crean de forma más clara, secuencial y legible. Sin embargo, en algunos casos, los autores de pruebas encontrarán que necesitan un control más granular sobre lo que se escribe en los registros: por lo tanto, la necesidad de la API de WexLogger.

Registro en TAEF

En el caso de los casos de prueba que se ejecutan en TAEF, el autor de la prueba no necesita ninguna inicialización del registrador. Puede empezar inmediatamente a usar la API de registro que se expone al idioma en el que está creando las pruebas.

En el código nativo de C++, tendrá este aspecto:

using namespace WEX::Logging;
using namespace WEX::Common;
Log::Comment(L"Rendering to the BufferView");
Log::Comment(L"Render succeeded");

Log::Comment(String().Format(L"Look, a number! %d", aNumber));

#define LOG_OUTPUT(fmt, ...) Log::Comment(String().Format(fmt, __VA_ARGS__))
LOG_OUTPUT(L"Look, a number! %d", aNumber);

En el código administrado, tendrá este aspecto:

using WEX.Logging.Interop;
Log.Comment("Rendering to the BufferView");
Log.Comment("Render succeeded");

En JScript, tendrá este aspecto:

var log = new ActiveXObject("WEX.Logger.Log");
log.Comment("Rendering to the BufferView");
log.Comment("Render succeeded");

Registro fuera de TAEF

La mayor parte del tiempo, la inicialización del registro y la finalización serán realizadas por TAEF, por lo que WexLogger estará listo para usarse durante la duración del caso de prueba, como se indicó anteriormente, y finalizará correctamente. Sin embargo, si un cliente desea usar WexLogger fuera de TAEF, será responsable de llamar manualmente a LogController::InitializeLogging() y LogController::FinalizeLogging(). Este requisito solo existe para código nativo y administrado; Los scripts no tienen este requisito adicional. Consulte la tabla Métodos logController estáticos a continuación para obtener más información sobre la API de LogController.

Consulte la sección Generación de registros WTT para obtener información sobre cómo generar registros WTT fuera de TAEF.

WexLogger API

Esta es la lista de métodos de registro nativos de C++ disponibles.

Hay versiones equivalentes disponibles para el código administrado y el script.

Métodos de registro nativos de C++ Funcionalidad
Assert(const wchar_t* pszAssert) Registre una aserción de prueba.
Assert(const wchar_t* pszAssert, const wchar_t* pszContext) Registre una aserción de prueba, con contexto.
Assert(const wchar_t* pszAssert, const wchar_t* pszFile, const wchar_t* pszFunction, int line) Registre una aserción de prueba con información de archivo, función y línea.
Assert(const wchar_t* pszAssert, const wchar_t* pszContext, const wchar_t* pszFile, const wchar_t* pszFunction, int line) Registre una aserción de prueba, con contexto y también archivo, función e información de línea.
Bug(const wchar_t* pszBugDatabase, int bugId) Registre un número de error conocido.
Bug(const wchar_t* pszBugDatabase, int bugId, const wchar_t* pszContext) Registre un número de error conocido, con contexto.
Comment(const wchar_t* pszComment) Registre un comentario de prueba.
Comment(const wchar_t* pszComment, const wchar_t* pszContext) Registrar un comentario de prueba, con contexto
EndGroup(const wchar_t* pszGroupName) Registre el final de un grupo de pruebas o de una prueba específica.
EndGroup(const wchar_t* pszGroupName, const wchar_t* pszContext) Registre el final de un grupo de pruebas, o de una prueba específica, con contexto.
Error(const wchar_t* pszError) Registre un error de prueba.
Error(const wchar_t* pszError, const wchar_t* pszContext) Registre un error de prueba, con contexto.
Error(const wchar_t* pszError, const wchar_t* pszFile, const wchar_t* pszFunction, int line) Registre un error de prueba con información de archivo, función y línea.
Error(const wchar_t* pszError, const wchar_t* pszContext, const wchar_t* pszFile, const wchar_t* pszFunction, int line) Registre un error de prueba, con contexto y también archivo, información de función y línea.
File(const wchar_t* pszFileName) Registre un archivo de prueba que se va a guardar. Los archivos se guardan <en WTTRunWorkingDir>\WexLogFileOutput (si se establece WTTRunWorkingDir) o <CurrentDirectory\>WexLogFileOutput.
File(const wchar_t* pszFileName, const wchar_t* pszContext) Registre un archivo de prueba que se va a guardar, con contexto. Los archivos se guardan <en WTTRunWorkingDir>\WexLogFileOutput (si se establece WTTRunWorkingDir) o <CurrentDirectory\>WexLogFileOutput.
Property(const wchar_t* pszName, const wchar_t* pszValue) Registre un par de propiedades nombre-valor. El valor puede estar en formato xml.
Property(const wchar_t* pszName, const wchar_t* pszValue, const wchar_t* pszContext) Registre un par de propiedades nombre-valor, con contexto. El valor puede estar en formato xml.
Result(TestResults::Result testResult) Registre un resultado de prueba.
Result(TestResults::Result testResult, const wchar_t* pszComment) Registre un resultado de prueba con un comentario asociado.
Result(TestResults::Result testResult, const wchar_t* pszComment, const wchar_t* pszContext) Registre un resultado de prueba con un comentario asociado, con contexto.
StartGroup(const wchar_t* pszGroupName) Registre el inicio de un grupo de pruebas o de una prueba específica.
StartGroup(const wchar_t* pszGroupName, TestResults::Result defaultTestResult) Registre el inicio de un grupo de pruebas o de una prueba específica; también establece el resultado de la prueba predeterminado.
StartGroup(const wchar_t* pszGroupName, const wchar_t* pszContext) Registre el inicio de un grupo de pruebas, o de una prueba específica, con contexto.
StartGroup(const wchar_t* pszGroupName, const wchar_t* pszContext, TestResults::Result defaultTestResult) Registre el inicio de un grupo de pruebas o de una prueba específica; también establece el resultado de la prueba predeterminado.
Warning(const wchar_t* pszWarning) Registre una advertencia de prueba.
Warning(const wchar_t* pszWarning, const wchar_t* pszContext) Registre una advertencia de prueba, con contexto.
Warning(const wchar_t* pszWarning, const wchar_t* pszFile, const wchar_t* pszFunction, int line) Registre una advertencia de prueba con información de archivo, función y línea.
Warning(const wchar_t* pszWarning, const wchar_t* pszContext, const wchar_t* pszFile, const wchar_t* pszFunction, int line) Registre una advertencia de prueba, con contexto y también archivo, información de función y línea.
Xml(const wchar_t* pszXml) Registrar datos xml. No se realiza ninguna comprobación para comprobar que tiene un formato correcto.
Xml(const wchar_t* pszXml, const wchar_t* pszContext) Registrar datos xml, con contexto. No se realiza ninguna comprobación para comprobar que tiene un formato correcto.
MiniDump() Registre el mini volcado de memoria del proceso actual.

Nota: "Context" es una cadena adicional que, opcionalmente, puede proporcionar con una llamada API de WexLogger para proporcionar más contexto o detalles. Por ejemplo, puede optar por pasar siempre "ImageComparator" como contexto al realizar llamadas API de WexLogger desde los métodos de clase ImageComparator.

Estos son los valores válidos posibles para la enumeración TestResults::Result nativa de C++. Hay versiones equivalentes disponibles para el código administrado y el script.

Enumeración TestResults::Result nativa de C++ Funcionalidad
Superado Prueba superada
NotRun La prueba no se ejecutó
Omitido La prueba se omitió
Bloqueado La prueba se bloqueó
Con error Error en la prueba

Esta es la lista de métodos nativos de LogController de C++ disponibles:

Métodos LogController nativos de C++ Funcionalidad
static HRESULT InitializeLogging() Inicialice la funcionalidad de registro.
static HRESULT InitializeLogging(WexLoggerErrorCallback pfnErrorCallback) Inicialice la funcionalidad de registro y especifique la función WexLoggerErrorCallback que desea usar para recibir notificaciones de errores internos del registrador.
static HRESULT InitializeLogging(const wchar_t* pszLogName) Inicialice la funcionalidad de registro y especifique el nombre del archivo de registro que desea usar. Nota: El nombre del registro solo se tiene en cuenta si WttLogging está habilitado.
static HRESULT InitializeLogging(const wchar_t* pszLogName, WexLoggerErrorCallback pfnErrorCallback) Inicialice la funcionalidad de registro, especifique el nombre del archivo de registro que desea usar y especifique la función WexLoggerErrorCallback que desea usar para recibir una notificación de errores internos del registrador. Nota: El nombre del registro solo se tiene en cuenta si WttLogging está habilitado.
static bool IsInitialized() Devuelve si logController se ha inicializado o no para este proceso.
static const unsigned short* GetLogName() Devuelve el nombre especificado para el registro en la llamada InitializeLogging (si existe).
static HRESULT FinalizeLogging() Finalice la funcionalidad de registro.

Nota: Consulte la sección Control de errores de C++ a continuación para obtener más información sobre el mecanismo WexLoggerErrorCallback y cómo usarlo fuera del marco TAEF.

Nota: Solo es necesario llamar a InitializeLogging/FinalizeLogging al usar WexLogger fuera del marco TAEF, ya que TAEF ya controla la inicialización o finalización del registro.

Nota: No es necesario inicializar o completar la funcionalidad de registro al usar WexLogger desde el script.

Esta es la lista de métodos RemoteLogContoller nativos de C++ disponibles:

Métodos RemoteLogController nativos de C++ Funcionalidad
static HRESULT GenerateConnectionData(WEX::Common::NoThrowString& connectionData) Genera los datos de conexión que se deben usar dentro de los procesos primarios y secundarios para permitir que el proceso secundario vuelva a iniciar sesión en el proceso primario.
static HRESULT GenerateConnectionData(const wchar_t* pszMachineName, WEX::Common::NoThrowString& connectionData) Se usa al iniciar procesos secundarios en una máquina remota. Genera los datos de conexión que se deben usar dentro de los procesos primarios y secundarios para permitir que el proceso secundario vuelva a iniciar sesión en el proceso primario.
static HRESULT InitializeLogging(WEX::Common::NoThrowString connectionData) Inicializa la funcionalidad de registro dentro del proceso primario para que el proceso secundario pueda volver a iniciar sesión en él.

Nota: Consulte la sección Registro remoto desde procesos secundarios a continuación para obtener más información sobre el registro remoto.

Esta es la lista de métodos de registro administrados disponibles.

Métodos de registro administrados Funcionalidad
Assert(proveedor IFormatProvider, formato de cadena, objeto params[] args) Registre una aserción de prueba mediante un proveedor de información de formato específico de la referencia cultural, una cadena de formato y una matriz de objetos que contenga cero o más objetos para dar formato.
Assert(proveedor IFormatProvider, formato de cadena, objeto params[] args) Registre una aserción de prueba mediante un proveedor de información de formato específico de la referencia cultural, una cadena de formato y una matriz de objetos que contenga cero o más objetos para dar formato.
Assert(string message) Registre una aserción de prueba.
Assert(string format, object arg0) Registre una aserción de prueba mediante una cadena de formato y un objeto al que se va a dar formato.
Assert(string format, params object[] args) Registre una aserción de prueba mediante una cadena de formato y una matriz de objetos que contenga cero o más objetos para dar formato.
Assert(string message, string context) Registre una aserción de prueba, con contexto.
Assert(string message, string file, string function, int line) Registre una aserción de prueba, y también archivo, información de función y línea.
Assert(string message, string context, string file, string function, int line) Registre una aserción de prueba, con contexto y también archivo, función e información de línea.
Bug(string bugDatabase, int bugId) Registre un número de error conocido.
Bug(string bugDatabase, int bugId, string context) Registre un número de error conocido, con contexto.
Comment(proveedor IFormatProvider, formato de cadena, objeto params[] args) Registre un comentario de prueba mediante un proveedor de información de formato específico de la referencia cultural, una cadena de formato y una matriz de objetos que contenga cero o más objetos para dar formato.
Comment(string message) Registrar un comentario de prueba
Comment(string format, object arg0) Registre un comentario de prueba con una cadena de formato y un objeto al que se va a dar formato.
Comment(string format, params object[] args) Registre un comentario de prueba mediante una cadena de formato y una matriz de objetos que contenga cero o más objetos para dar formato.
Comment(string message, string context) Registrar un comentario de prueba, con contexto
EndGroup(string groupName) Registre el final de un grupo de pruebas o de una prueba específica.
EndGroup(string groupName, string context) Registre el final de un grupo de pruebas, o de una prueba específica, con contexto.
Error(proveedor IFormatProvider, formato de cadena, objeto params[] args) Registre un error de prueba mediante un proveedor de información de formato específico de la referencia cultural, una cadena de formato y una matriz de objetos que contenga cero o más objetos para dar formato.
Error(mensaje de cadena) Registre un error de prueba.
Error(string format, object arg0) Registre un error de prueba mediante una cadena de formato y un objeto al que se va a dar formato.
Error(string message, string context) Registre un error de prueba, con contexto.
Error(proveedor IFormatProvider, formato de cadena, objeto params[] args) Registre un error de prueba mediante una cadena de formato y una matriz de objetos que contenga cero o más objetos para dar formato.
Error(string message, string file, string function, int line) Registre un error de prueba con información de archivo, función y línea.
Error(string message, string context, string file, string function, int line) Registre un error de prueba, con contexto y también archivo, información de función y línea.
File(string fileName) Registre un archivo de prueba que se va a guardar. Los archivos se guardan en WTTRunWorkingDir\WexLogFileOutput (si se establece WTTRunWorkingDir) o CurrentDirectory\WexLogFileOutput.
File(string fileName, string context) Registre un archivo de prueba que se va a guardar, con contexto. Los archivos se guardan en WTTRunWorkingDir\WexLogFileOutput (si se establece WTTRunWorkingDir) o CurrentDirectory\WexLogFileOutput.
MiniDump() Registre el mini volcado de memoria del proceso actual.
Property(nombre de cadena, valor de cadena) Registre un par de propiedades nombre-valor. El valor puede estar en formato xml.
Property(string name, string value, string context) Registre un par de propiedades nombre-valor, con contexto. El valor puede estar en formato xml.
Result(TestResult testResult) Registre un resultado de prueba.
Result(TestResult testResult, string comment) Registre un resultado de prueba con un comentario asociado.
Result(TestResult testResult, string comment, string context) Registre un resultado de prueba con un comentario asociado, con contexto.
StartGroup(string groupName) Registre el inicio de un grupo de pruebas o de una prueba específica.
StartGroup(string groupName, string context) Registre el inicio de un grupo de pruebas, o de una prueba específica, con contexto.
Warning(proveedor IFormatProvider, formato de cadena, objeto params[] args) Registre una advertencia de prueba mediante un proveedor de información de formato específico de la referencia cultural, una cadena de formato y una matriz de objetos que contenga cero o más objetos para dar formato.
Warning(string message) Registre una advertencia de prueba.
Warning(string format, object arg0) Registre una advertencia de prueba con una cadena de formato y un objeto al que se va a dar formato.
Warning(string format, params object[] args) Registre una advertencia de prueba mediante una cadena de formato y una matriz de objetos que contenga cero o más objetos para dar formato.
Warning(string message, string context) Registre una advertencia de prueba, con contexto.
Warning(string message, string file, string function, int line) Registre una advertencia de prueba con información de archivo, función y línea.
Warning(string message, string context, string file, string function, int line) Registre una advertencia de prueba, con contexto y también archivo, información de función y línea.
Xml(string xmlData) Registrar datos xml. No se realiza ninguna comprobación para comprobar que tiene un formato correcto.
Xml(string xmlData, string context) Registrar datos xml, con contexto. No se realiza ninguna comprobación para comprobar que tiene un formato correcto.

Esta es la lista de métodos logContoller administrados disponibles:

Métodos LogController administrados Funcionalidad
static void InitializeLogging() Inicialice la funcionalidad de registro.
static void InitializeLogging(String logName) Inicialice la funcionalidad de registro y especifique el nombre del archivo de registro que desea usar. Nota: El nombre del registro solo se tiene en cuenta si WttLogging está habilitado.
static bool IsInitialized() Devuelve si logController se ha inicializado o no para este proceso.
static String GetLogName() Devuelve el nombre especificado para el registro en la llamada InitializeLogging (si existe).
static void FinalizeLogging() Finalice la funcionalidad de registro.

Nota: Consulte la sección Error y excepción de código administrado a continuación para obtener más información sobre cómo controlar errores y excepciones al usar la capa administrada de WexLogger fuera del marco TAEF.

Nota: Solo es necesario llamar a InitializeLogging/FinalizeLogging al usar WexLogger fuera del marco TAEF, ya que TAEF ya controla la inicialización o finalización del registro.

Nota: No es necesario inicializar o completar la funcionalidad de registro al usar WexLogger desde el script.

Esta es la lista de métodos RemoteLogContoller administrados disponibles:

Métodos RemoteLogController administrados Funcionalidad
static String GenerateConnectionData() Genera los datos de conexión que se deben usar dentro de los procesos primarios y secundarios para permitir que el proceso secundario vuelva a iniciar sesión en el proceso primario.
static String GenerateConnectionData(string machineName) Se usa al iniciar procesos secundarios en una máquina remota. Genera los datos de conexión que se deben usar dentro de los procesos primarios y secundarios para permitir que el proceso secundario vuelva a iniciar sesión en el proceso primario.
static void InitializeLogging(String connectionData) Inicializa la funcionalidad de registro dentro del proceso primario para que el proceso secundario pueda volver a iniciar sesión en él.

Nota: Consulte la sección Registro remoto desde procesos secundarios a continuación para obtener más información sobre el registro remoto.

Registro remoto desde procesos secundarios

WexLogger proporciona la capacidad de que uno o varios procesos secundarios vuelvan a iniciar sesión en un único proceso primario, lo que da lugar a la generación de resultados de pruebas consolidados dentro de un único archivo de registro.

Los procesos secundarios se pueden ejecutar en la misma máquina que el proceso primario o de forma remota en otra máquina. Para que el registro de máquina remota funcione, depende del cliente wexLogger agregar exclusiones de firewall TCP para todos los procesos secundarios en la máquina remota. Sin embargo, si los procesos secundarios se ejecutan en la misma máquina que el elemento primario, no es necesario realizar ninguna modificación del firewall.

Los pasos siguientes son necesarios para configurar cada conexión de registro remoto:

Proceso primario

  1. Llame a RemoteLogController::GenerateConnectionData() para generar los datos de conexión que deben usar ambos procesos para iniciar una conexión de registro.

    Nota: Asegúrese de comprobar el valor devuelto de esta llamada.

        NoThrowString connectionData;
    Throw::IfFailed(RemoteLogController::GenerateConnectionData(connectionData));

  2. Comunique los datos de conexión con el proceso secundario estableciendolos en su bloque de entorno o pasandolos como argumento en el símbolo del sistema. Por ejemplo:

    Pase como argumento con nombre en el símbolo del sistema que WexLogger entiende:
    /wexlogger_connectiondata=[datos de conexión]

    Nota: Si se usa esta opción, el paso 1 de la sección Proceso secundario siguiente no es necesario.

    Pase como una variable de entorno con nombre que WexLogger entiende:
    [YourAppName_cmd]=/wexlogger_connectiondata=[datos de conexión]

    Nota: Si se usa esta opción, el paso 1 de la sección Proceso secundario siguiente no es necesario.

    Pasar al proceso en un formato arbitrario (algún otro parámetro de comando, variable de entorno, etc.)
    Nota: Si se usa esta opción, el paso 1 de la sección Proceso secundario siguiente es necesario.

    Nota: Como comodidad, el valor "/wexlogger_connectiondata=" se define como una constante en remoteLogControllers nativos y administrados:

    • WEX::Logging::c_szWexLoggerRemoteConnectionData, en LogController.h

    • RemoteLogController.WexLoggerRemoteConnectionData, en Wex.Logger.Interop.dll

  3. Iniciar el proceso secundario con los datos de conexión

  4. Llame a RemoteLogController::InitalizeLogging([datos de conexión creados en el paso 1])). Esta llamada se debe realizar después de iniciar el proceso secundario, ya que agotará el tiempo de espera si el elemento secundario no llama a LogController::InitializeLogging() de forma oportuna.

    Nota: Asegúrese de comprobar el valor devuelto de esta llamada.

    // ...launch child process with connection data...
Throw::IfFailed(RemoteLogController::InitializeLogging(connectionData));

  5. Espere en el proceso secundario, etc.

Proceso secundario

  1. Si los datos de conexión no se pasaron al proceso secundario como argumento con nombre en el símbolo del sistema que WexLogger entiende (consulte el paso 2 anterior), debe establecer una variable de entorno como tal:

    [YourAppName_cmd]=/wexlogger_connectiondata=[datos de conexión]

    Por ejemplo:

    // App name is mytestapp.exe
::SetEnvironmentVariable(L"mytestapp_cmd", String(c_szWexLoggerRemoteConnectionData).Append(connectionData));

  2. Llame a LogController::InitializeLogging() para inicializar el registro de este proceso. Internamente, esto aprovechará la variable de entorno establecida en el paso 1 anterior (o en el paso 2 de la sección Proceso primario) para iniciar una conexión de registro al proceso primario.

  3. Registro, etc. todos los seguimientos se devolverán al proceso primario.

  4. Llame a LogController::FinalizeLogging() para finalizar el registro de este proceso.

Determinar el resultado de la prueba

Aunque hay un método proporcionado para indicar explícitamente el resultado previsto de un caso de prueba (Log::Result()), no es necesario que un caso de prueba use este método en la mayoría de los casos.

Por ejemplo, si un caso de prueba no llama explícitamente a Log::Result() y no registra un error (a través de Log::Error()), de forma predeterminada se considera un caso de prueba superada; si registra un error, se trata de un caso de prueba con errores.

Sin embargo, si un caso de prueba llama explícitamente a Log::Result(TestResults::TestPassed),pero también registra un error en el caso de prueba, la prueba seguirá contando como un error porque se produjo un error dentro de la prueba.

Dentro del marco TAEF, este comportamiento se puede invalidar etiquetando la prueba con un resultado de prueba predeterminado diferente. Puede encontrar más información sobre esto en el documento "Creación de pruebas TAEF".

Este comportamiento también se puede invalidar llamando explícitamente a Log::StartGroup() para sus propios grupos de pruebas o casos de prueba, con un resultado de prueba predeterminado de su elección.

Generación de registros WTT

Existen tres métodos para generar registros WTT a través de WexLogger. Todos ellos requieren que WttLog.dll esté presente en el directorio de ejecución o en la ruta de acceso.

  • Si está ejecutando en el laboratorio, con el cliente wtt instalado, los registros de wtt se generarán automáticamente automáticamente. Esto se debe al hecho de que WexLogger busca la existencia de dos variables de entorno que solo deben existir en un entorno de laboratorio: "WttTaskGuid" y "WTTRunWorkingDir". Si existen ambas, el registro de wtt se habilita automáticamente.

  • Si se ejecuta dentro de TAEF fuera de un entorno de laboratorio, pase /enablewttlogging en el símbolo del sistema al caso de prueba. Ejemplo:

    te my.test.dll /enablewttlogging

  • Si está consumiendo WexLogger fuera del marco TAEF y no se ejecuta en un entorno de laboratorio, debe establecer la <variable de entorno YOUR_PROCESS_NAME>_CMD para que contenga esta opción antes de llamar a LogController::InitializeLogging(). Ejemplo:

    Environment.SetEnvironmentVariable("<YOUR_PROCESS_NAME>_CMD", "/enablewttlogging");
LogController.InitializeLogging();

    Environment.SetEnvironmentVariable("consoleapplication4_cmd", "/enablewttlogging");
LogController.InitializeLogging();

  • Si desea anexar a un archivo de registro wtt existente en lugar de sobrescribirlo, especifique también la opción /appendwttlogging además de /enablewttlogging.

    te my.test.dll /enablewttlogging /appendwttlogging

    Environment.SetEnvironmentVariable("<YOUR_PROCESS_NAME>_CMD", "/enablewttlogging /appendwttlogging");
LogController.InitializeLogging();

    Environment.SetEnvironmentVariable("consoleapplication4_cmd", "/enablewttlogging /appendwttlogging");
LogController.InitializeLogging();

También es posible invalidar o anexar completamente a la cadena de dispositivo WttLogger predeterminada especificando una de las siguientes opciones de comando:

/WttDeviceString:<new device string>
Invalida completamente el WttDeviceString usado por WexLogger cuando inicializa WttLogger.

/WttDeviceStringSuffix:<value para anexar a la cadena del dispositivo>
Anexa el valor especificado al WttDeviceString predeterminado usado por WexLogger cuando inicializa WttLogger. Se omite si también se especifica '/WttDeviceString'.

En la tabla siguiente se muestra cómo WexLogger TestResults se asigna a los resultados de WttLogger:

WexLogger WttLogger
Superado WTT_TESTCASE_RESULT_PASS
NotRun WTT_TESTCASE_RESULT_BLOCKED
Omitido WTT_TESTCASE_RESULT_SKIPPED
Bloqueado WTT_TESTCASE_RESULT_BLOCKED
Con error WTT_TESTCASE_RESULT_FAIL

Dependencias del registrador

El registrador nativo de C++ (Wex.Logger.dll) depende de Wex.Common.dll y Wex.Communication.dll.

El registrador administrado (Wex.Logger.Interop.dll) depende de Wex.Logger.dll, Wex.Common.dll y Wex.Communication.dll.

Además, se requiereWttLog.dll cuando se habilita el registro de Wtt.

Datos de error adicionales

En caso de que se registre un error, puede habilitar WexLogger para incluir uno o varios de los siguientes elementos además del propio error:

  • Minivolcado
  • ScreenCapture
  • StackTrace
te my.test.dll /minidumponerror

te my.test.dll /screencaptureonerror /stacktraceonerror

Con una o varias de estas opciones habilitadas, recibirá una salida adicional cada vez que se llama a Log::Error().

Nota: Si está consumiendo WexLogger fuera del marco TAEF, debe establecer la <variable de entorno YOUR_PROCESS_NAME>_CMD para que contenga estas opciones antes de llamar a LogController::InitializeLogging(). Ejemplo:

Environment.SetEnvironmentVariable("<YOUR_PROCESS_NAME>_CMD", "/screencaptureonerror /minidumponerror /stacktraceonerror");
LogController.InitializeLogging();

Environment.SetEnvironmentVariable("consoleapplication4_cmd", "/screencaptureonerror /minidumponerror /stacktraceonerror");
LogController.InitializeLogging();

Control de errores de C++

Para blindar a los autores de casos de prueba de la carga de comprobar los valores devueltos para cada llamada a Log API, WexLogger notifica condiciones de error inesperadas mediante el uso de un mecanismo de devolución de llamada opcional; una función WexLoggerErrorCallback . Tras la inicialización de WexLogger (a través de LogController::InitializeLogging()), los clientes pueden optar por especificar una función WexLoggerErrorCallback para llamar si se producen condiciones de error inesperadas dentro de WexLogger. La función WexLoggerErrorCallback debe usar la siguiente firma:

void __stdcall MyLoggerErrorCallback(const unsigned short* pszMessage, HRESULT hr);

Un uso común de la función WexLoggerErrorCallback sería escribir los mensajes de error en la consola (si el arnés de prueba es una aplicación de consola). Por ejemplo, el marco TAEF es un cliente de WexLogger e implementa un WexLoggerErrorCallback que escribe texto rojo en la consola cuando se producen errores de WexLogger.

Compatibilidad con .NET 4.0

Wex.Logger.Interop se compila como un binario de NetFx 2/3/3.5, de modo que se pueda cargar en procesos de NetFx 2/3/3.5 y NetFx 4. Esto permite a TAEF ejecutar todos los ensamblados administrados por encima de NetFx 2. Si usa Wex.Logger fuera de TAEF, deberá agregar un archivo de configuración para que su exe configure el entorno de ejecución de NetFx 4 para cargar archivos binarios de NetFx 2/3/3.5 en su proceso. El archivo de configuración debe contener lo siguiente:

<configuration> 
    <startup useLegacyV2RuntimeActivationPolicy="true">
        <supportedRuntime version="v4.0"/>
    </startup>
</configuration>

Control de excepciones y errores de código administrado

Para blindar a los autores de casos de prueba de la carga de comprobar los valores devueltos para cada llamada de Log API, la capa administrada de WexLogger notifica condiciones de error inesperadas mediante el uso del evento LoggerController.WexLoggerError . Puede suscribirse a este evento en cualquier momento implementando su propio WexLoggerErrorEventHandler y usando la siguiente sintaxis conocida para la suscripción de eventos de C#:

LogController.WexLoggerError += new WexLoggerEventHandler(My_WexLoggerErrorHandler);

Este es un ejemplo del aspecto que podría tener el controlador de eventos:

static void LogController_WexLoggerError(object sender, WexLoggerErrorEventArgs e)
{
    ConsoleColor originalColor = Console.ForegroundColor;
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine("LogController_WexLoggerError: " + e.Message);
    Console.ForegroundColor = originalColor;
}

Además, los métodos LogController::InitializeLogging() y LogController::FinalizeLogging() inician WexLoggerException en caso de error. Esto proporciona información detallada sobre el error y también le permite anular la ejecución de pruebas antes de comenzar. Los autores de casos de prueba nunca tendrán que preocuparse por detectar estas excepciones; deben esperarse o controlarse solo durante la inicializaiton/finalización de WexLogger.