testfixture.h

Go to the documentation of this file.

#ifndef CPPUT_TESTFIXTURE_H_INCLUDED
# define CPPUT_TESTFIXTURE_H_INCLUDED

# include <cpput/forwards.h>
# include <cpput/extendeddata.h>
# include <cpput/testcase.h>
# include <cpput/testsuite.h>
# include <cpput/translate.h>
# include <cpptl/typename.h>


namespace CppUT {


class CPPUT_API TestFixture : public CppTL::IntrusiveCount
                            , public TestExtendedDataFactory
{
public:
   virtual ~TestFixture()
   {
   }

   virtual void setUp()
   {
   }

   virtual void tearDown()
   {
   }

   static void addTestWithSpecifics( TestSuite &suite,
                                     const TestPtr &test,
                                     const TestExtendedData &specifics )
   {
      ::CppUT::TestExtendedDataHelper specificHelper( *test );
      specificHelper( specifics );
      suite.add( test );
   }
};



namespace Impl {

   typedef CppTL::IntrusivePtr<TestFixture> TestFixturePtr;

   class CPPUT_API FixtureFactory
   {
   public:
      virtual ~FixtureFactory()
      {
      }

      TestFixturePtr operator()()
      {
         return createNewFixture();
      }

   private:
      virtual TestFixturePtr createNewFixture() =0;
   };


   template<typename FixtureType>
   class FixtureFactoryImpl : public FixtureFactory
   {
   public:
      TestFixturePtr createNewFixture()
      {
         return TestFixturePtr( new FixtureType() );
      }
   };

   template<typename FixtureType>
   class FixtureFactoryWrapper
   {
   public:
      FixtureFactoryWrapper( FixtureFactory &factory )
         : factory_( factory )
      {
      }

      CppTL::IntrusivePtr<FixtureType> operator()()
      {
        return ::CppTL::staticPointerCast<FixtureType>( factory_() );
      }

   private:
      FixtureFactory &factory_;
   };
} // namespace Impl


/* Code generated by the helper macros is roughly like this:

class SomeTest : public CppUT::TestFixture
{
public:     // CPPUT_TESTSUITE_BEGIN
   typedef FixtureType CppUT_ThisType;

   static std::string defaultSuiteName()
   {
      return ::CppTL::getTypeName<CppUT_ThisType>( #FixtureType );
   }

   void addTests_( const ::CppUT::TestSuitePtr &suite,
                   ::CppUT::Impl::FixtureFactory &factory_ )
   {
      ::CppUT::Impl::FixtureFactoryWrapper<CppUT_ThisType> fixtureFactory( factory_ );
      ::CppTL::IntrusivePtr<FixtureType> fixture;

      // CPPUT_TESTSUITE_EXTEND (if defined)
      ParentFixtureType::addTests_( suite, factory_ );

      // CPPUT_TEST( testMethod )
      fixture = fixtureFactory();
      suite->add( ::CppUT::makeFixtureTestCase( fixture, 
                                                &FixtureType::testMethod, 
                                                #testMethod ) );

      
   }  // if ended using CPPUT_ABSTRACT_TESTSUITE_END, stop there (suite() is not defined)

   // if ended using CPPUT_TESTSUITE_END, define the static function suite
   static ::CppUT::TestSuitePtr suite()
   {
      ::CppUT::TestSuitePtr testSuite( ::CppUT::makeTestSuite( defaultSuiteName() ) );
      ::CppUT::Impl::FixtureFactoryImpl<CppUT_ThisType> factory;
      addTests_( testSuite, factory );
      return testSuite;
   }
};

*/



# if CPPUT_USE_RTTI_TO_NAME_SUITE
#  define CPPUT_TESTSUITE_NAME_FROM_TYPE( FixtureType )              \
      ::CppTL::getTypeName( ::CppTL::Type<FixtureType>(), #FixtureType )
# else // if CPPUT_USE_RTTI_TO_NAME_SUITE
#  define CPPUT_TESTSUITE_NAME_FROM_TYPE( FixtureType )              \
      std::string( #FixtureType )
# endif // if CPPUT_USE_RTTI_TO_NAME_SUITE



# define CPPUT_TESTSUITE_BEGIN( FixtureType )                                \
public:                                                                      \
   typedef FixtureType CppUT_ThisType;                                       \
                                                                             \
   static std::string defaultSuiteName()                                     \
   {                                                                         \
      return CPPUT_TESTSUITE_NAME_FROM_TYPE( FixtureType );                  \
   }                                                                         \
                                                                             \
   static void addTests_( const ::CppUT::TestSuitePtr &suite,                \
                          ::CppUT::Impl::FixtureFactory &factory_ )          \
   {                                                                         \
      ::CppUT::Impl::FixtureFactoryWrapper<CppUT_ThisType> fixtureFactory(   \
         factory_ );                                                         \
      ::CppTL::IntrusivePtr<FixtureType> fixture
  
# define CPPUT_TESTSUITE_EXTEND( FixtureType, ParentFixtureType )            \
      CPPUT_TESTSUITE_BEGIN( FixtureType );                                  \
      ParentFixtureType::addTests_( suite, factory_ )

# define CPPUT_TESTSUITE_END()                                                \
   }                                                                          \
                                                                              \
   static ::CppUT::TestPtr suite( const std::string &name = std::string("") ) \
   {                                                                          \
      std::string suiteName = name;                                           \
      if ( suiteName.empty() )                                                \
          suiteName = defaultSuiteName();                                     \
      ::CppUT::TestSuitePtr testSuite = ::CppUT::makeTestSuite( suiteName );  \
      ::CppUT::Impl::FixtureFactoryImpl<CppUT_ThisType> factory;              \
      addTests_( testSuite, factory );                                        \
      return ::CppTL::staticPointerCast< ::CppUT::Test >( testSuite );        \
   }

# define CPPUT_ABSTRACT_TESTSUITE_END()                                      \
   }

# define CPPUT_TEST( testMethod )                                            \
      fixture = fixtureFactory();                                            \
      suite->add( ::CppUT::makeFixtureTestCase( fixture,                     \
                   ::CppTL::memfn0( fixture,                                 \
                                    &CppUT_ThisType::testMethod ),           \
                   #testMethod ) )

# define CPPUT_TEST_WITH_SPECIFICS( testMethod, specifics )                  \
      fixture = fixtureFactory();                                            \
      addTestWithSpecifics( *suite,                                          \
                            ::CppUT::makeFixtureTestCase( fixture,           \
                               ::CppTL::memfn0( fixture,                     \
                                  &CppUT_ThisType::testMethod ),             \
                                                          #testMethod ),     \
                            specifics )
         
} // namespace CppUT


#endif // CPPUT_TESTFIXTURE_H_INCLUDED