Microsoft.VisualStudio.TestTools.CppUnitTestFramework 사용

이 항목에서는 Microsoft::VisualStudio::CppUnitTestFramework 네임스페이스의 public 구성원 목록을 제공합니다.

헤더 파일은 VisualStudio2012[x86]InstallFolder\VC\UnitTest\include 폴더에 있습니다.

lib 파일은 VisualStudio2012[x86]InstallFolder\VC\UnitTest\lib 폴더에 있습니다.

항목 내용

CppUnitTest.h

CppUnitTest.h

테스트 클래스와 메서드 만들기

TEST_CLASS(className)  

테스트 메서드를 포함하는 각 클래스에 필요합니다. className을 테스트 클래스로 식별합니다. 네임스페이스 범위에서 TEST_CLASS를 선언해야 합니다.

TEST_METHOD(methodName)   
{  
    // test method body  
}  

methodName을 테스트 메서드로 정의합니다. 메서드의 클래스 범위에서 TEST_METHOD를 선언해야 합니다.

초기화 및 정리

테스트 메서드

TEST_METHOD_INITIALIZE(methodName)   
{  
    // method initialization code  
}  

각 테스트 메서드를 실행하기 전에 실행되는 메서드로 methodName을 정의합니다. TEST_METHOD_INITIALIZE는 테스트 클래스에서 한 번만 정의할 수 있으며 테스트 클래스에서 정의해야 합니다.

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

각 테스트 메서드를 실행한 후에 실행되는 메서드로 methodName을 정의합니다. TEST_METHOD_CLEANUP은 테스트 클래스에서 한 번만 정의할 수 있으며 테스트 클래스의 범위에서 정의해야 합니다.

테스트 클래스

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

각 테스트 클래스를 만든 후에 실행되는 메서드로 methodName을 정의합니다. TEST_CLASS_INITIALIZE는 테스트 클래스에서 한 번만 정의할 수 있으며 테스트 클래스의 범위에서 정의해야 합니다.

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

각 테스트 클래스를 만든 후에 실행되는 메서드로 methodName을 정의합니다. TEST_CLASS_CLEANUP은 테스트 클래스에서 한 번만 정의할 수 있으며 테스트 클래스의 범위에서 정의해야 합니다.

테스트 모듈

TEST_MODULE_INITIALIZE(methodName)  
{  
    // module initialization code  
}  

모듈을 로드할 때 실행되는 메서드 methodName을 정의합니다. TEST_MODULE_INITIALIZE는 테스트 모듈에서 한 번만 정의할 수 있으며 네임스페이스 범위에서 선언해야 합니다.

TEST_MODULE_CLEANUP(methodName)  

모듈을 언로드할 때 실행되는 메서드 methodName을 정의합니다. TEST_MODULE_CLEANUP은 테스트 모듈에서 한 번만 정의할 수 있으며 네임스페이스 범위에서 선언해야 합니다.

테스트 특성 만들기

테스트 메서드 특성

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

하나 이상의 TEST_METHOD_ATTRIBUTE 매크로로 정의된 특성을 테스트 메서드 testClassName에 추가합니다.

TEST_METHOD_ATTRIBUTE 매크로는 이름 attributeName 및 값 attributeValue를 사용하여 특성을 정의합니다.

테스트 클래스 특성

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

하나 이상의 TEST_CLASS_ATTRIBUTE 매크로로 정의된 특성을 테스트 클래스 testClassName에 추가합니다.

TEST_CLASS_ATTRIBUTE 매크로는 이름 attributeName 및 값 attributeValue를 사용하여 특성을 정의합니다.

테스트 모듈 특성

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

하나 이상의 TEST_MODULE_ATTRIBUTE 매크로로 정의된 특성을 테스트 모듈 testModuleName에 추가합니다.

TEST_MODULE_ATTRIBUTE 매크로는 이름 attributeName 및 값 attributeValue를 사용하여 특성을 정의합니다.

미리 정의된 특성

위에서 설명한 매크로 TEST_METHOD_ATTRIBUTE, TEST_CLASS_ATTRIBUTE 또는 TEST_MODULE_ATTRIBUTE 매크로를 이러한 미리 정의된 특성 매크로로 대체할 수 있습니다.

TEST_OWNER(ownerAlias)  

이름 Owner 및 특성 값 ownerAlias를 사용하여 특성을 정의합니다.

TEST_DESCRIPTION(description)  

이름 Description 및 특성 값 description을 사용하여 특성을 정의합니다.

TEST_PRIORITY(priority)  

이름 Priority 및 특성 값 priority를 사용하여 특성을 정의합니다.

TEST_WORKITEM(workitem)  

이름 WorkItem 및 특성 값 workItem을 사용하여 특성을 정의합니다.

TEST_IGNORE()  

이름 Ignore 및 특성 값 true를 사용하여 특성을 정의합니다.

CppUnitTestAssert.h

일반 어설션

AreEqual

두 개체가 같은지 확인합니다.

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

두 double이 같은지 확인합니다.

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

두 부동이 같은지 확인합니다.

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

두 char* 문자열이 같은지 확인합니다.

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

두 w_char* 문자열이 같은지 확인합니다.

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

AreNotEqual

두 double이 같지 않은지 확인합니다.

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

두 부동이 같지 않은지 확인합니다.

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

두 char* 문자열이 같지 않은지 확인합니다.

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

두 w_char* 문자열이 같지 않은지 확인합니다.

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

operator==를 기준으로 하여 두 참조가 같지 않은지 확인합니다.

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

AreSame

두 참조가 같은 개체 인스턴스(ID)를 참조하는지 확인합니다.

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

AreNotSame

두 참조가 같은 개체 인스턴스(ID)를 참조하지 않는지 확인합니다.

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

IsNull

포인터가 NULL인지 확인합니다.

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

IsNotNull

포인터가 NULL이 아닌지 확인합니다.

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

IsTrue

조건이 true인지 확인합니다.

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

IsFalse

조건이 false인지 확인합니다.

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

Fail

테스트 사례가 실패한 것으로 강제 지정합니다.

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

Windows 런타임 어설션

AreEqual

두 Windows 런타임 포인터가 같은지 확인합니다.

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

두 Platform::String^ 문자열이 같은지 확인합니다.

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

AreSame

두 Windows 런타임 참조가 같은 개체를 참조하는지 확인합니다.

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

AreNotEqual

두 Windows 런타임 포인터가 같지 않은지 확인합니다.

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

두 Platform::String^ 문자열이 같지 않은지 확인합니다.

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

AreNotSame

두 Windows 런타임 참조가 같은 개체를 참조하지 않는지 확인합니다.

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

IsNull

Windows 런타임 포인터가 nullptr인지 확인합니다.

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

IsNotNull

Windows 런타임 포인터가 nullptr이 아닌지 확인합니다.

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

예외 어설션

EXPECTEXCEPTION

함수에서 예외가 발생하는지 확인합니다.

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

함수에서 예외가 발생하는지 확인합니다.

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

CppUnitTestLogger.h

Logger

Logger 클래스는 기록 대상 정적 메서드를 포함합니다.

class Logger  

메시지 작성

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

예제

아래 코드는 이 문서에서 설명한 VSCppUnit 사용법의 예입니다.

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

참고 항목

코드 단위 테스트
테스트 탐색기를 사용하여 네이티브 코드 단위 테스트
기존 C++ 응용 프로그램에 단위 테스트 추가