Partager via


Informations de référence sur l’API Microsoft.VisualStudio.TestTools.CppUnitTestFramework

Cette rubrique liste les membres publics de l’espace de noms Microsoft::VisualStudio::CppUnitTestFramework. Utilisez ces API pour écrire des tests unitaires C++ basés sur le framework de tests unitaires natifs Microsoft. Vous pouvez trouver un exemple d’utilisation à la fin de la rubrique.

Les fichiers d’en-tête et de bibliothèque se trouvent à l’emplacement suivant : <dossier d’installation de Visual Studio>\VC\Auxiliary\VS\UnitTest.

Les chemins des fichiers d’en-tête et de bibliothèque sont configurés automatiquement dans un projet de test natif.

Dans cette rubrique

CppUnitTest.h

CppUnitTest.h

Créer des classes et des méthodes de test

TEST_CLASS(className)

Obligatoire pour chaque classe contenant des méthodes de test. Identifie className en tant que classe de test. TEST_CLASS doit être déclaré dans l’étendue de l’espace de noms.

TEST_METHOD(methodName)
{
    // test method body
}

Définit methodName en tant que méthode de test. TEST_METHOD doit être déclaré dans la portée de la classe de la méthode.

Initialiser et nettoyer

Méthodes de test

TEST_METHOD_INITIALIZE(methodName)
{
    // method initialization code
}

Définit methodName en tant que méthode qui s’exécute avant l’exécution de chaque méthode de test. TEST_METHOD_INITIALIZE ne peut être défini qu’une seule fois dans une classe de test et doit être défini dans la portée de la classe de test.

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

Définit methodName en tant que méthode qui s’exécute après l’exécution de chaque méthode de test. TEST_METHOD_CLEANUP ne peut être défini qu’une seule fois dans une classe de test et doit être défini dans la portée de la classe de test.

Classes de test

TEST_CLASS_INITIALIZE(methodName)
{
    // test class initialization  code
}

Définit methodName en tant que méthode qui s’exécute avant la création de chaque classe de test. TEST_CLASS_INITIALIZE ne peut être défini 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 en tant que méthode qui s’exécute après la création de chaque classe de test. TEST_CLASS_CLEANUP ne peut être défini qu’une seule fois dans une classe de test et doit être défini dans la portée de la classe de test.

Modules de test

TEST_MODULE_INITIALIZE(methodName)
{
    // module initialization code
}

Définit la méthode methodName qui s’exécute au moment du chargement d’un module. TEST_MODULE_INITIALIZE ne peut être défini qu’une seule 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 s’exécute au moment du déchargement d’un module. TEST_MODULE_CLEANUP ne peut être défini qu’une seule fois dans un module de test et doit être déclaré dans la portée de l’espace de noms.

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 testMethodName.

Une macro TEST_METHOD_ATTRIBUTE définit un attribut avec le nom attributeName et la valeur attributeValue.

Attributs de classe de test

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 avec le nom attributeName et la valeur attributeValue.

Attributs de module de test

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 avec le nom attributeName et la valeur attributeValue.

Attributs prédéfinis

Ces macros d’attributs prédéfinis sont fournis pour des raisons pratiques pour les cas courants. Ils peuvent être remplacées par la macro TEST_METHOD_ATTRIBUTE décrite ci-dessus.

TEST_OWNER(ownerAlias)

Définit un TEST_METHOD_ATTRIBUTE avec le nom Owner et la valeur d’attribut ownerAlias.

TEST_DESCRIPTION(description)

Définit un TEST_METHOD_ATTRIBUTE avec le nom Description et la valeur d’attribut description.

TEST_PRIORITY(priority)

Définit un TEST_METHOD_ATTRIBUTE avec le nom Priority et la valeur de l’attribut priority.

TEST_WORKITEM(workitem)

Définit un TEST_METHOD_ATTRIBUTE avec le nom WorkItem et la valeur de l’attribut workItem.

TEST_IGNORE()

Définit un TEST_METHOD_ATTRIBUTE avec le nom Ignore et la valeur de l’attribut true.

CppUnitTestAssert.h

Assertions générales

Sont égaux

Vérifie que deux objets sont égaux

template<typename T>
static void Assert::AreEqual(
    const T& expected,
    const T& actual,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Vérifie que deux valeurs double sont égales

static void Assert::AreEqual(
    double expected,
    double actual,
    double tolerance,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Vérifie que deux valeurs float sont égales

static void Assert::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 Assert::AreEqual(
    const char* expected,
    const char* actual,
    bool ignoreCase = false,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Vérifie que deux chaînes w_char* sont égales

static void Assert::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 valeurs double ne sont pas égales

static void Assert::AreNotEqual(
    double notExpected,
    double actual,
    double tolerance,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Vérifie que deux valeurs float ne sont pas égales

static void Assert::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 Assert::AreNotEqual(
    const char* notExpected,
    const char* actual,
    bool ignoreCase = false,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Vérifie que deux chaînes w_char* ne sont pas égales

static void Assert::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 sur la base de l’opérateur ==.

template<typename T>
static void Assert::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 référencent la même instance d’objet (identité).

template<typename T>
static void Assert::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 référencent pas la même instance d’objet (identité).

template<typename T>
static void Assert::AreNotSame (
    const T& notExpected,
    const T& actual,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

A une valeur nulle

Vérifie qu’un pointeur a une valeur NULL.

template<typename T>
static void Assert::IsNull(
    const T* actual,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

N’a pas de valeur nulle

Vérifie qu’un pointeur n’a pas une valeur NULL

template<typename T>
static void Assert::IsNotNull(
    const T* actual,
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Est vrai

Vérifie qu’une condition est vraie

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

Est faux

Vérifie qu’une condition est fausse

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

Échec

Force l’échec du résultat du cas de test

static void Assert::Fail(
    const wchar_t* message = NULL,
    const __LineInfo* pLineInfo = NULL)

Assertions Windows Runtime

Sont égaux

Vérifie que deux pointeurs Windows Runtime sont égaux.

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

Vérifie que deux chaînes Platform::String^ sont égales.

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

Sont identiques

Vérifie que deux références Windows Runtime référencent le même objet.

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

Ne sont pas égaux

Vérifie que deux pointeurs Windows Runtime ne sont pas égaux.

template<typename T>
static void Assert::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 Assert::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 Windows Runtime ne référencent pas le même objet.

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

A une valeur nulle

Vérifie qu’un pointeur Windows Runtime est nullptr.

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

N’a pas de valeur nulle

Vérifie qu’un pointeur Windows Runtime n’est pas nullptr.

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

Assertions d’exception

S’attendre à une exception

Vérifie qu’une fonction lève une exception :

template<typename _EXPECTEDEXCEPTION, typename _FUNCTOR>
static void Assert::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 Assert::ExpectException(
    _RETURNTYPE (*func)(),
    const wchar_t* message= NULL,
    const __LineInfo* pLineInfo = NULL)

CppUnitTestLogger.h

Enregistreur

La classe Logger contient des méthodes statiques pour écrire dans la fenêtre Sortie.

Écrire un message

Écrire une chaîne dans la fenêtre Sortie

static void Logger::WriteMessage(const wchar_t* message)
static void Logger::WriteMessage(const char* message)

Exemple

Ce code est un exemple d’utilisation de VSCppUnit. Il inclut des exemples de métadonnées d’attribut, de fixtures, de tests unitaires avec des assertions et de journalisation personnalisée.

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

Voir aussi