ExpectationBoundary.h

Go to the documentation of this file.

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

   begin                : Thu Dec 17 2002
   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.

 **/

#ifndef MOCKPP_EXPECTATIONBOUNDARY_H
#define MOCKPP_EXPECTATIONBOUNDARY_H


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

#include <mockpp/AbstractExpectation.h>
#include <mockpp/util/AssertMo.h>


MOCKPP_NS_START


template <class T>
class ExpectationBoundary : public AbstractExpectation<T>
{
  private:

    T    lower_bound;
    T    upper_bound;
    T    actualValue;
    bool haveActualValue;
    bool expectNothing;

  public:

    ExpectationBoundary(const String &name, VerifiableList *parent = 0)
     : AbstractExpectation<T>(name, parent),
       expectNothing(false)
    {
        clearActual();
    }


    void setActual(const T &value )
    {
      actualValue = value;
      haveActualValue = true;
      if (this->shouldCheckImmediately())
      {
        verify();
      }
    }


    void setExpected(const T &lower, const T &upper )
    {
      MOCKPP_ASSERT_TRUE(lower <= upper);
      lower_bound = lower;
      upper_bound = upper;
      expectNothing = false;
      this->setHasExpectations();
    }


#if MOCKPP_BOUNDARY_DELTA != 0

    void setExpectedDelta(const T &median, const T &delta )
    {
      T lower = median - delta;
      T upper = median + delta;
      if (lower <= upper)
        setExpected(lower, upper);
      else
        setExpected(upper, lower);
    }
#endif


    virtual void reset()
    {
      this->clearFailOnVerify();
      clearActual();
      clearExpectation();
      expectNothing = false;
    }


    virtual void clearActual()
    {
      haveActualValue = false;
      lower_bound = 0;
      upper_bound = 0;
      actualValue = 0;
    }


    virtual void setExpectNothing()
    {
      expectNothing = true;
      clearActual();
      this->setHasExpectations();
    }


    virtual void verify()
    {
      if( expectNothing )
      {
        String fmt = mockpp_i18n(MOCKPP_PCHAR("%1 expected no value."));
        fmt << this->getVerifiableName();

        MOCKPP_ASSERT_FALSE_MESSAGE(fmt, haveActualValue );
      }
      else
      {
        if (!this->hasExpectations() )
          return;

        String fmt = mockpp_i18n(MOCKPP_PCHAR("%1 expected a value."));
        fmt << this->getVerifiableName();
        MOCKPP_ASSERT_TRUE_MESSAGE(fmt, haveActualValue );

        fmt = mockpp_i18n(MOCKPP_PCHAR("%1 received a value of %2 which is less than the expected value of %3."));
        fmt << this->getVerifiableName() << actualValue << lower_bound;
        MOCKPP_ASSERT_TRUE_MESSAGE(fmt, lower_bound <= actualValue );

        fmt = mockpp_i18n(MOCKPP_PCHAR("%1 received a value of %2 which is greater than the expected value of %3."));
        fmt << this->getVerifiableName() << actualValue << upper_bound;
        MOCKPP_ASSERT_TRUE_MESSAGE(fmt, actualValue <= upper_bound);
      }
    }

  protected:

    virtual void clearExpectation()
    {
      this->clearHasExpectations();
    }
};


MOCKPP_NS_END


#endif // MOCKPP_EXPECTATIONBOUNDARY_H

---