ExpectationConglomeration.h

Go to the documentation of this file.

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

   begin                : Sat Dec 21 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_EXPECTATIONCONGLOMERATION_H
#define MOCKPP_EXPECTATIONCONGLOMERATION_H

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

#include MOCKPP_ALGORITHM_H
#include MOCKPP_SET_H
#include MOCKPP_VECTOR_H

#include <mockpp/AbstractExpectationCollection.h>
#include <mockpp/util/AssertMo.h>
#include <mockpp/ExpectationBoundary.h>


MOCKPP_NS_START


template <class T>
class ExpectationConglomeration : public AbstractExpectationCollection<T>
{

  public:

    ExpectationConglomeration(const String &name, VerifiableList *parent = 0)
      : AbstractExpectationCollection<T>(name, parent),
        expectNothing(false),
        haveActualValue(false)
    {
    }


    void addActual(const T &actualItem)
    {
      actualItems.insert(actualItem);
      haveActualValue = true;

      if (this->shouldCheckImmediately())
        checkImmediateValue(actualItem);
    }


    template <class I>
    void addActual(I items, I end)
    {
      for ( /* -- */; items != end; ++items)
        addActual(*items);
    }


    ExpectationConglomeration& addExpected(const T &expectedItem)
    {
      expectedSingleItems.push_back(expectedItem);
      expectNothing = false;
      this->setHasExpectations();
      return *this;
    }


    ExpectationConglomeration& addExpectedBoundary(const T &lower, const T &upper)
    {
      expectedBoundaryItems.push_back(Boundary (lower, upper));
      expectNothing = false;
      this->setHasExpectations();
      return *this;
    }


    template <class I>
    ExpectationConglomeration& addExpected(I items, I end)
    {
      for ( /* -- */; items != end; ++items)
        addExpected(*items);
      return *this;
    }


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


    virtual void clearActual()
    {
      haveActualValue = false;
      actualItems.clear();
    }


    virtual void verify()
    {
      if( expectNothing)
      {
        String fmt = mockpp_i18n(MOCKPP_PCHAR("%1 expected no value."));
        fmt << 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 did not receive the expected item set."));
        fmt << this->getVerifiableName();
        typename MOCKPP_STL::set<T>::const_iterator it;
        for (it = actualItems.begin(); it != actualItems.end(); ++it)
          MOCKPP_ASSERT_TRUE_MESSAGE(fmt, contains(*it));
      }
    }


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


    bool contains(const T &val) const
    {
      if (MOCKPP_STL::find(expectedSingleItems.begin(), expectedSingleItems.end(), val) != expectedSingleItems.end())
         return true;

      typename MOCKPP_STL::vector<Boundary>::const_iterator it;
      for (it = expectedBoundaryItems.begin(); it != expectedBoundaryItems.end(); ++it)
        if ( (*it).contains(val))
          return true;

      return false;
    }


    AbstractExpectationCollection<T>::getVerifiableName;

  protected:

    virtual void clearExpectation()
    {
      this->clearHasExpectations();
      expectedBoundaryItems.clear();
      expectedSingleItems.clear();
    }


    virtual void checkImmediateValue(const T &actualItem) const
    {
      String fmt = mockpp_i18n(MOCKPP_PCHAR("%1 did not receive an expected item.\nUnexpected: %2"));
      fmt << getVerifiableName() << actualItem;

      MOCKPP_ASSERT_TRUE_MESSAGE(fmt, contains(actualItem));
    }


  private:

    class Boundary
    {
      public:

        Boundary (const T &low, const T &up)
         : lower(low)
         , upper(up)
        {
        }

        bool contains(const T &val) const
        {
          return val <= upper && val >= lower;
        }

      private:

       T lower;
       T upper;
    };

    MOCKPP_STL::set<T>           actualItems;
    MOCKPP_STL::vector<T>        expectedSingleItems;
    MOCKPP_STL::vector<Boundary> expectedBoundaryItems;
    bool                  expectNothing;
    bool                  haveActualValue;
};



MOCKPP_NS_END


#endif // MOCKPP_EXPECTATIONCONGLOMERATION_H

---