Using Microsoft.VisualStudio.TestTools.CppUnitTestFramework
The new home for Visual Studio documentation is Visual Studio 2017 Documentation on docs.microsoft.com.
The latest version of this topic can be found at Using Microsoft.VisualStudio.TestTools.CppUnitTestFramework.
This topic lists the public members of the Microsoft::VisualStudio::CppUnitTestFramework namespace.
The header files are located in the VisualStudio2012[x86]InstallFolder\VC\UnitTest\include folder.
The lib files are located in the VisualStudio2012[x86]InstallFolder\VC\UnitTest\lib folder.
Create test classes and methods
TEST_CLASS(className)
Required for each class containing test methods. Identifies className as a test class. TEST_CLASS must be declared at namescape scope.
TEST_METHOD(methodName)
{
// test method body
}
Defines methodName as a test method. TEST_METHOD must be declared in the scope of the method's class.
Initialize and cleanup
Test methods
TEST_METHOD_INITIALIZE(methodName)
{
// method initialization code
}
Defines methodName as a method that runs before each test method is run. TEST_METHOD_INITIALIZE can only be defined once in a test class and must be defined in the test class.
TEST_METHOD_CLEANUP(methodName)
{
// test method cleanup code
}
Defines methodName as a method that runs after each test method is run. TEST_METHOD_CLEANUP can only be defined once in a test class and must be defined in the scope of the test class.
Test classes
TEST_CLASS_INITIALIZE(methodName)
{
// test class initialization code
}
Defines methodName as a method that runs after each test class is created. TEST_CLASS_INITIALIZE can only be defined once in a test class and must be defined in the scope of the test class.
TEST_CLASS_CLEANUP(methodName)
{
// test class cleanup code
}
Defines methodName as a method that runs after each test class is created. TEST_CLASS_CLEANUP can only be defined once in a test class and must be defined in the scope of the test class.
Test modules
TEST_MODULE_INITIALIZE(methodName)
{
// module initialization code
}
Defines the method methodName that runs when a module is loaded. TEST_MODULE_INITIALIZE can only be defined once in a test module and must be declared at namespace scope.
TEST_MODULE_CLEANUP(methodName)
Defines the method methodName that runs when a module is unloaded. TEST_MODULE_CLEANUP can only be defined once in a test module and must be declared at namespace scope.
Create test attributes
Test method attributes
BEGIN_TEST_METHOD_ATTRIBUTE(testMethodName)
TEST_METHOD_ATTRIBUTE(attributeName, attributeValue)
...
END_TEST_METHOD_ATTRIBUTE()
Adds the attributes defined with one or more TEST_METHOD_ATTRIBUTE macros to the test method testClassName.
A TEST_METHOD_ATTRIBUTE macro defines an attribute with the name attributeName and the value attributeValue.
Test class attributes
BEGIN_TEST_CLASS_ATTRIBUTE(testClassName)
TEST_CLASS_ATTRIBUTE(attributeName, attributeValue)
...
END_TEST_CLASS_ATTRIBUTE()
Adds the attributes defined with one or more TEST_CLASS_ATTRIBUTE macros to the test class testClassName.
A TEST_CLASS_ATTRIBUTE macro defines an attribute with the name attributeName and the value attributeValue.
Test module attributes
BEGIN_TEST_MODULE_ATTRIBUTE(testModuleName)
TEST_MODULE_ATTRIBUTE(attributeName, attributeValue)
...
END_TEST_MODULE_ATTRIBUTE()
Adds the attributes defined with one or more TEST_MODULE_ATTRIBUTE macros to the test module testModuleName.
A TEST_MODULE_ATTRIBUTE macro defines an attribute with the name attributeName and the value attributeValue.
Pre-defined attributes
These pre-defined attribute macros can be substituted for the macros TEST_METHOD_ATTRIBUTE, TEST_CLASS_ATTRIBUTE, OR TEST_MODULE_ATTRIBUTE described above.
TEST_OWNER(ownerAlias)
Defines an attribute with the name Owner and the attribute value of ownerAlias.
TEST_DESCRIPTION(description)
Defines an attribute with the name Description and the attribute value of description.
TEST_PRIORITY(priority)
Defines an attribute with the name Priority and the attribute value of priority.
TEST_WORKITEM(workitem)
Defines an attribute with the name WorkItem and the attribute value of workItem.
TEST_IGNORE()
Defines an attribute with the name Ignore and the attribute value of true.
General Asserts
Are Equal
Verify that two objects are equal
template<typename T> static void AreEqual( const T& expected, const T& actual, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Verify that two doubles are equal
static void AreEqual( double expected, double actual, double tolerance, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Verify that two floats are equal
static void AreEqual( float expected, float actual, float tolerance, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Verify that two char* strings are equal
static void AreEqual( const char* expected, const char* actual, bool ignoreCase = false, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Verify that two w_char* strings are equal
static void AreEqual( const wchar_t* expected, const wchar_t* actual, bool ignoreCase = false, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Are Not Equal
Verify that two doubles are not equal
static void AreNotEqual( double notExpected, double actual, double tolerance, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Verify that two floats are not equal
static void AreNotEqual( float notExpected, float actual, float tolerance, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Verify that two char* strings are not equal
static void AreNotEqual( const char* notExpected, const char* actual, bool ignoreCase = false, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Verify that two w_char* strings are not equal
static void AreNotEqual( const wchar_t* notExpected, const wchar_t* actual, bool ignoreCase = false, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Verify that two references are not equal based on operator==.
template<typename T> static void AreNotEqual( const T& notExpected, const T& actual, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Are Same
Verify that two references refer to the same object instance (identity).
template<typename T> static void AreSame( const T& expected, const T& actual, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Are Not Same
Verify that two references do not refer to the same object instance (identity).
template<typename T> static void AreNotSame ( const T& notExpected, const T& actual, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Is Null
Verify that a pointer is NULL.
template<typename T> static void IsNull( const T* actual, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Is Not Null
Verify that a pointer is not NULL
template<typename T> static void IsNotNull( const T* actual, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Is True
Verify that a condition is true
static void IsTrue( bool condition, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Is False
Verify that a condition is false
static void IsFalse( bool condition, const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Fail
Force the test case result to be failed
static void Fail( const wchar_t* message = NULL, const __LineInfo* pLineInfo = NULL)
Windows Runtime Asserts
Are Equal
Verifies that two Windows Runtime pointers are equal.
template<typename T>
static void AreEqual(
T^ expected,
T^ actual,
Platform::String^ message = nullptr,
const __LineInfo* pLineInfo= nullptr)
Verifies that two Platform::String^ strings are equal.
template<typename T>
static void AreEqual(
T^ expected,
T^ actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Are Same
Verifies that two Windows Runtime references reference the same object.
template<typename T>
static void AreSame(
T% expected,
T% actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Are Not Equal
Verifies that two Windows Runtime pointers are not equal.
template<typename T>
static void AreNotEqual(
T^ notExpected,
T^ actual,
Platform::String^ message = nullptr,
const __LineInfo* pLineInfo= nullptr)
Verifies that two Platform::String^ strings are not equal.
static void AreNotEqual(
Platform::String^ notExpected,
Platform::String^ actual,
bool ignoreCase = false,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Are Not Same
Verifies that two Windows Runtime references do not reference the same object.
template<typename T>
static void AreNotSame(
T% notExpected,
T% actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Is Null
Verifies that a Windows Runtime pointer is a nullptr.
template<typename T>
static void IsNull(
T^ actual,
Platform::String^ message = nullptr,
const __LineInfo* pLineInfo= nullptr)
Is Not Null
Verifies that a Windows Runtime pointer is not a nullptr.
template<typename T>
static void IsNotNull(
T^ actual,
Platform::String^ message= nullptr,
const __LineInfo* pLineInfo= nullptr)
Exception Asserts
Expect Exception
Verify that a function raises an exception:
template<typename _EXPECTEDEXCEPTION, typename _FUNCTOR>
static void ExpectException(
_FUNCTOR functor,
const wchar_t* message= NULL,
const __LineInfo* pLineInfo= NULL)
Verify that a function raises an exception:
template<typename _EXPECTEDEXCEPTION, typename _RETURNTYPE>
static void ExpectException(
_RETURNTYPE (*func)(),
const wchar_t* message= NULL,
const __LineInfo* pLineInfo = NULL)
Logger
The Logger class contains static methods to write to
class Logger
Write Message
static void Logger::WriteMessage(const wchar_t* message)
static void Logger::WriteMessage(const char* message)
This code is an example of
////////////////////////////////////////////////////////////
/* 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");
}
};
Unit Test Your Code
Unit testing native code with Test Explorer
Adding unit tests to existing C++ applications