Utilizzo di Microsoft.VisualStudio.TestTools.CppUnitTestFramework
In questo argomento sono elencati i membri pubblici dello spazio dei nomi Microsoft::VisualStudio::CppUnitTestFramework.
I file di intestazione sono contenuti nella cartella di VisualStudio2012[x86]InstallFolder**\ VC \ include \ UnitTest**.
I file lib si trovano nella cartella di VisualStudio2012[x86]InstallFolder**\ VC \ UnitTest \ lib**.
In questo argomento
CppUnitTest.h
Creare le classi e i metodi di test
Inizializzazione e pulizia
Metodi di test
Classi di test
Moduli di test
Creare attributi di test
Attributi di test del metodo
Attributi di classe di test
Attributi del modulo di test
Attributi predefiniti
CppUnitTestAssert.h
Asserzioni generali
Sono uguali
Non sono uguali
Sono lo stesso
Non sono lo stesso
E' Null.
Non è Null
E' true
E' false.
Fail
Asserzioni di Windows Runtime
Sono uguali
Sono lo stesso
Non sono uguali
Non sono lo stesso
E' Null.
Non è Null
Asserzioni di eccezione
- Prevedere un'eccezione
CppUnitTestLogger.h
Logger
Scrittura del messaggio
CppUnitTest.h
Creare le classi e i metodi di test
TEST_CLASS(className)
Richiesto per ogni classe che contiene metodi di test.Identifica className come 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 nella classe del metodo.
Inizializzazione e pulizia
Metodi di test
TEST_METHOD_INITIALIZE(methodName)
{
// method initialization code
}
Definisce methodName come metodo da eseguire prima che ogni metodo di test sia eseguito.TEST_METHOD_INITIALIZE può essere definito una sola volta in una classe di test e deve essere definito nella classe di test.
TEST_METHOD_CLEANUP(methodName)
{
// test method cleanup code
}
Definisce methodName come metodo che viene 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 nella classe di test.
Classi di test
TEST_CLASS_INITIALIZE(methodName)
{
// test class initialization code
}
Definisce methodName come metodo che viene eseguito dopo che ogni classe di test viene creata.TEST_CLASS_INITIALIZE può essere definito una sola volta in una classe di test e deve essere definito nella classe di test.
TEST_CLASS_CLEANUP(methodName)
{
// test class cleanup code
}
Definisce methodName come metodo che viene eseguito dopo che ogni classe di test viene creata.TEST_CLASS_CLEANUP può essere definito una sola volta in una classe di test e deve essere definito nella classe di test.
Moduli di test
TEST_MODULE_INITIALIZE(methodName)
{
// module initialization code
}
Definisce il metodo methodName eseguito quando un modulo viene caricato.TEST_MODULE_INITIALIZE può essere definito una sola volta in un modulo di test e deve essere dichiarato in ambito dello spazio dei nomi.
TEST_MODULE_CLEANUP(methodName)
Definisce il metodo methodName eseguito quando un modulo viene scaricato.TEST_MODULE_CLEANUP può essere definito una sola volta in un modulo di test e deve essere dichiarato in ambito dello spazio dei nomi.
Creare attributi di test
Attributi di test del metodo
BEGIN_TEST_METHOD_ATTRIBUTE(testMethodName)
TEST_METHOD_ATTRIBUTE(attributeName, attributeValue)
...
END_TEST_METHOD_ATTRIBUTE()
Aggiunge gli attributi definiti con uno o più macro TEST_METHOD_ATTRIBUTE al metodo di test testClassName.
Una macro di TEST_METHOD_ATTRIBUTE definisce un attributo con il nome attributeName e il valore attributeValue.
Attributi di classe di test
BEGIN_TEST_CLASS_ATTRIBUTE(testClassName)
TEST_CLASS_ATTRIBUTE(attributeName, attributeValue)
...
END_TEST_CLASS_ATTRIBUTE()
Aggiunge gli attributi definiti con uno o più macro TEST_CLASS_ATTRIBUTE alla classe di test testClassName.
Una macro di 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 uno o più macro TEST_MODULE_ATTRIBUTE al modulo di test testModuleName.
Una macro di TEST_MODULE_ATTRIBUTE definisce un attributo con il nome attributeName e il valore attributeValue.
Attributi predefiniti
Queste macro di attributi predefiniti possono essere sostituite dalle macro TEST_METHOD_ATTRIBUTE, TEST_CLASS_ATTRIBUTE, o TEST_MODULE_ATTRIBUTE descritto in precedenza.
TEST_OWNER(ownerAlias)
Definisce un attributo con il nome Owner e il valore di attributo ownerAlias.
TEST_DESCRIPTION(description)
Definisce un attributo con il nome Description e il valore di attributo description.
TEST_PRIORITY(priority)
Definisce un attributo con il nome Priority e il valore di attributo priority.
TEST_WORKITEM(workitem)
Definisce un attributo con il nome WorkItem e il valore di attributo workItem.
TEST_IGNORE()
Definisce un attributo con il nome Ignore e il valore di attributo true.
CppUnitTestAssert.h
Asserzioni generali
Sono uguali
Verifica che due oggetti sono uguali
template<typename T>
static void AreEqual(
const T& expected,
const T& actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Verifica che due double siano uguali
static void AreEqual(
double expected,
double actual,
double tolerance,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Verifica che due float siano uguali
static void 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 AreEqual(
const char* expected,
const char* actual,
bool ignoreCase = false,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Verifica che due stringhe di w_char* siano uguali
static void AreEqual(
const wchar_t* expected,
const wchar_t* actual,
bool ignoreCase = false,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Non sono uguali
Verifica che due double non siano uguali
static void AreNotEqual(
double notExpected,
double actual,
double tolerance,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Verifica che due float non siano uguali
static void AreNotEqual(
float notExpected,
float actual,
float tolerance,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Verifica che due stringhe char* non siano uguali
static void AreNotEqual(
const char* notExpected,
const char* actual,
bool ignoreCase = false,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Verifica che due stringhe di w_char* non siano uguali
static void AreNotEqual(
const wchar_t* notExpected,
const wchar_t* actual,
bool ignoreCase = false,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Verifica che due riferimenti non siano uguali in base all'operatore ==.
template<typename T>
static void AreNotEqual(
const T& notExpected,
const T& actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Sono lo stesso
Verifica che due riferimenti puntano alla stessa istanza di un oggetto (identità).
template<typename T>
static void AreSame(
const T& expected,
const T& actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Non sono lo stesso
Verifica che due riferimenti non si riferiscano alla stessa istanza di un oggetto (identità).
template<typename T>
static void AreNotSame (
const T& notExpected,
const T& actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
E' Null.
Verifica che un puntatore sia NULL.
template<typename T>
static void IsNull(
const T* actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Non è Null
Verifica che un puntatore non sia NULL
template<typename T>
static void IsNotNull(
const T* actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
E' true
Verifica che una condizione è true
static void IsTrue(
bool condition,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
E' false.
Verifica che una condizione è false
static void IsFalse(
bool condition,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Fail
Forza il risultato del test case a fallire
static void Fail(
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Asserzioni di Windows Runtime
Sono uguali
Verifica che due puntatori di Windows Runtime siano uguali.
template<typename T>
static void AreEqual(
T^ expected,
T^ actual,
Platform::String^ message = nullptr,
const __LineInfo* pLineInfo= nullptr)
Verifica che due stringhe di Platform::String^ siano uguali.
template<typename T>
static void AreEqual(
T^ expected,
T^ actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Sono lo stesso
Verifica che due riferimenti di Windows Runtime fanno riferimento allo stesso oggetto.
template<typename T>
static void AreSame(
T% expected,
T% actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Non sono uguali
Verifica che due puntatori di Windows Runtime non siano uguali.
template<typename T>
static void AreNotEqual(
T^ notExpected,
T^ actual,
Platform::String^ message = nullptr,
const __LineInfo* pLineInfo= nullptr)
Verifica che due stringhe di Platform::String^ non siano uguali.
static void AreNotEqual(
Platform::String^ notExpected,
Platform::String^ actual,
bool ignoreCase = false,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Non sono lo stesso
Verifica che due riferimenti di Windows Runtime non fanno riferimento allo stesso oggetto.
template<typename T>
static void AreNotSame(
T% notExpected,
T% actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
E' Null.
Verifica che un puntatore di Windows Runtime sia un nullptr.
template<typename T>
static void IsNull(
T^ actual,
Platform::String^ message = nullptr,
const __LineInfo* pLineInfo= nullptr)
Non è Null
Verifica che un puntatore di Windows Runtime non sia un nullptr.
template<typename T>
static void IsNotNull(
T^ actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Asserzioni di eccezione
Prevedere un'eccezione
Verifica che una funzione genera un'eccezione:
template<typename _EXPECTEDEXCEPTION, typename _FUNCTOR>
static void ExpectException(
_FUNCTOR functor,
const wchar_t* message= NULL,
const __LineInfo* pLineInfo= NULL)
Verifica che una funzione genera un'eccezione:
template<typename _EXPECTEDEXCEPTION, typename _RETURNTYPE>
static void ExpectException(
_RETURNTYPE (*func)(),
const wchar_t* message= NULL,
const __LineInfo* pLineInfo = NULL)
CppUnitTestLogger.h
Logger
La classe logger contiene i metodi statici per scriverci
class Logger
Scrittura del messaggio
static void
Logger::WriteMessage(const wchar_t* message)
static void
Logger::WriteMessage(const char* message)
Esempio
Questo è un esempio di codice
////////////////////////////////////////////////////////////
/* 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");
}
};
Vedere anche
Concetti
Verifica del codice tramite unit test
Unit test delle applicazioni C++ esistenti con Esplora test