Verwenden von Microsoft.VisualStudio.TestTools.CppUnitTestFramework

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

Die Headerdateien sind im Ordner VisualStudio2012 [x86] InstallFolderUnitTest VC \ \ \ include.

Die lib-Dateien sind im Ordner VisualStudio2012 [x86] InstallFolderUnitTest VC \ \ \ lib.

In diesem Thema

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

Erstellen Sie Testklassen und Methoden

TEST_CLASS(className)

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

TEST_METHOD(methodName) 
{
    // test method body
}

Definiert methodName als Testmethode.TEST_METHOD muss im Kontext der Methode deklariert werden.

Initialisierungs- und bereinigen Sie

Testmethoden

TEST_METHOD_INITIALIZE(methodName) 
{
    // method initialization code
}

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

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

Definiert methodName als Methode, die ausgeführt wird, wenn eine Testmethode ausgeführt wurde.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 Methode methodName, die ausgeführt wird, wenn ein Modul geladen wird.TEST_MODULE_INITIALIZE kann in einem Testmodul nur einmal definiert werden und muss am Namespacebereich deklariert werden.

TEST_MODULE_CLEANUP(methodName)

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

Erstellen Sie Testattribute

Testmethodenattribute

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

Fügt die Attribute hinzu, die einem oder mehreren TEST_METHOD_ATTRIBUTE Makros der Testmethode testClassName 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 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 einem oder mehreren TEST_MODULE_ATTRIBUTE Makros das Testmodul testModuleName definiert werden.

Ein TEST_MODULE_ATTRIBUTE Makro 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 werden, das oben beschrieben wird.

TEST_OWNER(ownerAlias)

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

TEST_DESCRIPTION(description)

Definiert ein Attribut mit dem Namen Description und dem Attributwert von Beschreibung.

TEST_PRIORITY(priority)

Definiert ein Attribut mit dem Namen Priority und dem Attributwert von Priorität.

TEST_WORKITEM(workitem)

Definiert ein Attribut mit dem Namen WorkItem und dem Attributwert von Arbeitsaufgabe.

TEST_IGNORE()

Definiert ein Attribut mit dem Namen Ignore und dem 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 gleich sind 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, ob zwei Zeichenfolgen gleich sind w_char*

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

Stellen 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 Zeichenfolgen gleich sind nicht char*

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

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

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 gleiche

Überprüfen Sie, ob zwei Verweise auf die gleiche 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 gleich 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, ob 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, ob 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 Sie, ob eine Bedingung wahr ist

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

Die ist falsch

Überprüfen Sie, ob eine Bedingung den Wert False hat

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

Fail

Sie sollten das fehlgeschlagen 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 gleiche

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

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

Stellen 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 gleich 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

Stellen Sie sicher, dass 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)

Stellen Sie sicher, dass 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 für

////////////////////////////////////////////////////////////
/* 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 systemeigenen Code mit dem Test-Explorer

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