Usar Microsoft.VisualStudio.TestTools.CppUnitTestFramework

Artículo
02/19/2013

En este tema se enumeran los miembros públicos del espacio de nombres de Microsoft::VisualStudio::CppUnitTestFramework .

Los archivos de encabezado se encuentran en la carpeta VisualStudio2012 [x86] InstallFolder**\ VC \ UnitTest \ include** .

Los archivos lib se encuentran en la carpeta VisualStudio2012 [x86] InstallFolder**\ VC \ UnitTest \ include**.

En este tema

CppUnitTest.h

Crear clases y métodos de prueba
Inicializar y limpiar
- métodos de prueba
- Clases de prueba
- Módulos de prueba
Crear atributos de prueba
- Atributos del método de prueba
- Atributos de la clase de prueba
- Atributos del módulo de pruebas
- Atributos predefinidos
CppUnitTestAssert.h
- Aserciones Generales
  - Son iguales
  - No son iguales a
  - Son iguales
  - No son iguales
  - Es Null.
  - No es Null
  - El valor es de True.
  - Es False.
  - Con errores
- Aserciones de Windows Runtime
  - Son iguales
  - Son iguales
  - No son iguales a
  - No son iguales
  - Es Null.
  - No es Null
- Aserciones de Excepción
  - Espera la excepción
  CppUnitTestLogger.h
  - Logger:
  - Escribir mensaje

CppUnitTest.h

Crear clases y métodos de prueba

TEST_CLASS(className)

Necesario para cada clase que contiene métodos de prueba.Identifica className como clase de prueba.TEST_CLASS se debe declarar en el ámbito de namescape.

TEST_METHOD(methodName) 
{
    // test method body
}

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

Inicializar y limpiar

métodos de prueba

TEST_METHOD_INITIALIZE(methodName) 
{
    // method initialization code
}

Define methodName como un método que se ejecuta antes de que se ejecute cada método de prueba.TEST_METHOD_INITIALIZE sólo se puede definir una vez en una clase de prueba y se debe definir en la clase de prueba.

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

Define methodName como un método que se ejecuta después de que se ejecute cada método de prueba.TEST_METHOD_CLEANUP sólo 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 después de que se crea cada clase de prueba.TEST_CLASS_INITIALIZE sólo 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 crea cada clase de prueba.TEST_CLASS_CLEANUP sólo 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 sólo 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 sólo 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 del método de prueba

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

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

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

Atributos de la 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 TEST_CLASS_ATTRIBUTE a la clase de prueba testClassName.

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

Atributos del módulo de pruebas

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

Agrega los atributos definidos con una o varias macros TEST_MODULE_ATTRIBUTE al modulo de prueba testClassName.

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

Atributos predefinidos

Estas macros de atributo predefinido se pueden sustituir por las macros TEST_METHOD_ATTRIBUTE, TEST_CLASS_ATTRIBUTE, o TEST_MODULE_ATTRIBUTE descritas anteriormente.

TEST_OWNER(ownerAlias)

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

TEST_DESCRIPTION(description)

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

TEST_PRIORITY(priority)

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

TEST_WORKITEM(workitem)

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

TEST_IGNORE()

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

CppUnitTestAssert.h

Aserciones Generales

Son iguales

Compruebe que dos objetos son iguales

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

Compruebe que dos valores double son iguales

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

Comprueba que dos floats sean iguales

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

Compruebe que dos cadenas char* sean iguales

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

Compruebe que dos cadenas w char* sean iguales

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

No son iguales a

Compruebe que dos valores double no son iguales

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

Compruebe que dos valores float no son iguales

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

Compruebe que dos cadenas char* no sean iguales

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

Compruebe que dos cadenas w char* no sean iguales

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

Compruebe que dos referencias no sean iguales basándose en el operator ==.

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

Son iguales

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

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

No son iguales

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

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

Es Null.

Compruebe que un puntero sea NULL.

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

No es Null

Compruebe que un puntero no sea NULL

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

El valor es de True.

Compruebe que una condición sea true

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

Es False.

Compruebe que una condición sea false

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

Con errores

Fuerza el resultado de caso de prueba para que se produzca un error

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

Aserciones de Windows Runtime

Son iguales

Comprueba que dos punteros de Windows Runtime sean iguales.

template<typename T> 
static void 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 AreEqual(
    T^ expected, 
    T^ actual, 
    Platform::String^ message= nullptr, 
    const __LineInfo* pLineInfo= nullptr)

Son iguales

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

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

No son iguales a

Comprueba que dos punteros de Windows Runtime no sean iguales.

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

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

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

No son iguales

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

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

Es Null.

Comprueba que un puntero de Windows Runtime es un nullptr.

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

No es Null

Comprueba que un puntero de Windows Runtime no es un nullptr.

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

Aserciones de Excepción

Espera la excepción

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

template<typename _EXPECTEDEXCEPTION, typename _FUNCTOR> 
static void 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 ExpectException(
    _RETURNTYPE (*func)(), 
    const wchar_t* message= NULL, 
    const __LineInfo* pLineInfo = NULL)

CppUnitTestLogger.h

Logger:

La clase Logger contiene métodos estáticos para escribir

class Logger

Escribir mensaje

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

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

Ejemplo

Este código es un ejemplo de

////////////////////////////////////////////////////////////
/* USAGE EXAMPLE
// The following is an example of VSCppUnit usage.
// It includes examples of attribute metadata, fixtures,
// unit tests with assertions, and custom logging.

#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

Conceptos

Comprobar código utilizando pruebas unitarias

Pruebas unitarias de código nativo con el Explorador de pruebas

Pruebas unitarias de aplicaciones C++ existentes con el Explorador de pruebas

Compartir a través de

Usar Microsoft.VisualStudio.TestTools.CppUnitTestFramework

En este tema

CppUnitTest.h

Crear clases y métodos de prueba

Inicializar y limpiar

métodos de prueba

Clases de prueba

Módulos de prueba

Crear atributos de prueba

Atributos del método de prueba

Atributos de la clase de prueba

Atributos del módulo de pruebas

Atributos predefinidos

CppUnitTestAssert.h

Aserciones Generales

Son iguales

No son iguales a

Son iguales

No son iguales

Es Null.

No es Null

El valor es de True.

Es False.

Con errores

Aserciones de Windows Runtime

Son iguales

Son iguales

No son iguales a

No son iguales

Es Null.

No es Null

Aserciones de Excepción

Espera la excepción

CppUnitTestLogger.h

Logger:

Escribir mensaje

Ejemplo

Vea también

Conceptos

Recursos adicionales