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