//
// Listing 4: "Chainable" Mock-Objekte
//

#include "interface.h"
#include "consumer.h"

#include <mockpp/ChainableMockObject.h>
#include <mockpp/chaining/ChainingMockObjectSupport.h>

#include <exception>
#include <iostream>

using namespace mockpp;


class ChainMock : public Interface
                , public mockpp::ChainableMockObject
{
  public:

    ChainMock()
      : mockpp::ChainableMockObject(MOCKPP_PCHAR("ChainMock"), 0)
      , MOCKPP_CONSTRUCT_MEMBERS_FOR_VOID_CHAINABLE_EXT1(open, ext)
      , MOCKPP_CONSTRUCT_MEMBERS_FOR_CHAINABLE0(read)
      , MOCKPP_CONSTRUCT_MEMBERS_FOR_VOID_CHAINABLE_EXT1(write, ext)
      , MOCKPP_CONSTRUCT_MEMBERS_FOR_VOID_CHAINABLE0(close)
    {}

    MOCKPP_VOID_CHAINABLE_EXT1(ChainMock, open, const std::string &,
                                          ext,  std::string);

    MOCKPP_CHAINABLE0(ChainMock, std::string, read);

    MOCKPP_VOID_CHAINABLE_EXT1(ChainMock, write, const std::string &,
                                          ext,   std::string);

    MOCKPP_VOID_CHAINABLE0(ChainMock, close);
};


int main(int argc, char **argv)
{
  try
  {
    ChainMock mock;
    MOCKPP_CHAINER_FOR_EXT(ChainMock, open, ext) open_chainer (&mock);
    MOCKPP_CHAINER_FOR(ChainMock, read) read_chainer (&mock);
    MOCKPP_CHAINER_FOR_EXT(ChainMock, write, ext) write_chainer (&mock);
    MOCKPP_CHAINER_FOR(ChainMock, close) close_chainer (&mock);

    // Erwartungen für das Einlesen der Datei
    open_chainer.expects(once())
                .with(eq(std::string("datei1.lst")))
                .before(MOCKPP_PCHAR("reader"));

    read_chainer.stubs()
                .will(onConsecutiveCalls(new ReturnStub<std::string>("Datenpaket-1"),
                                         new ReturnStub<std::string>("Datenpaket-2"),
                                         new ReturnStub<std::string>("Datenpaket-3")))
                .id(MOCKPP_PCHAR("reader"));

    close_chainer.expects(once())
                 .after(MOCKPP_PCHAR("reader"));


    // Erwartungen für das Zurückschreiben der Datei
    open_chainer.expects(once())
                .with(eq(std::string("datei1.lst")))
                .before(MOCKPP_PCHAR("writer"));

    write_chainer.expects(once())
                 .with(eq(std::string("Datenpaket-1/fertig")));
    write_chainer.expects(once())
                 .with(eq(std::string("Datenpaket-2/fertig")));
    write_chainer.expects(once())
                 .with(eq(std::string("Datenpaket-3/fertig")))
                 .id(MOCKPP_PCHAR("writer"));

    close_chainer.expects(once())
                 .after(MOCKPP_PCHAR("writer"));


    // Consumer-Klasse ablaufen lassen
    std::cout << "Start der Tests" << std::endl;

    Consumer consumer(&mock);
    consumer.load();
    consumer.process();
    consumer.save();

    std::cout << "Ende der Tests" << std::endl;

    // alle restlichen Bedingungen prüfen
    mock.verify();
    std::cout << "Alle Tests wurden fehlerfrei durchlaufen" << std::endl;
  }
  catch(std::exception &ex)
  {
    std::cout << std::endl
              << "Fehler aufgetreten.\n" << ex.what() << std::endl
              << std::endl;
  }
}