/*
  CommandEquality(Test)  -  verify equality comparisons on command's subsystems

  Copyright (C)         Lumiera.org
    2009,               Hermann Vosseler <Ichthyostega@web.de>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU 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 General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

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

/** @file command-equality-test.cpp
 ** unit test \ref CommandEquality_test
 */


#include "lib/test/run.hpp"
#include "lib/test/test-helper.hpp"
#include "steam/control/command-def.hpp"
#include "steam/control/command-mutation.hpp"
#include "steam/control/argument-erasure.hpp"
#include "steam/control/command-storage-holder.hpp"
#include "steam/control/command-simple-closure.hpp"
#include "steam/control/memento-tie.hpp"
#include "lib/meta/tuple-helper.hpp"
#include "lib/format-cout.hpp"
#include "lib/symbol.hpp"
#include "lib/util.hpp"

#include <functional>
#include <string>
#include <tuple>

namespace steam {
namespace control {
namespace test    {
  
  
  
  using namespace lib::meta;
  using lib::Symbol;
  using util::isnil;
  using util::isSameObject;
  
  using std::function;
  using std::bind;
  using std::string;
  using std::make_tuple;
  
  
  
  namespace {
    
    string check_;
    
    Symbol COMMAND1 ("test.equalityCommand1");
    Symbol COMMAND2 ("test.equalityCommand2");
    
    const string MARK_1 ("|_1_");
    const string MARK_2 ("|_2_");
    
    void oper_1 (char par)             { check_ += MARK_1 + par; }
    void oper_2 (char par)             { check_ += MARK_2 + par; }
    
    string capt_1 (char par)           { return check_ + MARK_1 + "|"+par+"|"; }
    string capt_2 (char par)           { return check_ + MARK_2 + "|"+par+"|"; }
    
    void undo_1 (char par, string mem) { check_ = mem + MARK_1 + par + "|";}
    void undo_2 (char par, string mem) { check_ = mem + MARK_2 + par + "|";}
    
    
    typedef void   Sig_oper(char);
    typedef string Sig_capt(char);
    typedef void   Sig_undo(char,string);
    
    typedef function<Sig_oper> Fun_o;
    typedef function<Sig_capt> Fun_c;
    typedef function<Sig_undo> Fun_u;
    
    using ArgTuple  = Tuple<Types<char>>;
    using ArgHolder = OpClosure<Sig_oper>;
    using MemHolder = MementoTie<Sig_oper, string>;
    using Closure   = SimpleClosure<Sig_oper>;
  }
  
  
  
  /*************************************************************************************//**
   * @test cover command equality detection.
   * Two commands are deemed equivalent, if they are based on the same CommandImpl record.
   * This means, we only rely on the _identity_ of those commands, but do not check the
   * _equivalence_ of their backing implementations. The latter can not be possibly
   * implemented in a totally airtight fashion, and for this reason, the C++ standard
   * decided not to support comparison between std::function objects.
   * 
   * @see  control::Command
   * @see  control::CommandImpl
   * @see  command-basic-test.hpp
   */
  class CommandEquality_test : public Test
    {
      
      virtual void
      run (Arg) 
        {
          CHECK (&oper_1 != &oper_2);
          CHECK (&capt_1 != &capt_2);
          CHECK (&undo_1 != &undo_2);
          
          CommandDef (COMMAND1)
            .operation (oper_1)
            .captureUndo (capt_1)
            .undoOperation (undo_1)
            ;
          CommandDef (COMMAND2)
            .operation (oper_2)
            .captureUndo (capt_2)
            .undoOperation (undo_2)
            ;
          
          Command c1 = Command::get(COMMAND1);
          Command c2 = Command::get(COMMAND2);
          CHECK (c1 == c1);
          CHECK (c1 != c2);
          CHECK (c2 != c1);
          
          Command cx = c1;
          CHECK (c1 == cx);
          CHECK (cx == c1);
          CHECK (!isSameObject (c1, c2));
          
          // verify equality matches behaviour
          string protocol1 = execCommand(c1);
          string protocolX = execCommand(cx);
          string protocol2 = execCommand(c2);
          
          CHECK (protocol1 == protocolX);
          CHECK (protocol1 != protocol2);
        }
      
      
      /** Helper: invoke and undo a command, 
       *  @return resulting operation protocol
       */
      string
      execCommand (Command com)
        {
          check_ = "(start)";
          com.bind('o');
          com();
          cout << com << ":" << check_ << endl;
          com.undo();
          cout << com << ":" << check_ << endl;
          return check_;
        }
    };
  
  
  /** Register this test class... */
  LAUNCHER (CommandEquality_test, "function controller");
  
  
}}} // namespace steam::control::test
