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