AbstractDynamicChainingMock.h

Go to the documentation of this file.

/**************************************************************************

   begin                : Sun Aug 22 2004
   copyright            : (C) 2002-2010 by Ewald Arnold
   email                : mockpp at ewald-arnold dot de

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as
   published by the Free Software Foundation; either version 2 of the License,
   or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

   *
   *  Original Java Sources:  Copyright (c) 2000-2004, jMock.org
   *

 **/

#ifndef MOCKPP_ABSTRACTDYNAMICCHAININGMOCK_H
#define MOCKPP_ABSTRACTDYNAMICCHAININGMOCK_H

#include <mockpp/mockpp.h> // always first

#include <mockpp/chaining/DynamicChainingMock.h>
#include <mockpp/chaining/DynamicChainingMockError.h>
#include <mockpp/chaining/InvocationMocker.h>
#include <mockpp/chaining/FIFOInvocationDispatcher.h>

#include <mockpp/stub/ReturnStub.h>

#include <mockpp/compat/Exception.h>


MOCKPP_NS_START


template <typename R,    // Returntype
          typename I>    // Invocation
class AbstractDynamicChainingMockImpl : public DynamicChainingMock<R, I>
{
  protected:

    AbstractDynamicChainingMockImpl( typename InvocationDispatcher<R, I>::AP in_invocationDispatcher,
                                     const String &name,
                                     VerifiableList *parent)
        : DynamicChainingMock<R, I>(name, parent)
        , invocationDispatcher( in_invocationDispatcher )
    {}

  public:

    class Describer : public InvocationMocker<R, I>::DescriberBase
    {
      public:

        virtual bool hasDescription()
        {
          return false;
        }


        virtual String describeTo( String &result,
#ifdef MOCKPP_NO_TYPENAME_FOR_STL_NS
                                   const MOCKPP_STL::vector<InvocationMatcher<I>*> &matchers,
#else
                                   const typename MOCKPP_STL::vector<InvocationMatcher<I>*> &matchers,
#endif
                                   Stub<R, I> *stub,
                                   const String &name ) const
        {
          return result;
        }

#if defined( __BORLANDC__ ) || defined( _MSC_VER )

      // also prevent internal compiler error for BCB5

        String describeTo( String &result,
                           const typename MOCKPP_STL::vector<InvocationMatcher<I>*> &matchers,
                           TypelessStub<R>* stub,
                           const String &name ) const
        {
          return InvocationMocker<R, I>::DescriberBase::describeTo(result, matchers, adap.get(), name);
        }

#else
        using InvocationMocker<R, I>::DescriberBase::describeTo;
#endif

    };

    virtual void verify()
    {
      forgetFailure();

      MOCKPP_TRY
      {
        invocationDispatcher->verify();
      }

#ifndef MOCKPP_NO_EXCEPTIONS
      catch ( const AssertionFailedError &ex )
      {
        assertionFailed( __LINE__, __FILE__,
                                    MOCKPP_PCHAR( "mock object " )
                                    + getMockName()
                                    + MOCKPP_PCHAR( ": " )
                                    + ex.getMessage() );
      }
#endif // MOCKPP_NO_EXCEPTIONS
    }

    virtual String toString() const
    {
      return this->getVerifiableName();
    }

    String getMockName() const
    {
      return this->getVerifiableName();
    }

    virtual void setDefaultStub( const MOCKPP_NS::StubHolder<R, I> &newDefaultStub )
    {
      invocationDispatcher->setDefaultStub( newDefaultStub );
    }

    virtual void addInvokable( typename Invokable<R, I>::AP invokable )
    {
      invocationDispatcher->add( invokable );
    }

    virtual void reset()
    {
      invocationDispatcher->reset();
      forgetFailure();
    }

  protected:

    virtual R mockInvocation( const I &invocation ) = 0;

  private:

    void forgetFailure() const
    {
      failure.reset( 0 );
    }

  protected:

    mutable AutoPointer<AssertionFailedError>  failure;               
    typename InvocationDispatcher<R, I>::AP    invocationDispatcher;  
};


template <typename R,    // Returntype
          typename I>    // Invocation
class AbstractDynamicChainingMock : public AbstractDynamicChainingMockImpl<R, I>
{
  public:

    AbstractDynamicChainingMock( typename InvocationDispatcher<R, I>::AP in_invocationDispatcher,
                                 const String &name,
                                 VerifiableList *parent)
      : AbstractDynamicChainingMockImpl<R,I>(in_invocationDispatcher, name, parent)
    {}

    AbstractDynamicChainingMock( const String &name,
                                 VerifiableList *parent)
      : AbstractDynamicChainingMockImpl<R,I>(new FIFOInvocationDispatcher<R,I>, name, parent)
    {}

  protected:

    virtual R mockInvocation( const I &invocation )
    {
      if ( this->failure.get() != 0 )
        assertionFailed(this->failure->getSrcLine(),
                        this->failure->getSrcFile(),
                        this->failure->getMessage());

      MOCKPP_TRY
      {
        return this->invocationDispatcher->dispatch( invocation );
      }

#ifndef MOCKPP_NO_EXCEPTIONS
      catch ( const AssertionFailedError & assertion )
      {
        DynamicChainingMockError<R, I> dme( this,
                                            invocation,
                                            this->invocationDispatcher.get(),
                                            assertion.getMessage() );
        this->failure.reset( new AssertionFailedError(__LINE__, __FILE__, dme.getMessage()));
        assertionFailed(this->failure->getSrcLine(),
                        this->failure->getSrcFile(),
                        this->failure->getMessage());
      }
      return R();
#endif // MOCKPP_NO_EXCEPTIONS
    }
};


#ifndef MOCKPP_PTI_WEAKNESS // Partial Template Instantiation Weakness


template <typename I>    // Invocation
class AbstractDynamicChainingMock<void, I> : public AbstractDynamicChainingMockImpl<void, I>
{
  public:

    AbstractDynamicChainingMock( typename InvocationDispatcher<void, I>::AP in_invocationDispatcher,
                                 const String &name,
                                 VerifiableList *parent)
      : AbstractDynamicChainingMockImpl<void, I>(in_invocationDispatcher, name, parent)
    {}

    AbstractDynamicChainingMock( const String &name,
                                 VerifiableList *parent)
      : AbstractDynamicChainingMockImpl<void, I>(new FIFOInvocationDispatcher<void,I>, name, parent)
    {}

  protected:

    virtual void mockInvocation( const I &invocation )
    {
      if ( this->failure.get() != 0 )
        MOCKPP_THROW(*this->failure.get());

      MOCKPP_TRY
      {
        this->invocationDispatcher->dispatch( invocation );
      }

#ifndef MOCKPP_NO_EXCEPTIONS
      catch ( const AssertionFailedError & assertion )
      {
        DynamicChainingMockError<void, I> dme( this,
                                               invocation,
                                               this->invocationDispatcher.get(),
                                               assertion.getMessage() );
        this->failure.reset( new AssertionFailedError(__LINE__, __FILE__, dme.getMessage()));
        MOCKPP_THROW(*this->failure.get());
      }
#endif // MOCKPP_NO_EXCEPTIONS
    }
};


#define MOCKPP_ABSTRACTDYNAMICCHAININGMOCK_PTI_IMPL(I)
#define MOCKPP_ABSTRACTDYNAMICCHAININGMOCK_PTI_DECL(I)


#else // MOCKPP_PTI_WEAKNESS Partial Template Instantiation Weakness


#define MOCKPP_ABSTRACTDYNAMICCHAININGMOCK_PTI_DECL(I) \
MOCKPP_NS_START \
template<> \
void MOCKPP_NS::AbstractDynamicChainingMock<void, I >; \
}


#define MOCKPP_ABSTRACTDYNAMICCHAININGMOCK_PTI_IMPL(I) \
MOCKPP_NS_START \
template<> \
class AbstractDynamicChainingMock<void, I> : public AbstractDynamicChainingMockImpl<void, I> \
{ \
 public: \
  AbstractDynamicChainingMock( InvocationDispatcher<void, I>::AP in_invocationDispatcher, \
                               const String &name, \
                               VerifiableList *parent) \
    : AbstractDynamicChainingMockImpl<void, I>(in_invocationDispatcher, name, parent) \
  {} \
  \
  AbstractDynamicChainingMock( const String &name, \
                               VerifiableList *parent) \
    : AbstractDynamicChainingMockImpl<void, I>(new FIFOInvocationDispatcher<void,I>, name, parent) \
  {} \
  \
  void mockInvocation( const I &invocation ) \
  { \
    if ( this->failure.get() != 0 ) \
      MOCKPP_THROW(*this->failure.get()); \
  \
    try \
    { \
      this->invocationDispatcher->dispatch( invocation ); \
    } \
  \
    catch ( const AssertionFailedError & assertion ) \
    { \
      DynamicChainingMockError<void, I > dme( this, \
                                            invocation, \
                                            this->invocationDispatcher.get(), \
                                            assertion.getMessage() ); \
      this->failure.reset( new AssertionFailedError(__LINE__, __FILE__, dme.getMessage())); \
      MOCKPP_THROW(*this->failure.get()); \
    } \
  } \
}; \
MOCKPP_NS_END


#endif


MOCKPP_NS_END


#endif // MOCKPP_ABSTRACTDYNAMICCHAININGMOCK_H

---