exceptionguard.h

Go to the documentation of this file.

#ifndef CPPUT_TESTFAILUREGUARD_H_INCLUDED
# define CPPUT_TESTFAILUREGUARD_H_INCLUDED

# include <cpput/forwards.h>
# include <cpptl/intrusiveptr.h>
# include <deque>

/* Tests setUp(), tearDown(), run() call are protected by a ExceptionGuard.
 *
 * This guard chain ensures that any exceptions thrown by the call is caught and properly handled.
 * The default guard chain handles AssertionException (thrown when an assertion fails),
 * std::exception, and any other exception.
 * 
 * A ExceptionGuardElement can be added to the guard chain to handle exception type unknown
 * to the test framework which are not derived from std::exception (MFC CException * for example).
 */

namespace CppUT {

class CPPUT_API ExceptionGuardElement : public CppTL::IntrusiveCount
{
public:
   struct Context;

   virtual ~ExceptionGuardElement()
   {
   }

   void setNextInChain( const ExceptionGuardElementPtr &deleguate );

   virtual bool protect( Context &context ) = 0;

protected:
   bool callNextInChain( Context &context );

private:
   ExceptionGuardElementPtr deleguate_;
};


template<class ExceptionType
        ,class Translator>
class ExceptionTranslatorGuard : public ExceptionGuardElement
{
public:
   ExceptionTranslatorGuard( Translator translator )
      : translator_( translator )
   {
   }

   // overridden from ExceptionGuardElement
   bool protect( Context &context )
   {
      try
      {
         return callNextInChain( context );
      }
      catch ( const ExceptionType &e )
      {
         translator_( e );
         return false;
      }
   }
private:
   Translator translator_;
};


class CPPUT_API ExceptionGuard
{
public:
   ExceptionGuard();

   void append( const ExceptionGuardElementPtr &guard );

   void removeLast();

   bool protect( CppTL::Functor0 test ) const;

private:
   typedef std::deque<ExceptionGuardElementPtr> Guards;
   Guards guards_;
};



template<class Translator
        ,class ExceptionType>
void registerExceptionTranslation( ExceptionGuard &guard,
                                   Translator translator,
                                   CppTL::Type<ExceptionType> )
{
   typedef ExceptionTranslatorGuard<ExceptionType,Translator> GuardType;
   guard.append( ExceptionGuardElementPtr( new GuardType( translator ) ) );
}


} // namespace CppUT

#endif // CPPUT_TESTFAILUREGUARD_H_INCLUDED