Utilisation de Microsoft.VisualStudio.TestTools.CppUnitTestFramework
Cette rubrique répertorie les membres publics de l'espace de noms Microsoft::VisualStudio::CppUnitTestFramework.
Les fichiers d'en-tête se trouvent dans le dossier VisualStudio2012[x86]InstallFolder**\VC\UnitTest\include**.
Les fichiers lib se trouvent dans le dossier VisualStudio2012[x86]InstallFolder**\VC\UnitTest\lib**.
Dans cette rubrique
CppUnitTest.h
Créez des classes et des méthodes de test
Initialiser et nettoyage
Méthodes de test
Tester les classes
Tester les modules
Créer des attributs de test
Attributs de méthode de test
Tester les attributs de classe
Tester les attributs de module
Attributs prédéfinis
CppUnitTestAssert.h
Affirmations générales
Sont égaux
Ne sont pas égaux
Sont identiques
Ne sont pas identiques
Est Null
N'est pas null
Est Vrai
Est faux
Échec
Affirmations du runtime windows
Sont égaux
Sont identiques
Ne sont pas égaux
Ne sont pas identiques
Est Null
N'est pas null
Affirmations d'exception
- Attente d'une exception
CppUnitTestLogger.h
Logger
Écrire un message
CppUnitTest.h
Créez des classes et des méthodes de test
TEST_CLASS(className)
Requis pour chaque classe contenant des méthodes de test.Identifie className comme une classe de test.TEST_CLASS doit être déclaré dans la portée du namescape.
TEST_METHOD(methodName)
{
// test method body
}
Définit methodName comme une méthode de test.TEST_METHOD doit être déclaré dans la portée de la méthode de la classe.
Initialiser et nettoyage
Méthodes de test
TEST_METHOD_INITIALIZE(methodName)
{
// method initialization code
}
Définit methodName comme une méthode qui s'exécute avant que chaque méthode de test soit exécutée.TEST_METHOD_INITIALIZE ne peut être définie qu'une seule fois dans une classe de test et doit être défini dans la classe de test.
TEST_METHOD_CLEANUP(methodName)
{
// test method cleanup code
}
Définit methodName comme une méthode qui s'exécute après l'exécution de chaque méthode de test.TEST_METHOD_CLEANUP ne peut être définie qu'une seule fois dans une classe de test et doit être défini dans la portée de la classe de test.
Tester les classes
TEST_CLASS_INITIALIZE(methodName)
{
// test class initialization code
}
Définit methodName comme une méthode qui s'exécute après la création de chaque classe de test.TEST_CLASS_INITIALIZE ne peut être définie qu'une seule fois dans une classe de test et doit être défini dans la portée de la classe de test.
TEST_CLASS_CLEANUP(methodName)
{
// test class cleanup code
}
Définit methodName comme une méthode qui s'exécute après la création de chaque classe de test.TEST_CLASS_CLEANUP ne peut être définie qu'une seule fois dans une classe de test et doit être défini dans la portée de la classe de test.
Tester les modules
TEST_MODULE_INITIALIZE(methodName)
{
// module initialization code
}
Définit la méthode methodName qui fonctionne lorsqu'un module est chargé.TEST_MODULE_INITIALIZE ne peut être défini qu'une fois dans un module de test et doit être déclaré dans la portée de l'espace de noms.
TEST_MODULE_CLEANUP(methodName)
Définit la méthode methodName qui fonctionne lorsqu'un module n'est pas chargé.TEST_MODULE_CLEANUP ne peut être définie qu'une seule fois dans un module de test et doit être défini dans la portée de l'espace de nom.
Créer des attributs de test
Attributs de méthode de test
BEGIN_TEST_METHOD_ATTRIBUTE(testMethodName)
TEST_METHOD_ATTRIBUTE(attributeName, attributeValue)
...
END_TEST_METHOD_ATTRIBUTE()
Ajoute les attributs définis avec une ou plusieurs macros TEST_METHOD_ATTRIBUTE à la méthode de test testClassName.
Une macro TEST_METHOD_ATTRIBUTE définit un attribut par le nom attributeName et la valeur attributeValue.
Tester les attributs de classe
BEGIN_TEST_CLASS_ATTRIBUTE(testClassName)
TEST_CLASS_ATTRIBUTE(attributeName, attributeValue)
...
END_TEST_CLASS_ATTRIBUTE()
Ajoute les attributs définis avec une ou plusieurs macros TEST_CLASS_ATTRIBUTE à la classe de test testClassName.
Une macro TEST_CLASS_ATTRIBUTE définit un attribut par le nom attributeName et la valeur attributeValue.
Tester les attributs de module
BEGIN_TEST_MODULE_ATTRIBUTE(testModuleName)
TEST_MODULE_ATTRIBUTE(attributeName, attributeValue)
...
END_TEST_MODULE_ATTRIBUTE()
Ajoute les attributs définis avec une ou plusieurs macros TEST_MODULE_ATTRIBUTE au module de test testModuleName.
Une macro TEST_MODULE_ATTRIBUTE définit un attribut par le nom attributeName et la valeur attributeValue.
Attributs prédéfinis
Ces macros d'attributs prédéfinies peuvent être substituées pour les macros TEST_METHOD_ATTRIBUTE, TEST_CLASS_ATTRIBUTE, OU TEST_MODULE_ATTRIBUTE décrite ci-dessus.
TEST_OWNER(ownerAlias)
Définit un attribut avec le nom Owner et la valeur d'attribut ownerAlias.
TEST_DESCRIPTION(description)
Définit un attribut avec le nom Description et la valeur d'attribut description.
TEST_PRIORITY(priority)
Définit un attribut avec le nom Priority et la valeur d'attribut priority.
TEST_WORKITEM(workitem)
Définit un attribut avec le nom WorkItem et la valeur d'attribut workItem.
TEST_IGNORE()
Définit un attribut avec le nom Ignore et la valeur d'attribut true.
CppUnitTestAssert.h
Affirmations générales
Sont égaux
Vérifie que deux objets sont égaux
template<typename T>
static void AreEqual(
const T& expected,
const T& actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Vérifie que deux doubles sont égaux
static void AreEqual(
double expected,
double actual,
double tolerance,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Vérifie que deux floats sont égaux
static void AreEqual(
float expected,
float actual,
float tolerance,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Vérifie que deux chaînes char* sont égales
static void AreEqual(
const char* expected,
const char* actual,
bool ignoreCase = false,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Vérifiez que deux chaînes w_char* sont égales
static void AreEqual(
const wchar_t* expected,
const wchar_t* actual,
bool ignoreCase = false,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Ne sont pas égaux
Vérifie que deux doubles ne sont pas égaux
static void AreNotEqual(
double notExpected,
double actual,
double tolerance,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Vérifie que deux floats ne sont pas égaux
static void AreNotEqual(
float notExpected,
float actual,
float tolerance,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Vérifie que deux chaînes char* ne sont pas égales
static void AreNotEqual(
const char* notExpected,
const char* actual,
bool ignoreCase = false,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Vérifiez que deux chaînes w_char* ne sont pas égales
static void AreNotEqual(
const wchar_t* notExpected,
const wchar_t* actual,
bool ignoreCase = false,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Vérifie que deux références ne sont pas égales en fonction de l'operator==.
template<typename T>
static void AreNotEqual(
const T& notExpected,
const T& actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Sont identiques
Vérifie que deux références renvoient à la même instance de l'objet (identité).
template<typename T>
static void AreSame(
const T& expected,
const T& actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Ne sont pas identiques
Vérifie que deux références ne renvoient pas à la même instance de l'objet (identité).
template<typename T>
static void AreNotSame (
const T& notExpected,
const T& actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Est Null
Vérifie qu'un pointeur est NULL.
template<typename T>
static void IsNull(
const T* actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
N'est pas null
Vérifie qu'un pointeur n'est pas NULL
template<typename T>
static void IsNotNull(
const T* actual,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Est Vrai
Vérifie qu'une condition est vraie
static void IsTrue(
bool condition,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Est faux
Vérifie qu'une condition est fausse
static void IsFalse(
bool condition,
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Échec
Force le résultat du cas de test à faux
static void Fail(
const wchar_t* message = NULL,
const __LineInfo* pLineInfo = NULL)
Affirmations du runtime windows
Sont égaux
Vérifie que deux pointeurs d'exécution Windows sont égaux.
template<typename T>
static void AreEqual(
T^ expected,
T^ actual,
Platform::String^ message = nullptr,
const __LineInfo* pLineInfo= nullptr)
Vérifie que deux chaînes de Platform::String^ sont égales.
template<typename T>
static void AreEqual(
T^ expected,
T^ actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Sont identiques
Vérifie que deux références d'exécution windows référencent le même objet.
template<typename T>
static void AreSame(
T% expected,
T% actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Ne sont pas égaux
Vérifie que deux pointeurs d'exécution windows ne sont pas égaux.
template<typename T>
static void AreNotEqual(
T^ notExpected,
T^ actual,
Platform::String^ message = nullptr,
const __LineInfo* pLineInfo= nullptr)
Vérifie que deux chaînes Platform::String^ ne sont pas égales.
static void AreNotEqual(
Platform::String^ notExpected,
Platform::String^ actual,
bool ignoreCase = false,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Ne sont pas identiques
Vérifie que deux références d'exécution windows ne référence pas le même objet.
template<typename T>
static void AreNotSame(
T% notExpected,
T% actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Est Null
Vérifie qu'un pointeur d'exécution windows est un nullptr.
template<typename T>
static void IsNull(
T^ actual,
Platform::String^ message = nullptr,
const __LineInfo* pLineInfo= nullptr)
N'est pas null
Vérifie qu'un pointeur d'exécution windows n'est pas un nullptr.
template<typename T>
static void IsNotNull(
T^ actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Affirmations d'exception
Attente d'une exception
Vérifie qu'une fonction lève une exception :
template<typename _EXPECTEDEXCEPTION, typename _FUNCTOR>
static void ExpectException(
_FUNCTOR functor,
const wchar_t* message= NULL,
const __LineInfo* pLineInfo= NULL)
Vérifie qu'une fonction lève une exception :
template<typename _EXPECTEDEXCEPTION, typename _RETURNTYPE>
static void ExpectException(
_RETURNTYPE (*func)(),
const wchar_t* message= NULL,
const __LineInfo* pLineInfo = NULL)
CppUnitTestLogger.h
Logger
La classe de journalisation contient des méthodes statiques pour écrire
class Logger
Écrire un message
static void
Logger::WriteMessage(const wchar_t* message)
static void
Logger::WriteMessage(const char* message)
Exemple
Ce code est un exemple de
////////////////////////////////////////////////////////////
/* 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");
}
};
Voir aussi
Concepts
Vérification du code à l'aide de tests unitaires
Applications C++ existantes de tests unitaires avec Test Explorer