InvocationMocker.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_INVOCATIONMOCKER_H
#define MOCKPP_INVOCATIONMOCKER_H


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

#include MOCKPP_VECTOR_H

#include <mockpp/chaining/StubMatchersCollection.h>
#include <mockpp/chaining/Invokable.h>
#include <mockpp/chaining/InvocationMocker.h>

#include <mockpp/matcher/ArgumentsMatcher.h>

#include <mockpp/compat/AssertionFailedError.h>

#include <mockpp/stub/DefaultResultStub.h>
#include <mockpp/stub/VoidStub.h>
#include <mockpp/stub/StubHolder.h>


MOCKPP_NS_START

template <typename R,     // Returntype
          typename I>     // Invocation
class InvocationMockerBase : public Invokable<R, I>,
                             public StubMatchersCollection<R, I>
{
  public:

    class DescriberBase;

  protected:

    InvocationMockerBase( AutoPointer<DescriberBase> in_describer,
                          const StubHolder<R, I> &defaultStub)
      : stub(defaultStub)
      , describer(in_describer)
    {
    }

  public:

#ifdef MOCKPP_NO_TYPENAME_FOR_STL_NS
    typedef  MOCKPP_STL::vector<InvocationMatcher<I>*> List;           
#else
    typedef typename MOCKPP_STL::vector<InvocationMatcher<I>*> List;   
#endif
    typedef typename List::iterator Iterator;                          
    typedef typename List::const_iterator ConstIterator;               

    virtual ~InvocationMockerBase()
    {
      reset();
    }

    virtual void reset()
    {
      for ( Iterator it = matchers.begin(); it != matchers.end(); ++it )
        delete (*it);
      matchers.clear();
    }

    virtual bool matches( const I &invocation )
    {
      for ( Iterator it = matchers.begin(); it != matchers.end(); ++it )
      {
        if ( !( *it ) ->matches( invocation ) )
          return false;
      }
      return true;
    }

    virtual void verify()
    {
      MOCKPP_TRY
      {
        for ( ConstIterator it = matchers.begin(); it != matchers.end(); ++it )
          ( *it ) ->verify();
      }

#ifndef MOCKPP_NO_EXCEPTIONS
      catch ( const AssertionFailedError & error )
      {
        assertionFailed( __LINE__, __FILE__,
                                    error.getMessage() + MOCKPP_PCHAR( "\n" ) + this->toString() );
      }
#endif // MOCKPP_NO_EXCEPTIONS
    }

    virtual void setName( const String &in_name )
    {
      name = in_name;
    }

    virtual void addMatcher(  const MatcherHolder<I> &holder )
    {
      typename InvocationMatcher<I>::AP matcher = holder;
      matchers.push_back( matcher.release() );
    }

    virtual void setStub( const StubHolder<R, I> &in_stub )
    {
      stub = in_stub;
    }

    virtual bool hasDescription()
    {
      return describer->hasDescription();
    }

    virtual String describeTo( String &buffer ) const
    {
      return describer->describeTo( buffer, matchers, stub.get(), name );
    }

    //

    class DescriberBase
    {
      public:

        typedef AutoPointer<DescriberBase> AP;   

        virtual ~DescriberBase()
        {
        }

        virtual bool hasDescription() = 0;

        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 = 0;

        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
                           TypelessStub<R>* stub,
                           const String &name ) const
        {
          typename Stub<R, I>::AP adap = new TypelessStubAdapter<R, I> (stub, false);
          return describeTo(result, matchers, adap.get(), name);
        }
    };


    class Describer : public DescriberBase
    {
      public:

        virtual bool hasDescription()
        {
          return true;
        }

        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
        {
          const String SEP = MOCKPP_PCHAR( ", " );
          bool needSeparator = false;

          for ( ConstIterator it = matchers.begin(); it != matchers.end(); ++it )
          {
            InvocationMatcher<I>* invmatcher = *it;

            if ( !invmatcher->hasDescription() )
              continue;

            if ( needSeparator )
              result += SEP;

            invmatcher->describeTo( result );
            needSeparator = true;
          }

          if ( needSeparator )
            result += SEP;

          stub->describeTo( result );

          if ( name.length() != 0 )
            result += MOCKPP_PCHAR( " [" ) + name + MOCKPP_PCHAR( "]" );

          return result;
        }
    };

    //

    class DefaultDescriber : public DescriberBase
    {
      public:

        virtual bool hasDescription()
        {
          return true;
        }

        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
        {
          typename InvocationMockerBase<R, I>::ConstIterator it;
          for (it = matchers.begin(); it != matchers.end(); ++it )
          {
            InvocationMatcher<I>* matcher = *it;

            if ( matcher->hasDescription() )
            {
              matcher->describeTo( result );
              result += MOCKPP_PCHAR( ", " );
            }
          }

          stub->describeTo( result );

          if ( name.length() != 0 )
            result += MOCKPP_PCHAR( " [" ) + name + MOCKPP_PCHAR( "]" );
          return result;
        }
    };

  protected:

    List                      matchers;  
    typename Stub<R, I>::AP   stub;      

  private:

    String                      name;
    AutoPointer<DescriberBase>  describer;
};


template <typename R,     // Returntype
          typename I>     // Invocation
class InvocationMocker : public InvocationMockerBase<R, I>
{
    typedef typename InvocationMockerBase<R, I>::Iterator Iterator;                
    typedef typename InvocationMockerBase<R, I>::ConstIterator ConstIterator;      

  public:

    typedef typename InvocationMockerBase<R, I>::Describer Describer;                 
    typedef typename InvocationMockerBase<R, I>::DescriberBase DescriberBase;         
    typedef typename InvocationMockerBase<R, I>::DefaultDescriber DefaultDescriber;   

    InvocationMocker()
      : InvocationMockerBase<R, I>( new typename InvocationMockerBase<R, I>::DefaultDescriber(),
                                    new TypelessStubAdapter<R, I>(new DefaultResultStub<R> ))
    {
    }

    InvocationMocker( AutoPointer<DescriberBase> in_describer )
        : InvocationMockerBase<R, I>( in_describer,
                                      new TypelessStubAdapter<R, I>(new DefaultResultStub<R> ))
    {
    }

    virtual R invoke( const I &invocation )
    {
      for ( Iterator it = this->matchers.begin(); it != this->matchers.end(); ++it )
        ( *it ) ->incInvoked( invocation );
      return this->stub->invoke( invocation );
    }
};


#ifndef MOCKPP_PTI_WEAKNESS // Partial Template Instantiation Weakness


template <typename I>     // Invocation
class InvocationMocker<void, I> : public InvocationMockerBase<void, I>
{
    typedef typename InvocationMockerBase<void, I>::Iterator Iterator;            
    typedef typename InvocationMockerBase<void, I>::ConstIterator ConstIterator;  

  public:

    typedef typename InvocationMockerBase<void, I>::Describer Describer;                
    typedef typename InvocationMockerBase<void, I>::DescriberBase DescriberBase;        
    typedef typename InvocationMockerBase<void, I>::DefaultDescriber DefaultDescriber;  

    InvocationMocker<void, I>()
        : InvocationMockerBase<void, I>( new DefaultDescriber(),
                                         new TypelessStubAdapter<void, I>(new VoidStub))
    {
    }

    InvocationMocker<void, I>( AutoPointer<DescriberBase> in_describer )
        : InvocationMockerBase<void, I>( in_describer,
                                         new TypelessStubAdapter<void, I>(new VoidStub))
    {
    }

    virtual void invoke( const I &invocation )
    {
      for ( Iterator it = this->matchers.begin(); it != this->matchers.end(); ++it )
        ( *it ) ->incInvoked( invocation );
      this->stub->invoke( invocation );
    }
};


#define MOCKPP_INVOCATIONMOCKER_PTI_IMPL(I)
#define MOCKPP_INVOCATIONMOCKER_PTI_DECL(I)


#else // MOCKPP_PTI_WEAKNESS Partial Template Instantiation Weakness


#define MOCKPP_INVOCATIONMOCKER_PTI_DECL(I) \
MOCKPP_NS_START \
template<> \
class InvocationMocker<void, I>; \
}


#define MOCKPP_INVOCATIONMOCKER_PTI_IMPL(I) \
MOCKPP_NS_START \
template<> \
class InvocationMocker<void, I> : public InvocationMockerBase<void, I> \
{ \
 public: \
  InvocationMocker<void, I >() \
      : InvocationMockerBase<void, I >( new InvocationMockerBase<void, I >::DefaultDescriber(), \
                                        new TypelessStubAdapter<void, I >(new VoidStub)) \
  {} \
  \
  InvocationMocker<void, I >(\
    AutoPointer<MOCKPP_NS::InvocationMockerBase<void, I >::DescriberBase> in_describer ) \
      : InvocationMockerBase<void, I >( in_describer, \
                                        new TypelessStubAdapter<void, I >(new VoidStub)) \
  {}  \
  \
  void invoke( const I &invocation ) \
  { \
    for ( Iterator it = this->matchers.begin(); it != this->matchers.end(); ++it ) \
      ( *it ) ->incInvoked( invocation ); \
    this->stub->invoke( invocation ); \
  } \
}; \
MOCKPP_NS_END


#endif // MOCKPP_PTI_WEAKNESS


MOCKPP_NS_END

#endif // MOCKPP_INVOCATIONMOCKER_H

---