Udostępnij za pośrednictwem

Korzystanie z Microsoft.VisualStudio.TestTools.CppUnitTestFramework

  • Artykuł

Ten temat zawiera listę publicznych elementów członkowskich przestrzeni nazw Microsoft::VisualStudio::CppUnitTestFramework.

Pliki nagłówków znajdują się w folderze VisualStudio2012[x86]InstallFolder**\VC\UnitTest\include**.

Pliki lib znajdują się w folderze VisualStudio2012[x86]InstallFolder**\VC\UnitTest\lib**.

W tym temacie

CppUnitTest.h

  • Tworzenie klas i metod testowych

  • Inicjowanie i oczyszczanie

    • Metody testowe

    • Klasy testowe

    • Moduły testowe

  • Tworzenie atrybutów testowych

    • Atrybuty metody testowej

    • Atrybuty klasy testowej

    • Atrybuty modułów testowych

    • Wstępnie zdefiniowane atrybuty

    CppUnitTestAssert.h

    • Potwierdzenia ogólne

      • Są równe

      • Nie są równe

      • Są tym samym

      • Nie są tym samym

      • Ma wartość null

      • Nie jest wartością null

      • Jest prawdą

      • Jest fałszem

      • Zakończ niepowodzeniem

    • Potwierdzenia środowiska wykonawczego systemu Windows

      • Są równe

      • Są tym samym

      • Nie są równe

      • Nie są tym samym

      • Ma wartość null

      • Nie jest wartością null

    • Potwierdzenia wyjątków

      • Oczekiwany wyjątek

      CppUnitTestLogger.h

      • Rejestrator

      • Zapisz wiadomość

CppUnitTest.h

Tworzenie klas i metod testowych

TEST_CLASS(className)

Wymagane dla każdej klasy zawierającej metody testowe.Identyfikuje className jako klasę testową.TEST_CLASS musi być zadeklarowana w zakresie obszaru nazw.

TEST_METHOD(methodName) 
{
    // test method body
}

Definiuje methodName jako metodę testową.TEST_METHOD musi być zadeklarowana w zakresie klasy metody.

Inicjowanie i oczyszczanie

Metody testowe

TEST_METHOD_INITIALIZE(methodName) 
{
    // method initialization code
}

Definiuje methodName jako metodę, która jest uruchamiana przed uruchomieniem każdej metody testowej.TEST_METHOD_INITIALIZE można zdefiniować tylko raz w klasie testowej i musi być zdefiniowana w klasie testowej.

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

Definiuje methodName jako metodę, która jest uruchamiana po każdej metodzie testowej.TEST_METHOD_CLEANUP można zdefiniować tylko raz w klasie testowej i musi być zdefiniowana w zakresie klasy testowej.

Klasy testowe

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

Definiuje methodName jako metodę, która jest uruchamiana po utworzeniu każdej klasy testowej.TEST_CLASS_INITIALIZE można zdefiniować tylko raz w klasie testowej i musi być zdefiniowana w zakresie klasy testowej.

TEST_CLASS_CLEANUP(methodName) 
{
    // test class cleanup  code
}

Definiuje methodName jako metodę, która jest uruchamiana po utworzeniu każdej klasy testowej.TEST_CLASS_CLEANUP można zdefiniować tylko raz w klasie testowej i musi być zdefiniowana w zakresie klasy testowej.

Moduły testowe

TEST_MODULE_INITIALIZE(methodName)
{
    // module initialization code
}

Definiuje metodę methodName, która jest uruchamiana, gdy moduł jest załadowany.TEST_MODULE_INITIALIZE można zdefiniować tylko raz w module testowym i musi być zadeklarowana w zakresie przestrzeni nazw.

TEST_MODULE_CLEANUP(methodName)

Definiuje metodę methodName, która jest uruchamiana, gdy moduł zostanie zwolniony.TEST_MODULE_CLEANUP można zdefiniować tylko raz w module testowym i musi być zadeklarowana w zakresie przestrzeni nazw.

Tworzenie atrybutów testowych

Atrybuty metody testowej

BEGIN_TEST_METHOD_ATTRIBUTE(testMethodName) 
    TEST_METHOD_ATTRIBUTE(attributeName, attributeValue)
    ...
END_TEST_METHOD_ATTRIBUTE()

Dodaje atrybuty zdefiniowane z jednym lub wieloma makrami TEST_METHOD_ATTRIBUTE do metody testowej testClassName.

Makro TEST_METHOD_ATTRIBUTE określa atrybut o nazwie attributeName i wartość attributeValue.

Atrybuty klasy testowej

BEGIN_TEST_CLASS_ATTRIBUTE(testClassName) 
    TEST_CLASS_ATTRIBUTE(attributeName, attributeValue)
    ...
END_TEST_CLASS_ATTRIBUTE()

Dodaje atrybuty zdefiniowane z jednym lub wieloma makrami TEST_CLASS_ATTRIBUTE do klasy testowej testClassName.

Makro TEST_CLASS_ATTRIBUTE określa atrybut o nazwie attributeName i wartość attributeValue.

Atrybuty modułów testowych

BEGIN_TEST_MODULE_ATTRIBUTE(testModuleName) 
    TEST_MODULE_ATTRIBUTE(attributeName, attributeValue)
    ...
END_TEST_MODULE_ATTRIBUTE()

Dodaje atrybuty zdefiniowane z jednym lub wieloma makrami TEST_MODULE_ATTRIBUTE do modułu testowego testModuleName.

Makro TEST_MODULE_ATTRIBUTE określa atrybut o nazwie attributeName i wartość attributeValue.

Wstępnie zdefiniowane atrybuty

Makra atrybutów predefiniowanych mogą zastąpić makra TEST_METHOD_ATTRIBUTE, TEST_CLASS_ATTRIBUTE, lub TEST_MODULE_ATTRIBUTE opisane powyżej.

TEST_OWNER(ownerAlias)

Określa atrybut o nazwie Owner i wartość atrybutu ownerAlias.

TEST_DESCRIPTION(description)

Określa atrybut o nazwie Description i wartość atrybutu description.

TEST_PRIORITY(priority)

Określa atrybut o nazwie Priority i wartość atrybutu priority.

TEST_WORKITEM(workitem)

Określa atrybut o nazwie WorkItem i wartość atrybutu workItem.

TEST_IGNORE()

Określa atrybut o nazwie Ignore i wartość atrybutu true.

CppUnitTestAssert.h

Potwierdzenia ogólne

Są równe

Sprawdź, czy dwa obiekty są równe

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

Sprawdź, czy dwie wartości double są równe

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

Sprawdź, czy dwie wartości float są równe

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

Sprawdź, czy dwa ciągi znaków char* są równe

static void AreEqual(
    const char* expected, 
    const char* actual, 
    bool ignoreCase = false, 
    const wchar_t* message = NULL, 
    const __LineInfo* pLineInfo = NULL)

Sprawdź, czy dwa ciągi znaków w_char* są równe

static void AreEqual(
    const wchar_t* expected, 
    const wchar_t* actual, 
    bool ignoreCase = false, 
    const wchar_t* message = NULL, 
    const __LineInfo* pLineInfo = NULL)

Nie są równe

Sprawdź, czy dwie wartości double nie są równe

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

Sprawdź, czy dwie wartości float nie są równe

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

Sprawdź, czy dwa ciągi znaków char* nie są równe

static void AreNotEqual(
    const char* notExpected, 
    const char* actual, 
    bool ignoreCase = false, 
    const wchar_t* message = NULL, 
    const __LineInfo* pLineInfo = NULL)

Sprawdź, czy dwa ciągi znaków w_char* nie są równe

static void AreNotEqual(
    const wchar_t* notExpected, 
    const wchar_t* actual, 
    bool ignoreCase = false, 
    const wchar_t* message = NULL, 
    const __LineInfo* pLineInfo = NULL)

Sprawdź, czy dwa odwołania nie są równe, na podstawie operator==.

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

Są tym samym

Zweryfikuj, czy dwa odwołania odnoszą się do tego samego wystąpienia obiektu (tożsamość).

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

Nie są tym samym

Zweryfikuj, czy dwa odwołania nie odnoszą się do tego samego wystąpienia obiektu (tożsamość).

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

Ma wartość null

Sprawdź, czy wskaźnik jest NULL.

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

Nie jest wartością null

Sprawdź, czy wskaźnik nie jest NULL

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

Jest prawdą

Sprawdź, czy warunek jest spełniony

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

Jest fałszem

Sprawdź, czy warunek jest fałszywy

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

Zakończ niepowodzeniem

Zmusza do zakończenia przypadku testowego niepowodzeniem

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

Potwierdzenia środowiska wykonawczego systemu Windows

Są równe

Weryfikuje, czy dwa wskaźniki środowiska wykonawczego systemu Windows są równe.

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

Weryfikuje, czy dwa ciągi znaków Platform::String^ są równe.

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

Są tym samym

Weryfikuje, czy dwa odwołania środowiska wykonawczego systemu Windows odwołują się do tego samego obiektu.

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

Nie są równe

Weryfikuje, czy dwa wskaźniki środowiska wykonawczego systemu Windows nie są równe.

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

Weryfikuje, czy dwa ciągi znaków Platform::String^ nie są równe.

static void AreNotEqual(
    Platform::String^ notExpected, 
    Platform::String^ actual, 
    bool ignoreCase = false, 
    Platform::String^ message= nullptr, 
    const __LineInfo* pLineInfo= nullptr)

Nie są tym samym

Weryfikuje, czy dwa odwołania środowiska wykonawczego systemu Windows odwołują się do tego samego obiektu.

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

Ma wartość null

Weryfikuje, czy wskaźnik środowiska wykonawczego systemu Windows jest nullptr.

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

Nie jest wartością null

Weryfikuje, czy wskaźnik środowiska wykonawczego systemu Windows nie jest nullptr.

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

Potwierdzenia wyjątków

Oczekiwany wyjątek

Zweryfikuj, że funkcja wywołuje wyjątek:

template<typename _EXPECTEDEXCEPTION, typename _FUNCTOR> 
static void ExpectException(
    _FUNCTOR functor, 
    const wchar_t* message= NULL, 
    const __LineInfo* pLineInfo= NULL)

Zweryfikuj, że funkcja wywołuje wyjątek:

template<typename _EXPECTEDEXCEPTION, typename _RETURNTYPE> 
    static void ExpectException(
    _RETURNTYPE (*func)(), 
    const wchar_t* message= NULL, 
    const __LineInfo* pLineInfo = NULL)

CppUnitTestLogger.h

Rejestrator

Klasa rejestratora zawiera metody statyczne do zapisu

class Logger

Zapisz wiadomość

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

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

Przykład

Ten kod jest przykładem

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

Zobacz też

Koncepcje

Weryfikowanie kodu przy użyciu testów jednostkowych

Testy jednostkowe istniejących aplikacji C++ za pomocą narzędzia Eksplorator testów

Inne zasoby

Testy jednostkowe kodu natywnego za pomocą narzędzia Eksplorator testów