Compartilhar via

Usando Microsoft.VisualStudio.TestTools.CppUnitTestFramework

  • Artigo

Este tópico lista os membros públicos de namespace de Microsoft::VisualStudio::CppUnitTestFramework .

Os arquivos de cabeçalho são localizados na pasta de VisualStudio2012[x86]InstallFolder**\ \ \ UnitTest incluem VC** .

Os arquivos de biblioteca estão localizados na pasta de VisualStudio2012[x86]InstallFolderVC \ \ \ UnitTest biblioteca .

Neste tópico

CppUnitTest.h

  • Crie classes e métodos de teste

  • Inicializar e limpeza

    • Métodos de teste

    • Classes de teste

    • Módulos de teste

  • Crie atributos de teste

    • Atributos do método de teste

    • Atributos da classe de teste

    • Atributos de módulo de teste

    • Atributos predefinidos

    CppUnitTestAssert.h

    • Afirma geral

      • É igual

      • Não seja igual

      • São os mesmos

      • Não são os mesmos

      • É nulo

      • Não é nulo

      • É true

      • É false

      • Falha

    • Tempo de Execução do Windows afirma

      • É igual

      • São os mesmos

      • Não seja igual

      • Não são os mesmos

      • É nulo

      • Não é nulo

    • A exceção afirma

      • Aguarde a exceção

      CppUnitTestLogger.h

      • Registrador

      • Mensagem de gravação

CppUnitTest.h

Crie classes e métodos de teste

TEST_CLASS(className)

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

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.

Inicializar e limpeza

Testar métodos

TEST_METHOD_INITIALIZE(methodName) 
{
    // method initialization code
}

Define methodName como um método que executa antes que 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 na classe de teste.

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

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

Classes de teste

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

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

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

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

Módulos de teste

TEST_MODULE_INITIALIZE(methodName)
{
    // module initialization code
}

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

TEST_MODULE_CLEANUP(methodName)

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

Crie atributos de teste

Testar atributos do método

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

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

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

Atributos da 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 TEST_CLASS_ATTRIBUTE macros da classe testClassNamede teste.

Uma macro de 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 TEST_MODULE_ATTRIBUTE macros do módulo testModuleNamede teste.

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

Atributos predefinidos

Esses macros predefinidos de atributo podem ser substituídos para macros TEST_METHOD_ATTRIBUTE, TEST_CLASS_ATTRIBUTE, OR TEST_MODULE_ATTRIBUTE descrito acima.

TEST_OWNER(ownerAlias)

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

TEST_DESCRIPTION(description)

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

TEST_PRIORITY(priority)

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

TEST_WORKITEM(workitem)

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

TEST_IGNORE()

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

CppUnitTestAssert.h

Afirma geral

É igual

Verifique se dois objetos são iguais

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

Verifique se dois duplas são iguais

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

Verifique se dois flutuadores sejam iguais

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

Verifique se duas cadeias de caracteres de char* sejam iguais

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

Verifique se duas cadeias de caracteres de w_char* sejam iguais

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

Não seja igual

Verifique se dois duplas não sejam iguais

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

Verifique se dois flutuadores não sejam iguais

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

Verifique se duas cadeias de caracteres de char* não sejam iguais

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

Verifique se duas cadeias de caracteres de w_char* não sejam iguais

static void 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 sejam iguais com base no operator==.

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

São os mesmos

Verifique se duas referências se refere à mesma instância do objeto (identidade).

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

Não são os mesmos

Verifique se duas referências não se refere à mesma instância do objeto (identidade).

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

É nulo

Verifique se um ponteiro será NULL.

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

Não é nulo

Verifique se um ponteiro não é NULL

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

É true

Verifique se uma condição seja verdadeira

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

É false

Verifique se uma condição seja falsa

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

Falha

Forçar o resultado da situação de teste para ser falha

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

Tempo de Execução do Windows afirma

É igual

Verifica se dois ponteiros de Tempo de Execução do Windows são iguais.

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

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

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

São os mesmos

Verifica se duas referências de Tempo de Execução do Windows façam referência ao mesmo objeto.

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

Não seja igual

Verifica se dois ponteiros de Tempo de Execução do Windows não sejam iguais.

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

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

static void 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 de Tempo de Execução do Windows não faz referência ao mesmo objeto.

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

É nulo

Verifica se um ponteiro de Tempo de Execução do Windows é um nullptr.

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

Não é nulo

Verifica se um ponteiro de Tempo de Execução do Windows não seja um nullptr.

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

A exceção afirma

Aguarde a exceção

Verificando se uma função gerar uma exceção:

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

Verificando se uma função gerar uma exceção:

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

CppUnitTestLogger.h

Registrador

A classe do registrador contém métodos estáticos para gravação

class Logger

Mensagem de gravação

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

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

Exemplo

Este é um exemplo de código

////////////////////////////////////////////////////////////
/* 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");
    }
};

Consulte também

Conceitos

Verificando código usando testes de unidade

Testes de unidade de aplicativos do C++ existentes com Gerenciador de Testes

Outros recursos

Código nativo de testes de unidade com Gerenciador de Testes