Referência da API Microsoft.VisualStudio.TestTools.CppUnitTestFramework

Este tópico lista os membros públicos do namespace Microsoft::VisualStudio::CppUnitTestFramework. Use essas APIs para gravar testes de unidade do C++ com base em Microsoft Native Unit Test Framework. Há um Exemplo de Uso no final do tópico.

Os arquivos de cabeçalho e biblioteca ficam na <pasta de instalação do Visual Studio>\VC\Auxiliary\VS\UnitTest.

Caminhos de cabeçalho e lib são configurados automaticamente em um projeto de teste nativo.

Neste tópico

CppUnitTest.h

• Criar classes de teste e métodos

• Inicialização e limpeza

  • Métodos de teste

  • Classes de teste

  • Módulos de teste

• Criar atributos de teste

  • Atributos de método de teste

  • Atributos de classe de teste

  • Atributos de módulo de teste

  • Atributos predefinidos

    CppUnitTestAssert.h

  • Declarações Gerais

    • São iguais

    • Não são iguais

    • São os mesmos

    • Não são os mesmos

    • É nulo

    • Não é nulo

    • É True

    • É False

    • Falha

  • Declarações do Windows Runtime

    • São iguais

    • São os mesmos

    • Não são iguais

    • Não são os mesmos

    • É nulo

    • Não é nulo

  • Declarações de Exceção

    • Exceção de Espera

      CppUnitTestLogger.h

    • Agente

    • Gravar Mensagem

  • Exemplo de uso

CppUnitTest.h

Criar classes de teste e métodos

TEST_CLASS(className)

Necessário para cada classe que contém métodos de teste. Identifica className como uma classe de teste. TEST_CLASS precisa ser declarado no escopo do namespace.

TEST_METHOD(methodName)
{
    // test method body
}

Define methodName como um método de teste. TEST_METHOD deve ser declarado no escopo da classe do método.

Inicialização e limpeza

Métodos de teste

TEST_METHOD_INITIALIZE(methodName)
{
    // method initialization code
}

Define methodName como um método executado antes de cada método de teste ser executado. TEST_METHOD_INITIALIZE só pode ser definido uma vez em uma classe de teste e deve ser definido no escopo da classe de teste.

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

Define methodName como um método executado após de cada método de teste ser executado. TEST_METHOD_CLEANUP só pode ser definido uma vez em uma classe de teste e deve ser definido no escopo da classe de teste.

Classes de teste

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

Define methodName como um método executado após de cada classe de teste ser criada. TEST_CLASS_INITIALIZE só pode ser definido uma vez em uma classe de teste e deve ser definido no escopo da classe de teste.

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

Define methodName como um método executado após de cada classe de teste ser executada. TEST_CLASS_CLEANUP só pode ser definido uma vez em uma classe de teste e deve ser definido no escopo da classe de teste.

Módulos de teste

TEST_MODULE_INITIALIZE(methodName)
{
    // module initialization code
}

Define o método methodName executado quando um módulo é carregado. TEST_MODULE_INITIALIZE só pode ser definido uma vez em um módulo de teste e deve ser declarado no escopo do namespace.

TEST_MODULE_CLEANUP(methodName)

Define o método methodName executado quando um módulo é descarregado. TEST_MODULE_CLEANUP só pode ser definido uma vez em um módulo de teste e deve ser declarado no escopo do namespace.

Criar atributos de teste

Atributos de método de teste

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

Adiciona os atributos definidos com um ou mais macros TEST_METHOD_ATTRIBUTE ao método de teste testMethodName.

Uma macro TEST_METHOD_ATTRIBUTE define um atributo com o nome attributeName e o valor attributeValue.

Atributos de classe de teste

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

Adiciona os atributos definidos com um ou mais macros TEST_CLASS_ATTRIBUTE à classe de teste testClassName.

Uma macro TEST_CLASS_ATTRIBUTE define um atributo com o nome attributeName e o valor attributeValue.

Atributos de módulo de teste

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

Adiciona os atributos definidos com um ou mais macros TEST_MODULE_ATTRIBUTE ao módulo de teste testModuleName.

Uma macro TEST_MODULE_ATTRIBUTE define um atributo com o nome attributeName e o valor attributeValue.

Atributos predefinidos

Essas macros de atributo predefinidas são fornecidas como uma conveniência para casos comuns. Elas podem ser substituídas para a macro TEST_METHOD_ATTRIBUTE descrita acima.

TEST_OWNER(ownerAlias)

Define um TEST_METHOD_ATTRIBUTE com o nome Owner e o valor de atributo de ownerAlias.

TEST_DESCRIPTION(description)

Define um TEST_METHOD_ATTRIBUTE com o nome Description e o valor de atributo de description.

TEST_PRIORITY(priority)

Define um TEST_METHOD_ATTRIBUTE com o nome Priority e o valor de atributo de priority.

TEST_WORKITEM(workitem)

Define um TEST_METHOD_ATTRIBUTE com o nome WorkItem e o valor de atributo de workItem.

TEST_IGNORE()

Define um TEST_METHOD_ATTRIBUTE com o nome Ignore e o valor de atributo de true.

CppUnitTestAssert.h

Declarações Gerais

São iguais

Verifica se dois objetos são iguais

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

Verifica se dois duplos são iguais

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

Verifica se dois floats são iguais

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

Verifica se duas cadeias de caracteres char* são iguais

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

Verifica se duas cadeias de caracteres w_char* são iguais

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

Não são iguais

Verifica se dois duplos não são iguais

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

Verifica se dois floats não são iguais

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

Verifica se duas cadeias de caracteres char* não são iguais

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

Verifica se duas cadeias de caracteres w_char* não são iguais

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

Verifique se duas referências não são iguais com base em operator==.

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

São os mesmos

Verifica se duas referências indicam a mesma instância de objeto (identidade).

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

Não são os mesmos

Verifica se duas referências não indicam a mesma instância de objeto (identidade).

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

É nulo

Verifica se um ponteiro é NULO.

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

Não é nulo

Verifica se um ponteiro não é NULO

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

É verdadeiro

Verifica se uma condição é true

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

É falso

Verifica se uma condição é false

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

Falha

Força a falha do resultado do caso de teste

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

Declarações do Windows Runtime

São iguais

Verifica se dois ponteiros do Windows Runtime são iguais.

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

Verifica se duas cadeias de caracteres Platform::String^ são iguais.

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

São os mesmos

Verifica se duas referências do Windows Runtime referenciam o mesmo objeto.

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

Não são iguais

Verifica se dois ponteiros do Windows Runtime não são iguais.

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

Verifica se duas cadeias de caracteres Platform::String^ não são iguais.

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

Não são os mesmos

Verifica se duas referências do Windows Runtime não referenciam o mesmo objeto.

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

É nulo

Verifica se um ponteiro do Windows Runtime é um nullptr.

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

Não é nulo

Verifica se um ponteiro do Windows Runtime não é um nullptr.

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

Declarações de Exceção

Exceção de Espera

Verifica se uma função gera uma exceção:

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

Verifica se uma função gera uma exceção:

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

CppUnitTestLogger.h

Agente

A classe de agente contém métodos estáticos para gravar na Janela de Saída.

Gravar Mensagem

Gravar uma cadeia de caracteres na Janela de Saída

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

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

Exemplo

Esse código é um exemplo de uso do VSCppUnit. Ele inclui exemplos de metadados de atributo, acessórios, testes de unidade com asserções e registro em log 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");
    }
};

Confira também

• Realizar teste de unidade do seu código
• Escrever testes de unidade para C/C++