ExpectationList.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_EXPECTATIONLIST_H
#define MOCKPP_EXPECTATIONLIST_H

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

#include MOCKPP_ALGORITHM_H
#include MOCKPP_VECTOR_H

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


MOCKPP_NS_START


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

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


    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 did not receive the expected item list."));
        fmt << this->getVerifiableName();

        MOCKPP_ASSERT_TRUE_MESSAGE(fmt, actualItems == expectedItems);
      }
    }


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

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


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


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


    void balanceActual()
    {
      if (actualItems.size() < expectedItems.size())
      {
        haveActualValue = true;
        actualItems.push_back(expectedItems[actualItems.size()]);
      }
    }


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


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


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


    unsigned size() const
    {
      return expectedItems.size();
    }


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


  protected:

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


    void checkImmediateValue(const T &actualItem) const
    {
      unsigned itemsize = actualItems.size();
      String fmt = mockpp_i18n(MOCKPP_PCHAR("%1 had different item sizes.\n")
                        MOCKPP_PCHAR("Expected %2 items but received %3 when adding %4."));
      fmt << this->getVerifiableName() << expectedItems.size() << itemsize << actualItem;

      MOCKPP_ASSERT_TRUE_MESSAGE(fmt, expectedItems.size() >= itemsize);

      fmt = mockpp_i18n(MOCKPP_PCHAR("%1 added item[%2] does not match. %3 != %4."));
      fmt << this->getVerifiableName() << itemsize << expectedItems[(itemsize - 1)] << actualItem;

      this->assertEquals(fmt, actualItem, expectedItems[(itemsize - 1)]);
    }

  private:

    MOCKPP_STL::vector<T> actualItems;
    MOCKPP_STL::vector<T> expectedItems;
    bool           expectNothing;
    bool           haveActualValue;
};


MOCKPP_NS_END


#endif // MOCKPP_EXPECTATIONLIST_H

---