Utilizzo di Microsoft.VisualStudio.TestTools.CppUnitTestFramework

Articolo
03/05/2013

In questo argomento sono elencati i membri pubblici dello spazio dei nomi Microsoft::VisualStudio::CppUnitTestFramework.

I file di intestazione si trovano nella cartella VisualStudio2012[x86]InstallFolder**\VC\UnitTest\include**.

I file lib si trovano nella cartella VisualStudio2012[x86]InstallFolder**\VC\UnitTest\lib**.

In questo argomento

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

Creare le classi e i metodi di test

TEST_CLASS(className)

Richiesto per ogni classe che contiene metodi di test.Identifica className come classe di test.TEST_CLASS deve essere dichiarato nell'ambito dello spazio dei nomi.

TEST_METHOD(methodName) 
{
    // test method body
}

Definisce methodName come metodo di test.TEST_METHOD deve essere dichiarato nella classe del metodo.

Inizializzazione e pulizia

Metodi di test

TEST_METHOD_INITIALIZE(methodName) 
{
    // method initialization code
}

Definisce methodName come metodo da eseguire prima che ogni metodo di test sia eseguito.TEST_METHOD_INITIALIZE può essere definito una sola volta in una classe di test e deve essere definito nella classe di test.

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

Definisce methodName come metodo che viene eseguito dopo ogni metodo di test eseguito.TEST_METHOD_CLEANUP può essere definito una sola volta in una classe di test e deve essere definito nella classe di test.

Classi di test

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

Definisce methodName come metodo che viene eseguito dopo che ogni classe di test viene creata.TEST_CLASS_INITIALIZE può essere definito una sola volta in una classe di test e deve essere definito nella classe di test.

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

Definisce methodName come metodo che viene eseguito dopo che ogni classe di test viene creata.TEST_CLASS_CLEANUP può essere definito una sola volta in una classe di test e deve essere definito nella classe di test.

Moduli di test

TEST_MODULE_INITIALIZE(methodName)
{
    // module initialization code
}

Definisce il metodo methodName eseguito quando un modulo viene caricato.TEST_MODULE_INITIALIZE può essere definito una sola volta in un modulo di test e deve essere dichiarato in ambito dello spazio dei nomi.

TEST_MODULE_CLEANUP(methodName)

Definisce il metodo methodName eseguito quando un modulo viene scaricato.TEST_MODULE_CLEANUP può essere definito una sola volta in un modulo di test e deve essere dichiarato in ambito dello spazio dei nomi.

Creare attributi di test

Attributi di test del metodo

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

Aggiunge gli attributi definiti con uno o più macro TEST_METHOD_ATTRIBUTE al metodo di test testClassName.

Una macro TEST_METHOD_ATTRIBUTE definisce un attributo con il nome attributeName e il valore attributeValue.

Attributi di classe di test

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

Aggiunge gli attributi definiti con uno o più macro TEST_CLASS_ATTRIBUTE alla classe di test testClassName.

Una macro TEST_CLASS_ATTRIBUTE definisce un attributo con il nome attributeName e il valore attributeValue.

Attributi del modulo di test

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

Aggiunge gli attributi definiti con uno o più macro TEST_MODULE_ATTRIBUTE al modulo di test testModuleName.

Una macro TEST_MODULE_ATTRIBUTE definisce un attributo con il nome attributeName e il valore attributeValue.

Attributi predefiniti

Queste macro di attributi predefiniti possono essere sostituite dalle macro TEST_METHOD_ATTRIBUTE, TEST_CLASS_ATTRIBUTE, o TEST_MODULE_ATTRIBUTE descritto in precedenza.

TEST_OWNER(ownerAlias)

Definisce un attributo con il nome Owner e il valore di attributo di ownerAlias.

TEST_DESCRIPTION(description)

Definisce un attributo con il nome Description e il valore di attributo di description.

TEST_PRIORITY(priority)

Definisce un attributo con il nome Priority e il valore di attributo di priority.

TEST_WORKITEM(workitem)

Definisce un attributo con il nome WorkItem e il valore di attributo di workItem.

TEST_IGNORE()

Definisce un attributo con il nome Ignore e il valore di attributo true.

CppUnitTestAssert.h

Asserzioni generali

Sono uguali

Verifica che due oggetti sono uguali

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

Verifica che due double siano uguali

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

Verifica che due float siano uguali

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

Verificare che due stringhe char* siano uguali

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

Verifica che due stringhe di w_char* siano uguali

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

Non sono uguali

Verifica che due double non siano uguali

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

Verifica che due float non siano uguali

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

Verifica che due stringhe char* non siano uguali

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

Verifica che due stringhe di w_char* non siano uguali

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

Verifica che due riferimenti non siano uguali in base all'operatore ==.

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

Sono lo stesso

Verifica che due riferimenti puntano alla stessa istanza di un oggetto (identità).

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

Non sono lo stesso

Verifica che due riferimenti non si riferiscano alla stessa istanza di un oggetto (identità).

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

E' Null.

Verifica che un puntatore sia NULL.

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

Non è Null

Verifica che un puntatore non sia NULL

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

E' true

Verifica che una condizione è true

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

E' false.

Verifica che una condizione è false

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

Fail

Forza il risultato del test case a fallire

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

Asserzioni di Windows Runtime

Sono uguali

Verifica che due puntatori di Windows Runtime siano uguali.

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

Verifica che due stringhe di Platform::String^ siano uguali.

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

Sono lo stesso

Verifica che due riferimenti di Windows Runtime fanno riferimento allo stesso oggetto.

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

Non sono uguali

Verifica che due puntatori di Windows Runtime non siano uguali.

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

Verifica che due stringhe di Platform::String^ non siano uguali.

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

Non sono lo stesso

Verifica che due riferimenti di Windows Runtime non fanno riferimento allo stesso oggetto.

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

E' Null

Verifica che un puntatore di Windows Runtime sia un nullptr.

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

Non è Null

Verifica che un puntatore di Windows Runtime non sia un nullptr.

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

Asserzioni di eccezione

Prevedere un'eccezione

Verifica che una funzione genera un'eccezione:

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

Verifica che una funzione genera un'eccezione:

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

CppUnitTestLogger.h

Logger

La classe logger contiene i metodi statici per scriverci

class Logger

Scrittura del messaggio

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

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

Esempio

Questo è un esempio di codice

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

Vedere anche

Concetti

Verifica del codice tramite unit test

Unit test di codice nativo con Esplora test

Unit test delle applicazioni C++ esistenti con Esplora test

Share via

Utilizzo di Microsoft.VisualStudio.TestTools.CppUnitTestFramework

In questo argomento

CppUnitTest.h

Creare le classi e i metodi di test

Inizializzazione e pulizia

Metodi di test

Classi di test

Moduli di test

Creare attributi di test

Attributi di test del metodo

Attributi di classe di test

Attributi del modulo di test

Attributi predefiniti

CppUnitTestAssert.h

Asserzioni generali

Sono uguali

Non sono uguali

Sono lo stesso

Non sono lo stesso

E' Null.

Non è Null

E' true

E' false.

Fail

Asserzioni di Windows Runtime

Sono uguali

Sono lo stesso

Non sono uguali

Non sono lo stesso

E' Null

Non è Null

Asserzioni di eccezione

Prevedere un'eccezione

CppUnitTestLogger.h

Logger

Scrittura del messaggio

Esempio

Vedere anche

Concetti

Risorse aggiuntive