AbstractInvocationDispatcher.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_ABSTRACTINVOCATIONDISPATCHER_H
#define MOCKPP_ABSTRACTINVOCATIONDISPATCHER_H

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

#include MOCKPP_VECTOR_H

#include <mockpp/chaining/InvocationDispatcher.h>
#include <mockpp/chaining/Invokable.h>

#include <mockpp/stub/StubHolder.h>

#include <mockpp/stub/TestFailureStub.h>


MOCKPP_NS_START


template <typename R,   // Returntype
          typename I>   // Invocation
class AbstractInvocationDispatcher : public InvocationDispatcher<R, I>
{
  protected:

    typedef Invokable<R, I>    Item;             
    typedef MOCKPP_STL::vector<Item*> List;      

    typedef typename List::iterator          Iterator;         
    typedef typename List::reverse_iterator  ReverseIterator;  
    typedef typename List::const_iterator    ConstIterator;    

  public:

    AbstractInvocationDispatcher()
        : defaultStub( new TestFailureStub<R, I>( MOCKPP_PCHAR( "unexpected invocation" ) ) )
    {}

    virtual ~AbstractInvocationDispatcher()
    {
      for ( unsigned i = 0; i < invokables.size(); ++i )
        delete invokables[ i ];
      invokables.clear();
    }

    virtual void setDefaultStub( const MOCKPP_NS::StubHolder<R, I> &in_defaultStub )
    {
      defaultStub = in_defaultStub;
    }

    virtual void add( typename Invokable<R, I>::AP invokable )
    {
      invokables.push_back( invokable.release() );
    }

    virtual void verify()
    {
      for ( unsigned i = 0; i < invokables.size(); ++i )
        invokables[ i ] ->verify();
    }

    virtual void reset()
    {
      for ( unsigned i = 0; i < invokables.size(); ++i )
        delete invokables[ i ];
      invokables.clear();
    }

    virtual String describeTo( String &buffer ) const
    {
      if ( anyInvokableHasDescription() )
        writeInvokablesTo( buffer );
      else
        buffer += MOCKPP_PCHAR( "no expectations set" );

      return buffer;
    }

  private:

    void writeInvokablesTo( String &out_result ) const
    {
      unsigned lines = 0;
      String result;
      for ( unsigned i = 0; i < invokables.size(); ++i )
      {
        if ( invokables[ i ] ->hasDescription() )
        {
          ++lines;
          String s;
          invokables[ i ] ->describeTo( s );
          if (lines > 1)
            s.insert(0, MOCKPP_PCHAR(" - "));
          result += s + MOCKPP_PCHAR( "\n" );
        }
      }

      if (lines > 1)
        out_result += MOCKPP_PCHAR("\n - ");
      out_result += result;
    }

    bool anyInvokableHasDescription() const
    {
      for ( unsigned i = 0; i < invokables.size(); ++i )
        if ( invokables[ i ] ->hasDescription() )
          return true;
      return false;
    }

  protected:

    typename Stub<R, I>::AP defaultStub;  
    List                    invokables;   
};


MOCKPP_NS_END


#endif // MOCKPP_ABSTRACTINVOCATIONDISPATCHER_H

---