Condividi tramite


Informazioni di riferimento sulle API di Microsoft.VisualStudio.TestTools.CppUnitTestFramework

In questo argomento sono elencati i membri pubblici dello spazio dei nomi Microsoft::VisualStudio::CppUnitTestFramework. Usare queste API per scrivere unit test C++ in base a Microsoft Native Unit Test Framework. È disponibile un esempio di utilizzo alla fine dell'argomento.

I file di intestazione e lib si trovano nella <cartella> di installazione di Visual Studio\VC\Auxiliary\VS\UnitTest.

I percorsi dei file di intestazione e lib vengono configurati automaticamente in un progetto di test nativo.

Contenuto dell'argomento

CppUnitTest.h

CppUnitTest.h

Creare classi e metodi di test

TEST_CLASS(className)

Obbligatorio per ogni classe che contiene metodi di test. Identifica className come una 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 nell'ambito della classe del metodo.

Eseguire l'inizializzazione e la pulizia

Metodi di test

TEST_METHOD_INITIALIZE(methodName)
{
    // method initialization code
}

Definisce methodName come un metodo eseguito prima dell'esecuzione di ogni metodo di test. TEST_METHOD_INITIALIZE può essere definito una sola volta in una classe di test e deve essere definito nell'ambito della classe di test.

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

Definisce methodName come un metodo eseguito dopo l'esecuzione di ogni metodo di test. TEST_METHOD_CLEANUP può essere definito una sola volta in una classe di test e deve essere definito nell'ambito della classe di test.

Classi di test

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

Definisce methodName come un metodo eseguito prima della creazione di ogni classe di test. TEST_CLASS_INITIALIZE può essere definito una sola volta in una classe di test e deve essere definito nell'ambito della classe di test.

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

Definisce methodName come un metodo eseguito dopo la creazione di ogni classe di test. TEST_CLASS_CLEANUP può essere definito una sola volta in una classe di test e deve essere definito nell'ambito della classe di test.

Moduli di test

TEST_MODULE_INITIALIZE(methodName)
{
    // module initialization code
}

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

TEST_MODULE_CLEANUP(methodName)

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

Creare attributi di test

Attributi del metodo di test

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

Aggiunge gli attributi definiti con una o più macro TEST_METHOD_ATTRIBUTE al metodo di test testMethodName.

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

Attributi della classe di test

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

Aggiunge gli attributi definiti con una 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 una o più macro TEST_MODULE_ATTRIBUTE al metodo 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 vengono fornite per maggiore praticità nella gestione dei casi comuni. Possono essere sostituire con la macro TEST_METHOD_ATTRIBUTE descritta in precedenza.

TEST_OWNER(ownerAlias)

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

TEST_DESCRIPTION(description)

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

TEST_PRIORITY(priority)

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

TEST_WORKITEM(workitem)

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

TEST_IGNORE()

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

CppUnitTestAssert.h

Asserzioni generali

AreEqual

Verificare che due oggetti siano uguali

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

Verificare che due valori Double siano uguali

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

Verificare che due valori Float siano uguali

static void Assert::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 Assert::AreEqual(
    const char* expected,
    const char* actual,
    bool ignoreCase = false,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Verificare che due stringhe w_char* siano uguali

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

AreNotEqual

Verificare che i due valori Double non siano uguali

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

Verificare che i due valori Float non siano uguali

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

Verificare che due stringhe char* non siano uguali

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

Verificare che due stringhe w_char* non siano uguali

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

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

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

AreSame

Verificare che due riferimenti puntino alla stessa istanza di oggetto (identità).

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

AreNotSame

Verificare che due riferimenti non puntino alla stessa istanza di oggetto (identità).

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

IsNull

Verificare che un puntatore sia NULL.

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

IsNotNull

Verificare che un puntatore non sia NULL

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

IsTrue

Verificare che una condizione sia True

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

IsFalse

Verificare che una condizione sia False

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

Errore

Forza il risultato del test case come non superato

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

Asserzioni di Windows Runtime

AreEqual

Verifica che due puntatori di Windows Runtime siano uguali.

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

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

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

AreSame

Verifica che due riferimenti di Windows Runtime puntino allo stesso oggetto.

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

AreNotEqual

Verifica che due puntatori di Windows Runtime non siano uguali.

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

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

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

AreNotSame

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

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

IsNull

Verifica che un puntatore di Windows Runtime sia un nullptr.

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

IsNotNull

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

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

Asserzioni di eccezione

ExpectException

Verificare che una funzione generi un'eccezione:

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

Verificare che una funzione generi un'eccezione:

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

CppUnitTestLogger.h

Logger

La classe Logger contiene metodi statici per scrivere nella finestra di output.

WriteMessage

Scrivere una stringa nella finestra di output

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

Esempio

Questo codice è un esempio di utilizzo di VSCppUnit. Include esempi di metadati di attributi, fixture, unit test con asserzioni e registrazione personalizzata.

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

Vedi anche