Partekatu honen bidez:

Referencia de API Microsoft.VisualStudio.TestTools.CppUnitTestFramework

Este tema se enumeran los miembros públicos de espacio de nombres Microsoft::VisualStudio::CppUnitTestFramework. Use estas API para escribir pruebas unitarias de C++ basadas en el marco de pruebas unitarias de tipo nativo de Microsoft. Al final del tema encontrará un ejemplo de uso.

Los archivos lib y de encabezado se encuentran en la <carpeta de instalación de Visual Studio>\VC\Auxiliary\VS\UnitTest.

Las rutas de acceso de encabezado y biblioteca se configuran automáticamente en un proyecto de prueba nativo.

En este tema

CppUnitTest.h

CppUnitTest.h

Crear clases y métodos de prueba

TEST_CLASS(className)

Se requiere para cada clase que contiene métodos de prueba. Identifica className como una clase de prueba. TEST_CLASS debe declararse en el ámbito de espacio de nombres.

TEST_METHOD(methodName)
{
    // test method body
}

Define methodName como un método de prueba. TEST_METHOD debe declararse en el ámbito de la clase del método.

Inicialización y limpieza

Métodos de prueba

TEST_METHOD_INITIALIZE(methodName)
{
    // method initialization code
}

Define methodName como un método que se ejecuta antes de ejecutar cada método de prueba. TEST_METHOD_INITIALIZE solo se puede definir una vez en una clase de prueba y se debe definir en el ámbito de la clase de prueba.

TEST_METHOD_CLEANUP(methodName)
{
    // test method cleanup  code
}

Define methodName como un método que se ejecuta después de ejecutar cada método de prueba. TEST_METHOD_CLEANUP solo se puede definir una vez en una clase de prueba y se debe definir en el ámbito de la clase de prueba.

Clases de prueba

TEST_CLASS_INITIALIZE(methodName)
{
    // test class initialization  code
}

Define methodName como un método que se ejecuta antes de que se cree cada clase de prueba. TEST_CLASS_INITIALIZE solo se puede definir una vez en una clase de prueba y se debe definir en el ámbito de la clase de prueba.

TEST_CLASS_CLEANUP(methodName)
{
    // test class cleanup  code
}

Define methodName como un método que se ejecuta después de que se cree cada clase de prueba. TEST_CLASS_CLEANUP solo se puede definir una vez en una clase de prueba y se debe definir en el ámbito de la clase de prueba.

Módulos de prueba

TEST_MODULE_INITIALIZE(methodName)
{
    // module initialization code
}

Define el método methodName que se ejecuta cuando se carga un módulo. TEST_MODULE_INITIALIZE solo se puede definir una vez en un módulo de prueba y se debe declarar en el ámbito de espacio de nombres.

TEST_MODULE_CLEANUP(methodName)

Define el método methodName que se ejecuta cuando se descarga un módulo. TEST_MODULE_CLEANUP solo se puede definir una vez en un módulo de prueba y se debe declarar en el ámbito de espacio de nombres.

Crear atributos de prueba

Atributos de método de prueba

BEGIN_TEST_METHOD_ATTRIBUTE(testMethodName)
    TEST_METHOD_ATTRIBUTE(attributeName, attributeValue)
    ...
END_TEST_METHOD_ATTRIBUTE()

Agrega los atributos definidos con una o varias macros de TEST_METHOD_ATTRIBUTE al método de prueba testMethodName.

Una macro de TEST_METHOD_ATTRIBUTE define un atributo con el nombre attributeName y el valor attributeValue.

Atributos de clase de prueba

BEGIN_TEST_CLASS_ATTRIBUTE(testClassName)
    TEST_CLASS_ATTRIBUTE(attributeName, attributeValue)
    ...
END_TEST_CLASS_ATTRIBUTE()

Agrega los atributos definidos con una o varias macros de TEST_CLASS_ATTRIBUTE a la clase de prueba testClassName.

Una macro de TEST_CLASS_ATTRIBUTE define un atributo con el nombre attributeName y el valor attributeValue.

Atributos de módulo de prueba

BEGIN_TEST_MODULE_ATTRIBUTE(testModuleName)
    TEST_MODULE_ATTRIBUTE(attributeName, attributeValue)
    ...
END_TEST_MODULE_ATTRIBUTE()

Agrega los atributos definidos con una o varias macros de TEST_MODULE_ATTRIBUTE al módulo de prueba testModuleName.

Una macro de TEST_MODULE_ATTRIBUTE define un atributo con el nombre attributeName y el valor attributeValue.

Atributos predefinidos

Estas macros de atributo predefinidas se proporcionan para mayor comodidad en los casos comunes. Se pueden sustituir por la macro TEST_METHOD_ATTRIBUTE descrita anteriormente.

TEST_OWNER(ownerAlias)

Define un TEST_METHOD_ATTRIBUTE con el nombre Owner y el valor del atributo de ownerAlias.

TEST_DESCRIPTION(description)

Define un TEST_METHOD_ATTRIBUTE con el nombre Description y el valor del atributo de description.

TEST_PRIORITY(priority)

Define un TEST_METHOD_ATTRIBUTE con el nombre Priority y el valor del atributo de priority.

TEST_WORKITEM(workitem)

Define un TEST_METHOD_ATTRIBUTE con el nombre WorkItem y el valor del atributo de workItem.

TEST_IGNORE()

Define un TEST_METHOD_ATTRIBUTE con el nombre Ignore y el valor del atributo de true.

CppUnitTestAssert.h

Aserciones generales

Son iguales

Comprobar que dos objetos son iguales

template<typename T>
static void Assert::AreEqual(
    const T& expected,
    const T& actual,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Comprobar que dos duplicados son iguales

static void Assert::AreEqual(
    double expected,
    double actual,
    double tolerance,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Comprobar que dos floats son iguales

static void Assert::AreEqual(
    float expected,
    float actual,
    float tolerance,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Comprobar que dos cadenas char* son iguales

static void Assert::AreEqual(
    const char* expected,
    const char* actual,
    bool ignoreCase = false,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Comprobar que dos cadenas w_char* son iguales

static void Assert::AreEqual(
    const wchar_t* expected,
    const wchar_t* actual,
    bool ignoreCase = false,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

No son iguales

Comprobar que dos duplicados no son iguales

static void Assert::AreNotEqual(
    double notExpected,
    double actual,
    double tolerance,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Comprobar que dos floats no son iguales

static void Assert::AreNotEqual(
    float notExpected,
    float actual,
    float tolerance,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Comprobar que dos cadenas char* no son iguales

static void Assert::AreNotEqual(
    const char* notExpected,
    const char* actual,
    bool ignoreCase = false,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Comprobar que dos cadenas w_char* no son iguales

static void Assert::AreNotEqual(
    const wchar_t* notExpected,
    const wchar_t* actual,
    bool ignoreCase = false,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Compruebe si dos referencias son iguales según el operador ==.

template<typename T>
static void Assert::AreNotEqual(
    const T& notExpected,
    const T& actual,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Son los mismos

Compruebe que las dos referencias hacen referencia a la misma instancia de objeto (identidad).

template<typename T>
static void Assert::AreSame(
    const T& expected,
    const T& actual,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

No son los mismos

Compruebe que las dos referencias no hacen referencia a la misma instancia de objeto (identidad).

template<typename T>
static void Assert::AreNotSame (
    const T& notExpected,
    const T& actual,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Es Null

Compruebe que el puntero es NULL.

template<typename T>
static void Assert::IsNull(
    const T* actual,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

No es Null

Compruebe que un puntero no es NULL

template<typename T>
static void Assert::IsNotNull(
    const T* actual,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Es True

Compruebe que una condición es true

static void Assert::IsTrue(
    bool condition,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Es False

Compruebe que una condición es false

static void Assert::IsFalse(
    bool condition,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Suspenso

Fuerce el resultado del caso de prueba a producir un error

static void Assert::Fail(
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Aserciones en Windows Runtime

Son iguales

Comprueba si dos punteros de Windows Runtime son iguales.

template<typename T>
static void Assert::AreEqual(
    T^ expected,
    T^ actual,
    Platform::String^ message = nullptr,
    const __LineInfo* pLineInfo= nullptr)

Comprueba que dos cadenas Platform:: String ^ son iguales.

template<typename T>
static void Assert::AreEqual(
    T^ expected,
    T^ actual,
    Platform::String^ message= nullptr,
    const __LineInfo* pLineInfo= nullptr)

Son los mismos

Comprueba que dos referencias de Windows Runtime hacen referencia al mismo objeto.

template<typename T>
static void Assert::AreSame(
    T% expected,
    T% actual,
    Platform::String^ message= nullptr,
    const __LineInfo* pLineInfo= nullptr)

No son iguales

Comprueba si dos punteros de Windows Runtime no son iguales.

template<typename T>
static void Assert::AreNotEqual(
    T^ notExpected,
    T^ actual,
    Platform::String^ message = nullptr,
    const __LineInfo* pLineInfo= nullptr)

Comprueba que dos cadenas Platform:: String ^ no son iguales.

static void Assert::AreNotEqual(
    Platform::String^ notExpected,
    Platform::String^ actual,
    bool ignoreCase = false,
    Platform::String^ message= nullptr,
    const __LineInfo* pLineInfo= nullptr)

No son los mismos

Comprueba que dos referencias de Windows Runtime no hacen referencia al mismo objeto.

template<typename T>
static void Assert::AreNotSame(
    T% notExpected,
    T% actual,
    Platform::String^ message= nullptr,
    const __LineInfo* pLineInfo= nullptr)

Es Null

Comprueba que un puntero de Windows Runtime es nullptr.

template<typename T>
static void Assert::IsNull(
    T^ actual,
    Platform::String^ message = nullptr,
    const __LineInfo* pLineInfo= nullptr)

No es Null

Comprueba que un puntero de Windows Runtime no es nullptr.

template<typename T>
static void Assert::IsNotNull(
    T^ actual,
    Platform::String^ message= nullptr,
    const __LineInfo* pLineInfo= nullptr)

Aserciones en excepción

Excepción esperada

Compruebe que una función produce una excepción:

template<typename _EXPECTEDEXCEPTION, typename _FUNCTOR>
static void Assert::ExpectException(
    _FUNCTOR functor,
    const wchar_t* message= NULL,
    const __LineInfo* pLineInfo= NULL)

Compruebe que una función produce una excepción:

template<typename _EXPECTEDEXCEPTION, typename _RETURNTYPE>
    static void Assert::ExpectException(
    _RETURNTYPE (*func)(),
    const wchar_t* message= NULL,
    const __LineInfo* pLineInfo = NULL)

CppUnitTestLogger.h

Registrador

La clase Logger contiene métodos estáticos para escribir en la Ventana de salida.

Escribir mensaje

Escribir una cadena en la Ventana de salida

static void Logger::WriteMessage(const wchar_t* message)

static void Logger::WriteMessage(const char* message)

Ejemplo

Este código es un ejemplo de uso de VSCppUnit. Incluye ejemplos de metadatos de atributo, accesorios, pruebas unitarias con aserciones y registro personalizado.

// USAGE EXAMPLE

#include <CppUnitTest.h>

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

BEGIN_TEST_MODULE_ATTRIBUTE()
    TEST_MODULE_ATTRIBUTE(L"Date", L"2010/6/12")
END_TEST_MODULE_ATTRIBUTE()

TEST_MODULE_INITIALIZE(ModuleInitialize)
{
    Logger::WriteMessage("In Module Initialize");
}

TEST_MODULE_CLEANUP(ModuleCleanup)
{
    Logger::WriteMessage("In Module Cleanup");
}

TEST_CLASS(Class1)
{

public:

    Class1()
    {
        Logger::WriteMessage("In Class1");
    }

    ~Class1()
    {
        Logger::WriteMessage("In ~Class1");
    }

    TEST_CLASS_INITIALIZE(ClassInitialize)
    {
        Logger::WriteMessage("In Class Initialize");
    }

    TEST_CLASS_CLEANUP(ClassCleanup)
    {
        Logger::WriteMessage("In Class Cleanup");
    }

    BEGIN_TEST_METHOD_ATTRIBUTE(Method1)
        TEST_OWNER(L"OwnerName")
        TEST_PRIORITY(1)
    END_TEST_METHOD_ATTRIBUTE()

    TEST_METHOD(Method1)
    {
        Logger::WriteMessage("In Method1");
        Assert::AreEqual(0, 0);
    }

    TEST_METHOD(Method2)
    {
        Assert::Fail(L"Fail");
    }
};

Vea también

  • Last updated on