Usando Microsoft.VisualStudio.TestTools.CppUnitTestFramework

Artigo
02/25/2013

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

Os arquivos de cabeçalho estão localizados na pasta de VisualStudio2012 [] InstallFolder xVC \ \ \ UnitTest incluem .

Lib os arquivos estão localizados na pasta de VisualStudio2012 [] InstallFolder xVC \ \ \ UnitTest lib .

Neste tópico

CppUnitTest.h

Create test classes and methods
Initialize and cleanup
- Test methods
- Test classes
- Test modules
Create test attributes
- Test method attributes
- Test class attributes
- Test module attributes
- Pre-defined attributes
CppUnitTestAssert.h
- General Asserts
  - Are Equal
  - Are Not Equal
  - Are Same
  - Are Not Same
  - Is Null
  - Is Not Null
  - Is True
  - Is False
  - Fail
- Windows Runtime Asserts
  - Are Equal
  - Are Same
  - Are Not Equal
  - Are Not Same
  - Is Null
  - Is Not Null
- Exception Asserts
  - Expect Exception
  CppUnitTestLogger.h
  - Logger
  - Write Message

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 de 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 realiza após cada método de teste é 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 que executa após cada classe de teste são criados.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 que executa após cada classe de teste são criados.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 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 declarado no escopo de 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 declarado no escopo de namespace.

Criar atributos de teste

Testar atributos de 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 para o método testClassNamede teste.

Uma macro de 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 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 do 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 de TEST_MODULE_ATTRIBUTE ao 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 pelas macros TEST_METHOD_ATTRIBUTE, TEST_CLASS_ATTRIBUTE, OU 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 descrição.

TEST_PRIORITY(priority)

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

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 que sejam iguais dois dobros

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 é igual

Verifique que não sejam iguais dois dobros

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 iguais

Verifique se duas referências se referirem a mesma instância de 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 iguais

Verifique se duas referências não se referirem a mesma instância de 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 é NULO.

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 é NULO

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

É verdadeiro

Verifique que uma condição seja satisfeita

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

O padrão é falso

Verifique se uma condição é false

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

Falha

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

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

O tempo de execução do windows afirma

É igual

Verifica se dois ponteiros de tempo de execução do windows sejam 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^ sejam iguais.

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

São iguais

Verifica se duas referências de tempo de execução do windows referenciem o mesmo objeto.

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

Não é 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 iguais

Verifica se duas referências de tempo de execução do windows não referenciem o mesmo objeto.

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

é nulo

Verifica que 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 que um ponteiro de tempo de execução do windows não é um nullptr.

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

A exceção afirma

Aguardar a exceção

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

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

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

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

CppUnitTestLogger.h

Registador

A classe de registador contém métodos estáticos para escrever

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 o código usando testes de unidade

Teste de código nativo com Explorer de teste de unidade

Teste aplicativos C++ existentes com o Explorer de teste de unidade

Compartilhar via

Usando Microsoft.VisualStudio.TestTools.CppUnitTestFramework

Neste tópico

CppUnitTest.h

Crie classes e métodos de teste

Inicializar e limpeza

Testar métodos

Classes de teste

Módulos de teste

Criar atributos de teste

Testar atributos de método

Atributos de classe de teste

Atributos do módulo de teste

Atributos predefinidos

CppUnitTestAssert.h

Afirma geral

É igual

Não é igual

São iguais

Não são iguais

é nulo

Não é nulo

É verdadeiro

O padrão é falso

Falha

O tempo de execução do windows afirma

É igual

São iguais

Não é igual

Não são iguais

é nulo

Não é nulo

A exceção afirma

Aguardar a exceção

CppUnitTestLogger.h

Registador

Mensagem de gravação

Exemplo

Consulte também

Conceitos

Recursos adicionais