ChainingMockObjectSupport.h

Go to the documentation of this file.

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

   begin                : Sat Aug 21 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_CHAININGMOCKOBJECTSUPPORT_H
#define MOCKPP_CHAININGMOCKOBJECTSUPPORT_H


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

#include <mockpp/Throwable.h>

#include <mockpp/util/AutoPointer.h>

#include <mockpp/constraint/And.h>
#include <mockpp/constraint/Or.h>
#include <mockpp/constraint/IsEqual.h>
#include <mockpp/constraint/IsSame.h>
#include <mockpp/constraint/IsNot.h>
#include <mockpp/constraint/IsCloseTo.h>
#include <mockpp/constraint/StringContains.h>
#include <mockpp/constraint/StringStartsWith.h>
#include <mockpp/constraint/StringEndsWith.h>
#include <mockpp/constraint/IsInstanceOf.h>
#include <mockpp/constraint/IsGreaterThan.h>
#include <mockpp/constraint/IsGreaterOrEqual.h>
#include <mockpp/constraint/IsLessThan.h>
#include <mockpp/constraint/IsLessOrEqual.h>
#include <mockpp/constraint/OutBound.h>

#include <mockpp/chaining/CoreMock.h>

#include <mockpp/stub/ThrowStub.h>
#include <mockpp/stub/ReturnStub.h>
#include <mockpp/stub/RandomStub.h>
#include <mockpp/stub/ReturnObjectListStub.h>

#include <mockpp/matcher/TypelessMatcher.h>


MOCKPP_NS_START

MOCKPP_API_DECL(TypelessConstraint::AP) any();


MOCKPP_API_DECL(TypelessConstraint::AP) nothing();


template <typename T>
typename Constraint<T>::AP
outBound( const T& op )
{
  return new OutBound<T>( op );
}


template <typename T>
typename Constraint<T>::AP
eq( const T& op )
{
  return new IsEqual<T>( op );
}


template <typename T>
typename Constraint<T>::AP
ne( const T& op )
{
  return new IsNot<T>( new IsEqual<T>( op ) );
}


template <typename T>
typename Constraint<T>::AP
eq( const T &operand, const T &deviation )
{
  return new IsCloseTo<T>( operand, deviation );
}


template <typename T>
typename Constraint<T>::AP
le( const T &value )
{
  return new IsLessOrEqual<T>( value );
}


template <typename T>
typename Constraint<T>::AP
lt( const T &value )
{
  return new IsLessThan<T>( value );
}


template <typename T>
typename Constraint<T>::AP
gt( const T &value )
{
  return new IsGreaterThan<T>( value );
}


template <typename T>
typename Constraint<T>::AP
ge( const T &value )
{
  return new IsGreaterOrEqual<T>( value );
}


template <typename T>
typename Constraint<T>::AP
same( const T &operand )
{
  return new IsSame<T>( operand );
}


#ifndef MOCKPP_NO_RTTI

template <typename ROOT,
          typename DERIVED>
typename Constraint<ROOT*>::AP
isA( const DERIVED & /*operandClass*/ )
{
  return new IsInstanceOf<ROOT, DERIVED>();
}

template <typename ROOT,
          typename DERIVED>
typename Constraint<ROOT*>::AP
isA()
{
  return new IsInstanceOf<ROOT, DERIVED>();
}

#endif // MOCKPP_NO_RTTI


template <typename S>  // MOCKPP_STL::basic_string<char_type>
typename Constraint<S>::AP
stringContains( const S &substring )
{
  return new StringContains<S>( substring );
}


template <typename S>  // MOCKPP_STL::basic_string<char_type>
typename Constraint<S>::AP
startsWith( const S &substring )
{
  return new StringStartsWith<S>( substring );
}


template <typename S>  // MOCKPP_STL::basic_string<char_type>
typename Constraint<S>::AP
endsWith( const S &substring )
{
  return new StringEndsWith<S>( substring );
}


template <typename PCS> // pointer to const char_type
typename Constraint<MOCKPP_STL::basic_string<PCS> >::AP
stringContains( const PCS *substring )
{
  return new StringContains<MOCKPP_STL::basic_string<PCS> >( substring );
}


template <typename T>
typename Constraint<T>::AP
logic_not( const ConstraintHolder<T> &c )
{
  return new IsNot<T>( c );
}


template <typename T>
typename Constraint<T>::AP
logic_and( const ConstraintHolder<T> &left,
           const ConstraintHolder<T> &right,
           bool shortcut = true )
{
  return new And<T>( left, right, shortcut );
}


template <typename T>
typename Constraint<T>::AP
logic_or( const ConstraintHolder<T> &left,
          const ConstraintHolder<T> &right,
          bool shortcut = true )
{
  return new Or<T>( left, right, shortcut );
}


template <typename T>   // Invocation
typename TypelessStub<T>::AP returnValue( const T &o )
{
  return new ReturnStub<T>( o );
}


template <typename R, typename T>   // Invocation
typename TypelessStub<R>::AP randomValue( const T &max )
{
  return new RandomStub<R, T>( max );
}


template <typename R, typename T>   // Invocation
typename TypelessStub<R>::AP randomValue( const T &min, const T &max )
{
  return new RandomStub<R, T>( min, max );
}


template <typename T,
          typename I >   // Invocation
typename TypelessStub<T>::AP returnValue( I start, I end )
{
  return new ReturnObjectListStub<T>( start, end );
}


MOCKPP_API_DECL(TypelessStub<void>::AP) isVoid( );


template <typename R,   // ReturnType
          typename T>   // Invocation
typename TypelessStub<R>::AP throwException( const T &val )
{
  return new ThrowStub<R>( make_throwable(val) );
}


MOCKPP_API_DECL(AutoPointer<TypelessMatcher>) once();


MOCKPP_API_DECL(AutoPointer<TypelessMatcher>) atLeastOnce();


MOCKPP_API_DECL(AutoPointer<TypelessMatcher>) unlimited();


MOCKPP_API_DECL(AutoPointer<TypelessMatcher>) atMost( int expectedCount );


MOCKPP_API_DECL(AutoPointer<TypelessMatcher>) atLeast(int expectedCount);


MOCKPP_API_DECL(AutoPointer<TypelessMatcher>) exactly( int expectedCount );


MOCKPP_API_DECL(AutoPointer<TypelessMatcher>) never();


MOCKPP_API_DECL(AutoPointer<TypelessMatcher> never)( const String &errorMessage );


MOCKPP_NS_END


#include "OnConsecutiveCalls.h"
#include "ReturnValueAndTrigger.h"
#include "ReturnValueAndCall.h"


#ifdef MOCKPP_IMPORT_ABBREVIATED
using MOCKPP_NS::any;
using MOCKPP_NS::nothing;
using MOCKPP_NS::eq;
using MOCKPP_NS::ne;
using MOCKPP_NS::le;
using MOCKPP_NS::ge;
using MOCKPP_NS::gt;
using MOCKPP_NS::lt;
using MOCKPP_NS::same;
#ifndef MOCKPP_NO_RTTI
using MOCKPP_NS::isA;
#endif
using MOCKPP_NS::stringContains;
using MOCKPP_NS::startsWith;
using MOCKPP_NS::endsWith;
using MOCKPP_NS::logic_not;
using MOCKPP_NS::logic_and;
using MOCKPP_NS::logic_or;
using MOCKPP_NS::returnValue;
using MOCKPP_NS::returnValueAndTrigger;
using MOCKPP_NS::trigger;
using MOCKPP_NS::returnValueAndCall;
using MOCKPP_NS::call;
using MOCKPP_NS::onConsecutiveCalls;
using MOCKPP_NS::throwException;
using MOCKPP_NS::once;
using MOCKPP_NS::atLeastOnce;
using MOCKPP_NS::atMost;
using MOCKPP_NS::atLeast;
using MOCKPP_NS::exactly;
using MOCKPP_NS::never;
using MOCKPP_NS::isVoid;
using MOCKPP_NS::unlimited;
using MOCKPP_NS::outBound;
#endif


#endif // MOCKPP_CHAININGMOCKOBJECTSUPPORT_H

---