271 lines
8.7 KiB
C++
271 lines
8.7 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
|
|
#ifndef UNITLIB_H
|
|
#define UNITLIB_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "tier0/platform.h"
|
|
#include "tier1/interface.h"
|
|
#include "appframework/IAppSystem.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Usage model for the UnitTest library
|
|
//
|
|
// The general methodology here is that clients are expected to create unit
|
|
// test DLLs that statically link to the unit test DLL and which implement
|
|
// tests of various libraries. The unit test application will dynamically
|
|
// load all DLLs in a directory, which causes them to install their test cases
|
|
// into the unit test system. The application then runs through all tests and
|
|
// executes them all, displaying the results.
|
|
//
|
|
// *** NOTE: The test suites are compiled in both debug and release builds,
|
|
// even though it's expected to only be useful in debug builds. This is because
|
|
// I couldn't come up with a good way of disabling the code in release builds.
|
|
// (The only options I could come up with would still compile in the functions,
|
|
// just not install them into the unit test library, or would make it so that
|
|
// you couldn't step through the unit test code).
|
|
//
|
|
// Even though this is the case, there's no reason not to add test cases
|
|
// directly into your shipping DLLs, as long as you surround the code with
|
|
// #ifdef _DEBUG. To error check a project to make sure it's not compiling
|
|
// in unit tests in Release build, just don't link in unitlib.lib in Release.
|
|
// You can of course also put your test suites into separate DLLs.
|
|
//
|
|
// All tests inherit from the ITestCase interface. There are two major kinds
|
|
// of tests; the first is a single test case meant to run a piece of
|
|
// code and check its results match expected values using the Assert macros.
|
|
// The second kind is a test suite which is simply a list of other tests.
|
|
//
|
|
// The following classes and macros are used to easily create unit test cases
|
|
// and suites:
|
|
//
|
|
// Use DEFINE_TESTSUITE to define a particular test suite, and DEFINE_TESTCASE
|
|
// to add as many test cases as you like to that test suite, as follows:
|
|
//
|
|
// DEFINE_TESTSUITE( VectorTestSuite )
|
|
//
|
|
// DEFINE_TESTCASE( VectorAdditionTest, VectorTestSuite )
|
|
// {
|
|
// .. test code here ..
|
|
// }
|
|
//
|
|
// Note that the definition of the test suite can occur in a different file
|
|
// as the test case. A link error will occur if the test suite to which a
|
|
// test case is added has not been defined.
|
|
//
|
|
// To create a test case that is not part of a suite, use...
|
|
//
|
|
// DEFINE_TESTCASE_NOSUITE( VectorAdditionTest )
|
|
// {
|
|
// .. test code here ..
|
|
// }
|
|
//
|
|
// You can also create a suite which is a child of another suite using
|
|
//
|
|
// DEFINE_SUBSUITE( VectorTestSuite, MathTestSuite )
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// dll export stuff
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifdef UNITLIB_DLL_EXPORT
|
|
#define UNITLIB_INTERFACE DLL_EXPORT
|
|
#define UNITLIB_CLASS_INTERFACE DLL_CLASS_EXPORT
|
|
#define UNITLIB_GLOBAL_INTERFACE DLL_GLOBAL_EXPORT
|
|
#else
|
|
#define UNITLIB_INTERFACE DLL_IMPORT
|
|
#define UNITLIB_CLASS_INTERFACE DLL_CLASS_IMPORT
|
|
#define UNITLIB_GLOBAL_INTERFACE DLL_GLOBAL_IMPORT
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// All unit test libraries can be asked for a unit test
|
|
// AppSystem to perform connection
|
|
//-----------------------------------------------------------------------------
|
|
#define UNITTEST_INTERFACE_VERSION "UnitTestV001"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// NOTE: All classes and interfaces below you shouldn't use directly.
|
|
// Use the DEFINE_TESTSUITE and DEFINE_TESTCASE macros instead.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Test case + suite interface
|
|
//-----------------------------------------------------------------------------
|
|
class ITestCase
|
|
{
|
|
public:
|
|
// This returns the test name
|
|
virtual char const* GetName() = 0;
|
|
|
|
// This runs the test
|
|
virtual void RunTest() = 0;
|
|
};
|
|
|
|
class ITestSuite : public ITestCase
|
|
{
|
|
public:
|
|
// Add a test to the suite...
|
|
virtual void AddTest( ITestCase* pTest ) = 0;
|
|
};
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is the main function exported by the unit test library used by
|
|
// unit test DLLs to install their test cases into a list to be run
|
|
//-----------------------------------------------------------------------------
|
|
UNITLIB_INTERFACE void UnitTestInstallTestCase( ITestCase* pTest );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// These are the methods used by the unit test running program to run all tests
|
|
//-----------------------------------------------------------------------------
|
|
UNITLIB_INTERFACE int UnitTestCount();
|
|
UNITLIB_INTERFACE ITestCase* GetUnitTest( int i );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper for unit test DLLs to expose IAppSystems
|
|
//-----------------------------------------------------------------------------
|
|
#define USE_UNITTEST_APPSYSTEM( _className ) \
|
|
static _className s_UnitTest ## _className; \
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( _className, IAppSystem, UNITTEST_INTERFACE_VERSION, s_UnitTest ## _className );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Base class for test cases
|
|
//-----------------------------------------------------------------------------
|
|
class UNITLIB_CLASS_INTERFACE CTestCase : public ITestCase
|
|
{
|
|
public:
|
|
CTestCase( char const* pName, ITestSuite* pParent = 0 );
|
|
~CTestCase();
|
|
|
|
// Returns the test name
|
|
char const* GetName();
|
|
|
|
private:
|
|
char* m_pName;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Test suite class
|
|
//-----------------------------------------------------------------------------
|
|
class UNITLIB_CLASS_INTERFACE CTestSuite : public ITestSuite
|
|
{
|
|
public:
|
|
CTestSuite( char const* pName, ITestSuite* pParent = 0 );
|
|
~CTestSuite();
|
|
|
|
// This runs the test
|
|
void RunTest();
|
|
|
|
// Add a test to the suite...
|
|
void AddTest( ITestCase* pTest );
|
|
|
|
// Returns the test name
|
|
char const* GetName();
|
|
|
|
protected:
|
|
int m_TestCount;
|
|
ITestCase** m_ppTestCases;
|
|
char* m_pName;
|
|
};
|
|
|
|
#define TESTSUITE_CLASS( _suite ) \
|
|
class CTS ## _suite : public CTestSuite \
|
|
{ \
|
|
public: \
|
|
CTS ## _suite(); \
|
|
};
|
|
|
|
#define TESTSUITE_ACCESSOR( _suite ) \
|
|
CTS ## _suite* GetTS ## _suite() \
|
|
{ \
|
|
static CTS ## _suite s_TS ## _suite; \
|
|
return &s_TS ## _suite; \
|
|
}
|
|
|
|
#define FWD_DECLARE_TESTSUITE( _suite ) \
|
|
class CTS ## _suite; \
|
|
CTS ## _suite* GetTS ## _suite();
|
|
|
|
#define DEFINE_TESTSUITE( _suite ) \
|
|
TESTSUITE_CLASS( _suite ) \
|
|
TESTSUITE_ACCESSOR( _suite ) \
|
|
CTS ## _suite::CTS ## _suite() : CTestSuite( #_suite ) {}
|
|
|
|
#define DEFINE_SUBSUITE( _suite, _parent ) \
|
|
TESTSUITE_CLASS( _suite ) \
|
|
TESTSUITE_ACCESSOR( _suite ) \
|
|
FWD_DECLARE_TESTSUITE( _parent ) \
|
|
CTS ## _suite::CTS ## _suite() : CTestSuite( #_suite, GetTS ## _parent() ) {}
|
|
|
|
#define TESTCASE_CLASS( _case ) \
|
|
class CTC ## _case : public CTestCase \
|
|
{ \
|
|
public: \
|
|
CTC ## _case (); \
|
|
void RunTest(); \
|
|
};
|
|
|
|
#define DEFINE_TESTCASE_NOSUITE( _case ) \
|
|
TESTCASE_CLASS( _case ) \
|
|
CTC ## _case::CTC ## _case () : CTestCase( #_case ) {} \
|
|
\
|
|
CTC ## _case s_TC ## _case; \
|
|
\
|
|
void CTC ## _case ::RunTest()
|
|
|
|
#define DEFINE_TESTCASE( _case, _suite ) \
|
|
TESTCASE_CLASS( _case ) \
|
|
FWD_DECLARE_TESTSUITE( _suite ) \
|
|
CTC ## _case::CTC ## _case () : CTestCase( #_case, GetTS ## _suite() ) {} \
|
|
\
|
|
CTC ## _case s_TC ## _case; \
|
|
\
|
|
void CTC ## _case ::RunTest()
|
|
|
|
|
|
#define _Shipping_AssertMsg( _exp, _msg, _executeExp, _bFatal ) \
|
|
do { \
|
|
if (!(_exp)) \
|
|
{ \
|
|
_SpewInfo( SPEW_ASSERT, __TFILE__, __LINE__ ); \
|
|
SpewRetval_t ret = _SpewMessage(_msg); \
|
|
_executeExp; \
|
|
if ( ret == SPEW_DEBUGGER) \
|
|
{ \
|
|
if ( !ShouldUseNewAssertDialog() || DoNewAssertDialog( __TFILE__, __LINE__, _msg ) ) \
|
|
DebuggerBreak(); \
|
|
if ( _bFatal ) \
|
|
_ExitOnFatalAssert( __TFILE__, __LINE__ ); \
|
|
} \
|
|
} \
|
|
} while (0)
|
|
|
|
#define Shipping_Assert( _exp ) _Shipping_AssertMsg( _exp, _T("Assertion Failed: ") _T(#_exp), ((void)0), false )
|
|
|
|
|
|
#endif // UNITLIB_H
|