Verwenden von Microsoft.VisualStudio.TestTools.CppUnitTestFramework

In diesem Thema sind die öffentlichen Member des Microsoft::VisualStudio::CppUnitTestFramework-Namespace auf.

Die Headerdateien sind im Ordner VisualStudio2012[x86]InstallFolder**\VC\UnitTest\include**.

Die lib-Dateien sind im Ordner VisualStudio2012[x86]InstallFolder**\VC\UnitTest\lib**.

In diesem Thema

CppUnitTest.h

  • Erstellen Sie Testklassen und Methoden

  • Initialisierungs- und bereinigen

    • Testmethoden

    • Testklassen

    • Testmodule

  • Erstellen Sie Testattribute

    • Testmethodenattribute

    • Testklassenattribute

    • Testmodulattribute

    • Vordefinierte Attribute

    CppUnitTestAssert.h

    • Allgemeine Assertionen

      • Stellen Sie gleich

      • Achten Sie nicht gleich

      • Sind gleich

      • Nicht identisch sind

      • Ist NULL

      • Ist nicht NULL

      • Ist "True"

      • Ist falsch

      • Fail

    • Windows Runtime-Assertionen

      • Stellen Sie gleich

      • Sind gleich

      • Achten Sie nicht gleich

      • Nicht identisch sind

      • Ist NULL

      • Ist nicht NULL

    • Ausnahme-Assertionen

      • Rechnen Sie Ausnahme

      CppUnitTestLogger.h

      • Protokollierung

      • Nachricht schreiben

CppUnitTest.h

Erstellen Sie Testklassen und Methoden

TEST_CLASS(className)

Erforderlich für jede Klasse, Testmethoden enthält.Identifiziert className wie eine Testklasse.TEST_CLASS muss an namescape Gültigkeitsbereich deklariert werden.

TEST_METHOD(methodName) 
{
    // test method body
}

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

Initialisierungs- und bereinigen

Testmethoden

TEST_METHOD_INITIALIZE(methodName) 
{
    // method initialization code
}

Definiert methodName als Methode, die ausgeführt wird, bevor jede Testmethode ausgeführt wird.TEST_METHOD_INITIALIZE kann in einer Testklasse nur einmal definiert werden und in der Testklasse definiert werden.

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

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

Testklassen

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

Definiert methodName als Methode, wird nach jeder Testklasse erstellt wird.TEST_CLASS_INITIALIZE kann in einer Testklasse nur einmal definiert werden und muss im Kontext der Testklasse definiert werden.

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

Definiert methodName als Methode, wird nach jeder Testklasse erstellt wird.TEST_CLASS_CLEANUP kann in einer Testklasse nur einmal definiert werden und muss im Kontext der Testklasse definiert werden.

Testmodule

TEST_MODULE_INITIALIZE(methodName)
{
    // module initialization code
}

Definiert die methodName, die ausgeführt wird, wenn ein Modul geladen wird.TEST_MODULE_INITIALIZE kann in einem Testmodul nur einmal definiert werden und muss am Gültigkeitsbereich deklariert werden.

TEST_MODULE_CLEANUP(methodName)

Definiert die methodName, die ausgeführt wird, wenn ein Modul entladen wird.TEST_MODULE_CLEANUP kann in einem Testmodul nur einmal definiert werden und muss am Gültigkeitsbereich deklariert werden.

Erstellen Sie Testattribute

Testmethodenattribute

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

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

Ein Makro TEST_METHOD_ATTRIBUTE 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 den Attribute hinzu, die einem oder mehreren TEST_CLASS_ATTRIBUTE-Makros der Testklasse testClassName definiert werden.

Ein Makro TEST_CLASS_ATTRIBUTE 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 den Attribute hinzu, die einem oder mehreren TEST_MODULE_ATTRIBUTE-Makros das Testmodul testModuleName definiert werden.

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

Vordefinierte Attribute

Diese vordefinierten Attributmakros können für die Makros TEST_METHOD_ATTRIBUTE, TEST_CLASS_ATTRIBUTE OR TEST_MODULE_ATTRIBUTE ersetzt, das oben beschrieben wird.

TEST_OWNER(ownerAlias)

Definiert ein Attribut mit dem Namen Owner und der Attributwert von ownerAlias.

TEST_DESCRIPTION(description)

Definiert ein Attribut mit dem Namen Description und der Attributwert von description.

TEST_PRIORITY(priority)

Definiert ein Attribut mit dem Namen Priority und der Attributwert von priority.

TEST_WORKITEM(workitem)

Definiert ein Attribut mit dem Namen WorkItem und der Attributwert von workItem.

TEST_IGNORE()

Definiert ein Attribut mit dem Namen Ignore und der Attributwert von true.

CppUnitTestAssert.h

Allgemeine Assertionen

Stellen Sie gleich

Überprüfen Sie, ob zwei Objekte gleich sind

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

Überprüfen Sie, ob zwei double-Werte gleich sind

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

Überprüfen Sie, ob zwei unverankert gleich sind

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

Überprüfen Sie, ob zwei Zeichenfolgen übereinstimmen char*

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

Überprüfen Sie, dass zwei w_char* Zeichenfolgen gleich sind

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

Achten Sie nicht gleich

Überprüfen Sie, ob zwei double-Werte nicht gleich sind

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

Überprüfen Sie, ob zwei unverankert nicht gleich sind

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

Überprüfen Sie, ob zwei char* Zeichenfolgen nicht gleich sind

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

Überprüfen Sie, dass zwei w_char* Zeichenfolgen nicht gleich sind

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

Überprüfen Sie, ob zwei Verweise nicht auf Grundlage operator== gleich sind.

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

Sind gleich

Überprüfen Sie, dass zwei Referenzen über dieselbe Objektinstanz (Identität) verweisen.

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

Nicht identisch sind

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

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

Ist NULL

Überprüfen Sie, dass ein Zeiger NULL ist.

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

Ist nicht NULL

Überprüfen Sie, dass ein Zeiger nicht NULL ist

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

Ist "True"

Überprüfen, ob eine Bedingung zutrifft

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

Ist falsch

Überprüfen, ob eine Bedingung falsch ist

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

Fail

Erzwingen Sie das fehlerhaft werden Testfallergebnis,

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

Windows Runtime-Assertionen

Stellen Sie gleich

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

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

Sind gleich

Überprüft, ob zwei Windows Runtime-Verweise das gleiche Objekt verweisen.

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

Achten Sie nicht gleich

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

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

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

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

Nicht identisch sind

Überprüft, ob zwei Windows Runtime-Verweise nicht das gleiche Objekt verweisen.

template<typename T> 
static void 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 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 IsNotNull(
    T^ actual, 
    Platform::String^ message= nullptr, 
    const __LineInfo* pLineInfo= nullptr)

Ausnahme-Assertionen

Rechnen Sie Ausnahme

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

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

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

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

CppUnitTestLogger.h

Protokollierung

Die Protokollierungsklasse enthält statische Methoden, um zu schreiben

class Logger

Nachricht schreiben

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

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

Beispiel

Dieser Code ist ein Beispiel aus

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

Siehe auch

Konzepte

Überprüfen von Code mithilfe von Komponententests

Ausführen von Komponententests für vorhandene C++-Anwendungen mit dem Test-Explorer

Weitere Ressourcen

Ausführen von Komponententests für systemeigenen Code mit dem Test-Explorer

  • Last updated on