mirror of
https://review.haiku-os.org/haiku
synced 2025-02-12 00:28:19 +01:00
aa94570a34
Courtesy of Oliver Tappe. git-svn-id: file:///srv/svn/repos/haiku/trunk/current@6616 a95241bf-73f2-0310-859d-f6bbb57e9c96
346 lines
12 KiB
C++
346 lines
12 KiB
C++
// //////////////////////////////////////////////////////////////////////////
|
|
// Header file HelperMacros.h
|
|
// (c)Copyright 2000, Baptiste Lepilleur.
|
|
// Created: 2001/04/15
|
|
// //////////////////////////////////////////////////////////////////////////
|
|
#ifndef CPPUNIT_EXTENSIONS_HELPERMACROS_H
|
|
#define CPPUNIT_EXTENSIONS_HELPERMACROS_H
|
|
|
|
#include <cppunit/Portability.h>
|
|
#include <cppunit/extensions/AutoRegisterSuite.h>
|
|
#include <cppunit/extensions/TestSuiteBuilder.h>
|
|
#include <string>
|
|
|
|
namespace CppUnit
|
|
{
|
|
class TestFixture;
|
|
|
|
/*! \brief Abstract TestFixture factory.
|
|
*/
|
|
class TestFixtureFactory
|
|
{
|
|
public:
|
|
//! Creates a new TestFixture instance.
|
|
virtual CppUnit::TestFixture *makeFixture() =0;
|
|
};
|
|
} // namespace CppUnit
|
|
|
|
|
|
// The macro __CPPUNIT_SUITE_CTOR_ARGS expand to an expression used to construct
|
|
// the TestSuiteBuilder with macro CPPUNIT_TEST_SUITE.
|
|
//
|
|
// The name of the suite is obtained using RTTI if CPPUNIT_USE_TYPEINFO_NAME
|
|
// is defined, otherwise it is extracted from the macro parameter
|
|
//
|
|
// This macro is for cppunit internal and should not be use otherwise.
|
|
#if CPPUNIT_USE_TYPEINFO_NAME
|
|
# define __CPPUNIT_SUITE_CTOR_ARGS( ATestFixtureType )
|
|
#else
|
|
# define __CPPUNIT_SUITE_CTOR_ARGS( ATestFixtureType ) (string(#ATestFixtureType))
|
|
#endif
|
|
|
|
|
|
/*! \addtogroup WritingTestFixture Writing test fixture
|
|
*/
|
|
/** @{
|
|
*/
|
|
|
|
|
|
/** \file
|
|
* Macros intended to ease the definition of test suites.
|
|
*
|
|
* The macros
|
|
* CPPUNIT_TEST_SUITE(), CPPUNIT_TEST(), and CPPUNIT_TEST_SUITE_END()
|
|
* are designed to facilitate easy creation of a test suite.
|
|
* For example,
|
|
*
|
|
* \code
|
|
* #include <cppunit/extensions/HelperMacros.h>
|
|
* class MyTest : public CppUnit::TestFixture {
|
|
* CPPUNIT_TEST_SUITE( MyTest );
|
|
* CPPUNIT_TEST( testEquality );
|
|
* CPPUNIT_TEST( testSetName );
|
|
* CPPUNIT_TEST_SUITE_END();
|
|
* public:
|
|
* void testEquality();
|
|
* void testSetName();
|
|
* };
|
|
* \endcode
|
|
*
|
|
* The effect of these macros is to define two methods in the
|
|
* class MyTest. The first method is an auxiliary function
|
|
* named registerTests that you will not need to call directly.
|
|
* The second function
|
|
* \code static CppUnit::TestSuite *suite()\endcode
|
|
* returns a pointer to the suite of tests defined by the CPPUNIT_TEST()
|
|
* macros.
|
|
*
|
|
* Rather than invoking suite() directly,
|
|
* the macro CPPUNIT_TEST_SUITE_REGISTRATION() is
|
|
* used to create a static variable that automatically
|
|
* registers its test suite in a global registry.
|
|
* The registry yields a Test instance containing all the
|
|
* registered suites.
|
|
* \code
|
|
* CPPUNIT_TEST_SUITE_REGISTRATION( MyTest );
|
|
* CppUnit::Test* tp =
|
|
* CppUnit::TestFactoryRegistry::getRegistry().makeTest();
|
|
* \endcode
|
|
*
|
|
* The test suite macros can even be used with templated test classes.
|
|
* For example:
|
|
*
|
|
* \code
|
|
* template<typename CharType>
|
|
* class StringTest : public CppUnit::TestFixture {
|
|
* CPPUNIT_TEST_SUITE( StringTest );
|
|
* CPPUNIT_TEST( testAppend );
|
|
* CPPUNIT_TEST_SUITE_END();
|
|
* public:
|
|
* ...
|
|
* };
|
|
* \endcode
|
|
*
|
|
* You need to add in an implementation file:
|
|
*
|
|
* \code
|
|
* CPPUNIT_TEST_SUITE_REGISTRATION( StringTest<char> );
|
|
* CPPUNIT_TEST_SUITE_REGISTRATION( StringTest<wchar_t> );
|
|
* \endcode
|
|
*/
|
|
|
|
|
|
/*! \brief Begin test suite
|
|
*
|
|
* This macro starts the declaration of a new test suite.
|
|
* Use CPPUNIT_TEST_SUB_SUITE() instead, if you wish to include the
|
|
* test suite of the parent class.
|
|
*
|
|
* \param ATestFixtureType Type of the test case class. This type \b MUST
|
|
* be derived from TestFixture.
|
|
* \see CPPUNIT_TEST_SUB_SUITE, CPPUNIT_TEST, CPPUNIT_TEST_SUITE_END,
|
|
* \see CPPUNIT_TEST_SUITE_REGISTRATION, CPPUNIT_TEST_EXCEPTION, CPPUNIT_TEST_FAIL.
|
|
*/
|
|
#define CPPUNIT_TEST_SUITE( ATestFixtureType ) \
|
|
private: \
|
|
typedef ATestFixtureType __ThisTestFixtureType; \
|
|
class ThisTestFixtureFactory : public CppUnit::TestFixtureFactory \
|
|
{ \
|
|
virtual CppUnit::TestFixture *makeFixture() \
|
|
{ \
|
|
return new ATestFixtureType(); \
|
|
} \
|
|
}; \
|
|
public: \
|
|
static void \
|
|
registerTests( CppUnit::TestSuite *suite, \
|
|
CppUnit::TestFixtureFactory *factory ) \
|
|
{ \
|
|
CppUnit::TestSuiteBuilder<__ThisTestFixtureType> builder( suite );
|
|
|
|
|
|
/*! \brief Begin test suite (includes parent suite)
|
|
*
|
|
* This macro may only be used in a class whose parent class
|
|
* defines a test suite using CPPUNIT_TEST_SUITE() or CPPUNIT_TEST_SUB_SUITE().
|
|
*
|
|
* This macro begins the declaration of a test suite, in the same
|
|
* manner as CPPUNIT_TEST_SUITE(). In addition, the test suite of the
|
|
* parent is automatically inserted in the test suite being
|
|
* defined.
|
|
*
|
|
* Here is an example:
|
|
*
|
|
* \code
|
|
* #include <cppunit/extensions/HelperMacros.h>
|
|
* class MySubTest : public MyTest {
|
|
* CPPUNIT_TEST_SUB_SUITE( MySubTest, MyTest );
|
|
* CPPUNIT_TEST( testAdd );
|
|
* CPPUNIT_TEST( testSub );
|
|
* CPPUNIT_TEST_SUITE_END();
|
|
* public:
|
|
* void testAdd();
|
|
* void testSub();
|
|
* };
|
|
* \endcode
|
|
*
|
|
* \param ATestFixtureType Type of the test case class. This type \b MUST
|
|
* be derived from TestFixture.
|
|
* \param ASuperClass Type of the parent class.
|
|
* \see CPPUNIT_TEST_SUITE.
|
|
*/
|
|
#define CPPUNIT_TEST_SUB_SUITE( ATestFixtureType, ASuperClass ) \
|
|
private: \
|
|
typedef ASuperClass __ThisSuperClassType; \
|
|
CPPUNIT_TEST_SUITE( ATestFixtureType ); \
|
|
__ThisSuperClassType::registerTests( suite, factory )
|
|
|
|
|
|
/*! \brief Add a method to the suite.
|
|
* \param testMethod Name of the method of the test case to add to the
|
|
* suite. The signature of the method must be of
|
|
* type: void testMethod();
|
|
* \see CPPUNIT_TEST_SUITE.
|
|
*/
|
|
#define CPPUNIT_TEST( testMethod ) \
|
|
builder.addTestCaller( #testMethod, \
|
|
&__ThisTestFixtureType::testMethod , \
|
|
(__ThisTestFixtureType*)factory->makeFixture() )
|
|
|
|
|
|
/*! \brief Add a test which fail if the specified exception is not caught.
|
|
*
|
|
* Example:
|
|
* \code
|
|
* #include <cppunit/extensions/HelperMacros.h>
|
|
* #include <vector>
|
|
* class MyTest : public CppUnit::TestFixture {
|
|
* CPPUNIT_TEST_SUITE( MyTest );
|
|
* CPPUNIT_TEST_EXCEPTION( testVectorAtThrow, invalid_argument );
|
|
* CPPUNIT_TEST_SUITE_END();
|
|
* public:
|
|
* void testVectorAtThrow()
|
|
* {
|
|
* vector<int> v;
|
|
* v.at( 1 ); // must throw exception invalid_argument
|
|
* }
|
|
* };
|
|
* \endcode
|
|
*
|
|
* \param testMethod Name of the method of the test case to add to the suite.
|
|
* \param ExceptionType Type of the exception that must be thrown by the test
|
|
* method.
|
|
*/
|
|
#define CPPUNIT_TEST_EXCEPTION( testMethod, ExceptionType ) \
|
|
builder.addTestCallerForException( #testMethod, \
|
|
&__ThisTestFixtureType::testMethod , \
|
|
(__ThisTestFixtureType*)factory->makeFixture(), \
|
|
(ExceptionType *)NULL );
|
|
|
|
/*! \brief Adds a test case which is excepted to fail.
|
|
*
|
|
* The added test case expect an assertion to fail. You usually used that type
|
|
* of test case when testing custom assertion macros.
|
|
*
|
|
* \code
|
|
* CPPUNIT_TEST_FAIL( testAssertFalseFail );
|
|
*
|
|
* void testAssertFalseFail()
|
|
* {
|
|
* CPPUNIT_ASSERT( false );
|
|
* }
|
|
* \endcode
|
|
* \see CreatingNewAssertions.
|
|
*/
|
|
#define CPPUNIT_TEST_FAIL( testMethod ) \
|
|
CPPUNIT_TEST_EXCEPTION( testMethod, CppUnit::Exception )
|
|
|
|
/*! \brief End declaration of the test suite.
|
|
*
|
|
* After this macro, member access is set to "private".
|
|
*
|
|
* \see CPPUNIT_TEST_SUITE.
|
|
* \see CPPUNIT_TEST_SUITE_REGISTRATION.
|
|
*/
|
|
#define CPPUNIT_TEST_SUITE_END() \
|
|
builder.takeSuite(); \
|
|
} \
|
|
static CppUnit::TestSuite *suite() \
|
|
{ \
|
|
CppUnit::TestSuiteBuilder<__ThisTestFixtureType> \
|
|
builder __CPPUNIT_SUITE_CTOR_ARGS( ATestFixtureType ); \
|
|
ThisTestFixtureFactory factory; \
|
|
__ThisTestFixtureType::registerTests( builder.suite(), &factory ); \
|
|
return builder.takeSuite(); \
|
|
} \
|
|
private: /* dummy typedef so that the macro can still end with ';'*/ \
|
|
typedef ThisTestFixtureFactory __ThisTestFixtureFactory
|
|
|
|
/** @}
|
|
*/
|
|
|
|
#define __CPPUNIT_CONCATENATE_DIRECT( s1, s2 ) s1##s2
|
|
#define __CPPUNIT_CONCATENATE( s1, s2 ) __CPPUNIT_CONCATENATE_DIRECT( s1, s2 )
|
|
|
|
/** Decorates the specified string with the line number to obtain a unique name;
|
|
* @param str String to decorate.
|
|
*/
|
|
#define __CPPUNIT_MAKE_UNIQUE_NAME( str ) __CPPUNIT_CONCATENATE( str, __LINE__ )
|
|
|
|
|
|
/** Adds the specified fixture suite to the unnamed registry.
|
|
* \ingroup CreatingTestSuite
|
|
*
|
|
* This macro declares a static variable whose construction
|
|
* causes a test suite factory to be inserted in a global registry
|
|
* of such factories. The registry is available by calling
|
|
* the static function CppUnit::TestFactoryRegistry::getRegistry().
|
|
*
|
|
* \param ATestFixtureType Type of the test case class.
|
|
* \warning This macro should be used only once per line of code (the line
|
|
* number is used to name a hidden static variable).
|
|
* \see CPPUNIT_TEST_SUITE_NAMED_REGISTRATION
|
|
* \see CPPUNIT_TEST_SUITE, CppUnit::AutoRegisterSuite,
|
|
* CppUnit::TestFactoryRegistry.
|
|
*/
|
|
#define CPPUNIT_TEST_SUITE_REGISTRATION( ATestFixtureType ) \
|
|
static CppUnit::AutoRegisterSuite< ATestFixtureType > \
|
|
__CPPUNIT_MAKE_UNIQUE_NAME(__autoRegisterSuite )
|
|
|
|
|
|
/** Adds the specified fixture suite to the specified registry suite.
|
|
* \ingroup CreatingTestSuite
|
|
*
|
|
* This macro declares a static variable whose construction
|
|
* causes a test suite factory to be inserted in the global registry
|
|
* suite of the specified name. The registry is available by calling
|
|
* the static function CppUnit::TestFactoryRegistry::getRegistry().
|
|
*
|
|
* For the suite name, use a string returned by a static function rather
|
|
* than a hardcoded string. That way, you can know what are the name of
|
|
* named registry and you don't risk mistyping the registry name.
|
|
*
|
|
* \code
|
|
* // MySuites.h
|
|
* namespace MySuites {
|
|
* string math() {
|
|
* return "Math";
|
|
* }
|
|
* }
|
|
*
|
|
* // ComplexNumberTest.cpp
|
|
* #include "MySuites.h"
|
|
*
|
|
* CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( ComplexNumberTest, MySuites::math() );
|
|
* \endcode
|
|
*
|
|
* \param ATestFixtureType Type of the test case class.
|
|
* \param suiteName Name of the global registry suite the test suite is
|
|
* registered into.
|
|
* \warning This macro should be used only once per line of code (the line
|
|
* number is used to name a hidden static variable).
|
|
* \see CPPUNIT_TEST_SUITE_REGISTRATION
|
|
* \see CPPUNIT_TEST_SUITE, CppUnit::AutoRegisterSuite,
|
|
* CppUnit::TestFactoryRegistry..
|
|
*/
|
|
#define CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( ATestFixtureType, suiteName ) \
|
|
static CppUnit::AutoRegisterSuite< ATestFixtureType > \
|
|
__CPPUNIT_MAKE_UNIQUE_NAME(__autoRegisterSuite )(suiteName)
|
|
|
|
|
|
// Backwards compatibility
|
|
// (Not tested!)
|
|
|
|
#if CPPUNIT_ENABLE_CU_TEST_MACROS
|
|
|
|
#define CU_TEST_SUITE(tc) CPPUNIT_TEST_SUITE(tc)
|
|
#define CU_TEST_SUB_SUITE(tc,sc) CPPUNIT_TEST_SUB_SUITE(tc,sc)
|
|
#define CU_TEST(tm) CPPUNIT_TEST(tm)
|
|
#define CU_TEST_SUITE_END() CPPUNIT_TEST_SUITE_END()
|
|
#define CU_TEST_SUITE_REGISTRATION(tc) CPPUNIT_TEST_SUITE_REGISTRATION(tc)
|
|
|
|
#endif
|
|
|
|
|
|
#endif // CPPUNIT_EXTENSIONS_HELPERMACROS_H
|