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 de lib se trouvent dans le dossier VisualStudio2012[x86]InstallFolder**\VC\UnitTest \ lib** .

Dans cette rubrique

CppUnitTest.h

Create test classes and methods
Initialize and cleanup
- Test methods
- Test classes
- Test modules
Create test attributes
- Test method attributes
- Test class attributes
- Test module attributes
- Pre-defined attributes
CppUnitTestAssert.h
- General Asserts
  - Are Equal
  - Are Not Equal
  - Are Same
  - Are Not Same
  - Is Null
  - Is Not Null
  - Is True
  - Is False
  - Fail
- Windows Runtime Asserts
  - Are Equal
  - Are Same
  - Are Not Equal
  - Are Not Same
  - Is Null
  - Is Not Null
- Exception Asserts
  - Expect Exception
  CppUnitTestLogger.h
  - Logger
  - Write 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 nom de classe comme classe de test.TEST_CLASS doit être déclaré dans la portée du namescape.

TEST_METHOD(methodName) 
{
    // test method body
}

Définit NomDeMéthode comme 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 NomDeMéthode comme 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 NomDeMéthode comme méthode qui s'exécute après que chaque méthode de test soit exécutée.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 NomDeMéthode comme méthode qui s'exécute après que chaque classe de test soit créée.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 NomDeMéthode comme méthode qui s'exécute après que chaque classe de test soit créée.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 NomDeMéthode 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 NomDeMéthode qui fonctionne lorsqu'un module est dé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 avec 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 avec 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 avec 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 de ownerAlias.

TEST_DESCRIPTION(description)

Définit un attribut avec le nom Description et la valeur d'attribut de description.

TEST_PRIORITY(priority)

Définit un attribut avec le nom Priority et la valeur d'attribut de priorité.

TEST_WORKITEM(workitem)

Définit un attribut avec le nom WorkItem et la valeur d'attribut de 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 les mêmes

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 les mêmes

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

Tests unitaires du code natif avec Test Explorer

Applications C++ existantes de tests unitaires avec Test Explorer

Last updated on 2013-03-04

Utilisation de Microsoft.VisualStudio.TestTools.CppUnitTestFramework

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 les mêmes

Ne sont pas égaux

Ne sont pas les mêmes

Est Null

N'est pas Null

Affirmations d'exception

Attente d'une exception

CppUnitTestLogger.h

Logger

Écrire un message

Exemple

Voir aussi

Concepts

Ressources supplémentaires