Freigeben über


Referenz für die API „Microsoft.VisualStudio.TestTools.CppUnitTestFramework“

In diesem Thema werden die öffentlichen Member des Namespace Microsoft::VisualStudio::CppUnitTestFramework aufgeführt. Mit diesen APIs können Sie C++-Komponententests auf Grundlage des nativen Microsoft-Komponententest-Frameworks schreiben. Am Ende des Artikels finden Sie ein Beispiel für die Verwendung.

Die Header- und Bibliotheksdateien befinden sich unter <Visual Studio-Installationsordner>\VC\Auxiliary\VS\UnitTest>.

Header- und Bibliothekspfade werden automatisch in einem nativen Testprojekt konfiguriert.

In diesem Thema

CppUnitTest.h

CppUnitTest.h

Erstellen von Testklassen und Methoden

TEST_CLASS(className)

Erforderlich für jede Klasse, die Testmethoden enthält. Bezeichnet className als Testklasse. TEST_CLASS muss im Gültigkeitsbereich des Namespaces deklariert werden.

TEST_METHOD(methodName)
{
    // test method body
}

Definiert methodName als Testmethode. TEST_METHOD muss im Gültigkeitsbereich der Klasse der Methode deklariert werden.

Initialisieren und Bereinigen

Testmethoden

TEST_METHOD_INITIALIZE(methodName)
{
    // method initialization code
}

Definiert methodName als Methode, die vor jeder Testmethode ausgeführt wird. TEST_METHOD_INITIALIZE kann in einer Testklasse nur einmal definiert werden und muss im Gültigkeitsbereich der Testklasse definiert werden.

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

Definiert methodName als Methode, die nach jeder Testmethode ausgeführt wird. TEST_METHOD_CLEANUP kann in einer Testklasse nur einmal definiert werden und muss im Gültigkeitsbereich der Testklasse definiert werden.

Testklassen

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

Definiert methodName als Methode, die vor dem Erstellen der einzelnen Testklassen ausgeführt wird. TEST_CLASS_INITIALIZE kann in einer Testklasse nur einmal definiert werden und muss im Gültigkeitsbereich der Testklasse definiert werden.

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

Definiert methodName als Methode, die nach dem Erstellen der einzelnen Testmethoden ausgeführt wird. TEST_CLASS_CLEANUP kann in einer Testklasse nur einmal definiert werden und muss im Gültigkeitsbereich der Testklasse definiert werden.

Testmodule

TEST_MODULE_INITIALIZE(methodName)
{
    // module initialization code
}

Definiert die Methode methodName, die beim Laden eines Moduls ausgeführt wird. TEST_MODULE_INITIALIZE kann in einem Testmodul nur einmal definiert werden und muss im Gültigkeitsbereich des Namespace deklariert werden.

TEST_MODULE_CLEANUP(methodName)

Definiert die Methode methodName, die beim Entladen eines Moduls ausgeführt wird. TEST_MODULE_CLEANUP kann in einem Testmodul nur einmal definiert werden und muss im Gültigkeitsbereich des Namespace deklariert werden.

Erstellen von Testattributen

Testmethodenattribut

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

Fügt die Attribute hinzu, die mit einem oder mehreren TEST_METHOD_ATTRIBUTE-Makros der Testmethode testMethodName definiert werden.

Ein TEST_METHOD_ATTRIBUTE-Makro definiert ein Attribut mit dem Namen attributeName und dem Wert attributeValue.

Testklassenattribute

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

Fügt die Attribute hinzu, die mit einem oder mehreren TEST_CLASS_ATTRIBUTE-Makros der Testklasse testClassName definiert werden.

Ein TEST_CLASS_ATTRIBUTE-Makro definiert ein Attribut mit dem Namen attributeName und dem Wert attributeValue.

Testmodulattribute

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

Fügt die Attribute hinzu, die mit einem oder mehreren TEST_MODULE_ATTRIBUTE-Makros der Testmodule testModuleName definiert werden.

Ein TEST_MODULE_ATTRIBUTE-Makro definiert ein Attribut mit dem Namen attributeName und dem Wert attributeValue.

Vordefinierte Attribute

Diese vordefinierten Attributmakros werden für gängige Fälle zur Verfügung gestellt. Sie können durch das oben beschriebene Makro TEST_METHOD_ATTRIBUTE ersetzt werden.

TEST_OWNER(ownerAlias)

Definiert ein TEST_METHOD_ATTRIBUTE mit dem Namen Owner und dem Attributwert ownerAlias.

TEST_DESCRIPTION(description)

Definiert ein TEST_METHOD_ATTRIBUTE mit dem Namen Description und dem Attributwert description.

TEST_PRIORITY(priority)

Definiert ein TEST_METHOD_ATTRIBUTE mit dem Namen Priority und dem Attributwert priority.

TEST_WORKITEM(workitem)

Definiert ein TEST_METHOD_ATTRIBUTE mit dem Namen WorkItem und dem Attributwert workItem.

TEST_IGNORE()

Definiert ein TEST_METHOD_ATTRIBUTE mit dem Namen Ignore und dem Attributwert true.

CppUnitTestAssert.h

Allgemeine Assertionen

Gleich

Überprüft, ob zwei Objekte gleich sind.

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

Überprüft, ob zwei double-Elemente gleich sind.

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

Überprüft, ob zwei float-Elemente gleich sind.

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

Überprüft, ob zwei char*-Zeichenfolgen gleich sind.

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

Überprüft, ob zwei w_char*-Zeichenfolgen gleich sind.

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

Ungleich

Überprüft, ob zwei double-Elemente ungleich sind.

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

Überprüft, ob zwei float-Elemente ungleich sind.

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

Überprüft, ob zwei char*-Zeichenfolgen ungleich sind.

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

Überprüft, ob zwei w_char*-Zeichenfolgen ungleich sind.

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

Überprüft mit operator==, ob zwei Verweise ungleich sind.

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

Stimmen überein

Überprüft, ob zwei Verweise auf dieselbe Objektinstanz (Identität) verweisen.

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

Stimmen nicht überein

Überprüft, ob zwei Verweise nicht auf dieselbe Objektinstanz (Identität) verweisen.

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

Ist Null

Überprüft, ob ein Zeiger NULL ist.

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

Ist nicht Null

Überprüft, ob ein Zeiger nicht NULL ist.

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

Ist TRUE

Überprüft, ob eine Bedingung wahr ist.

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

Ist FALSE

Überprüft, ob eine Bedingung falsch ist.

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

Fehler

Setzt durch, dass das Ergebnis des Testfalls als Fehler zählt.

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

Windows-Runtime-Assertionen

Gleich

Überprüft, ob zwei Windows-Runtime-Zeiger gleich sind.

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

Überprüft, ob zwei Platform::String^-Zeichenfolgen gleich sind.

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

Stimmen überein

Überprüft, ob zwei Windows-Runtime-Verweise auf dasselbe Objekt verweisen.

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

Ungleich

Überprüft, ob zwei Windows-Runtime-Zeiger ungleich sind.

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

Überprüft, ob zwei Platform::String^-Zeichenfolgen ungleich sind.

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

Stimmen nicht überein

Überprüft, ob zwei Windows-Runtime-Verweise nicht auf dasselbe Objekt verweisen.

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

Ist Null

Überprüft, ob ein Windows-Runtime-Zeiger ein „nullptr“ ist.

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

Ist nicht Null

Überprüft, ob ein Windows-Runtime-Zeiger kein „nullptr“ ist.

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

Ausnahme-Assertionen

Ausnahme erwarten

Überprüft, ob eine Funktion eine Ausnahme auslöst:

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

Überprüft, ob eine Funktion eine Ausnahme auslöst:

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

CppUnitTestLogger.h

Protokollierungstool

Die Protokollierungsklasse enthält statische Methoden zum Schreiben in das Ausgabefenster.

Nachricht schreiben

Schreiben einer Zeichenfolge in das Ausgabefenster

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

Beispiel

Dieser Code veranschaulicht, wie Sie „VSCppUnit“ verwenden können. Er enthält Beispiele für Attributmetadaten, Prüfvorrichtungen, Komponententests mit Assertionsanweisungen und benutzerdefiniertem Protokollieren.

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

Siehe auch