abstract-tangible-test.cpp

Go to the documentation of this file.

/*
  AbstractTangible(Test)  -  cover the operations of any tangible UI element

  Copyright (C)         Lumiera.org
    2015,               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.

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


#include "lib/test/run.hpp"
#include "lib/test/test-helper.hpp"
#include "lib/test/event-log.hpp"
#include "test/mock-elm.hpp"
#include "test/test-nexus.hpp"
#include "lib/idi/genfunc.hpp"
#include "lib/idi/entry-id.hpp"
#include "steam/control/command-def.hpp"
#include "lib/diff/mutation-message.hpp"
#include "lib/diff/tree-diff.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/format-cout.hpp"
#include "lib/symbol.hpp"
#include "lib/error.hpp"
#include "lib/util.hpp"

#include <sigc++/signal.h>


using lib::Symbol;
using util::isnil;
using util::toString;
using lib::time::Time;
using stage::test::MockElm;
using lib::test::EventLog;
using lib::idi::EntryID;
using lib::diff::Rec;
using lib::diff::MakeRec;
using lib::diff::GenNode;
using lib::diff::DataCap;
using lib::diff::MutationMessage;
using steam::control::Command;
using steam::control::CommandDef;



namespace stage {
namespace model {
namespace test  {
  
  using LERR_(WRONG_TYPE);
  using ID = lib::idi::BareEntryID const&;
  
  namespace { // test fixture...
    
    /* === dummy operation to be invoked through the command system === */
    
    int dummyState = 0;
    
    void
    operate (int val)
    {
      dummyState = val;
    }
    
    int
    capture (int)
    {
      return dummyState;
    }
    
    void
    undoIt (int, int oldState)
    {
      dummyState = oldState;
    }
    
    
    
    const Symbol DUMMY_CMD_ID{"test.AbstractTangibleTest_dummy_command"};
    
    
    void
    processCommandInvocation (GenNode const& commandMsg)
    {
      REQUIRE (string{DUMMY_CMD_ID} == commandMsg.idi.getSym());
      
      auto cmd = Command::get (DUMMY_CMD_ID);
      auto arg = commandMsg.data.get<Rec>().scope()->data.get<int>();
      cmd.bind (arg);
      cmd();
    }
    
    
  }//(End) test fixture
  
  
  
  
  
  
  /***********************************************************************/
  class AbstractTangible_test : public Test
    {
      
      virtual void
      run (Arg)
        {
          verify_mockManipulation();
          invokeCommand();
          markState();
          revealer();
          notify();
          mutate();
        }
      
      
      void
      verify_mockManipulation ()
        {
          MARK_TEST_FUN
          MockElm mock("dummy");
          
          CHECK (mock.verify("ctor"));
          CHECK (mock.verifyEvent("create","dummy"));
          CHECK (mock.verify("ctor").arg("dummy","TestNexus").on(&mock));
          
          CHECK ("dummy" == mock.getID().getSym());
          CHECK (EntryID<MockElm>("dummy") == mock.getID());
          
          CHECK (!mock.verifyCall("reset"));
          
          // start manipulating state....
          mock.slotExpand();
          CHECK (mock.isExpanded());
          
          mock.reset();
          CHECK (mock.verify("reset"));
          CHECK (mock.verifyCall("reset"));
          CHECK (mock.verifyCall("reset").on(&mock));
          CHECK (mock.verifyCall("reset").on("dummy"));
          CHECK (mock.verifyEvent("reset"));
          CHECK (mock.verify("reset").after("ctor"));
          CHECK (mock.verify("ctor").before("reset"));
          CHECK (mock.ensureNot("reset").before("ctor"));
          CHECK (mock.ensureNot("ctor").after("reset"));
          
          CHECK (mock.verify("reset").beforeEvent("reset"));
          CHECK (mock.verifyCall("reset").beforeEvent("reset"));
          CHECK (!mock.verifyCall("reset").afterEvent("reset"));
          
          CHECK (!mock.isTouched());
          CHECK (!mock.isExpanded());
          
          mock.markMsg("qui dolorem ipsum quia dolor sit amet consectetur adipisci velit.");
          CHECK (mock.verifyMark("Message", "dolor"));
          CHECK (mock.verifyCall("doMsg"));
          CHECK (mock.verifyCall("doMsg").arg("lorem ipsum"));
          CHECK (mock.verifyCall("doMsg").argMatch("dolor.+dolor\\s+"));
          CHECK (mock.verifyMatch("Rec\\(mark.+ID = Message.+\\{.+lorem ipsum"));
          
          EventLog log = mock.getLog();
          log.verify("ctor")
             .before("reset")
             .before("lorem ipsum");
          
          // create further mock elements...
          MockElm foo("foo"), bar("bar");
          foo.verify("ctor").arg("foo");
          bar.verify("ctor").arg("bar");
          
          bar.ensureNot("foo");
          log.ensureNot("foo");
          mock.ensureNot("foo");
          CHECK (!foo.ensureNot("foo"));
          
          // now join the logs together,
          // allowing to watch the combined events
          bar.joinLog(mock);
          foo.joinLog(mock);
          CHECK (log.verifyEvent("logJoin","bar")
                    .beforeEvent("logJoin","foo"));
          
          CHECK (mock.verifyEvent("logJoin","bar")
                     .beforeEvent("logJoin","foo"));
          CHECK (mock.verifyEvent("create","foo"));
          CHECK (log.verifyEvent("create","foo"));
          CHECK (log.verifyEvent("create","dummy")
                    .beforeEvent("create","bar")
                    .beforeEvent("create","foo"));
          
          
          mock.kill();
          foo.markMsg("dummy killed");
          CHECK (log.verifyEvent("destroy","dummy")
                    .beforeCall("doMsg").on("foo"));
          
          // Access the log on the Test-Nexus hub
          EventLog nexusLog = stage::test::Nexus::getLog();
          CHECK (nexusLog.verifyEvent("destroy","dummy")
                         .beforeEvent("dummy successfully zombificated"));
          
          mock.slotExpand(); // attempt to operate the zombie
          CHECK (nexusLog.verifyEvent("dummy successfully zombificated")
                         .beforeCall("note").on("ZombieNexus").arg("defunct-dummy", "expand")
                         .beforeEvent("error","sent note message to ZombieNexus"));
          
          
          cout << "____Event-Log_________________\n"
               << util::join(mock.getLog(), "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
          
          cout << "____Nexus-Log_________________\n"
               << util::join(stage::test::Nexus::getLog(), "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
        }
      
      
      
      void
      invokeCommand ()
        {
          MARK_TEST_FUN
          EventLog nexusLog = stage::test::Nexus::startNewLog();
          
          // Setup test stage: define a command/action "in Steam"
          CommandDef (DUMMY_CMD_ID)
              .operation (operate)
              .captureUndo (capture)
              .undoOperation (undoIt);
          
          stage::test::Nexus::setCommandHandler (&processCommandInvocation);
          
          // the UI element to trigger this command invocation
          MockElm mock("uiElm");
          
          int prevState = dummyState;
          int concreteParam = 1 +rand() % 100;
          
          // on bus no traces from this command yet...
          CHECK (nexusLog.ensureNot(string(DUMMY_CMD_ID)));
          
          
          // message to bind parameter data and finally trigger the command
          mock.invoke (DUMMY_CMD_ID, concreteParam);
          CHECK (dummyState == concreteParam);  // command was indeed invoked
          CHECK (nexusLog.verifyCall("act").arg("«int»|" +toString(concreteParam))
                         .beforeEvent("bind and trigger command \""+DUMMY_CMD_ID));
          
          // verify proper binding, including UNDO state capture
          Command::get (DUMMY_CMD_ID).undo();
          CHECK (dummyState == prevState);
          
          cout << "____Nexus-Log_________________\n"
               << util::join(nexusLog, "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
          
          
          // reset to default (NOP) handler
          stage::test::Nexus::setCommandHandler();
        }
      
      
      void
      markState ()
        {
          MARK_TEST_FUN
          EventLog nexusLog = stage::test::Nexus::startNewLog();
          
          sigc::signal<void> trigger_expand;
          sigc::signal<void> trigger_collapse;
          
          MockElm mock("target");
          ID targetID = mock.getID();
          
          trigger_expand.connect   (sigc::mem_fun(mock, &Tangible::slotExpand));
          trigger_collapse.connect (sigc::mem_fun(mock, &Tangible::slotCollapse));
          
          CHECK (not mock.isTouched());
          CHECK (not mock.isExpanded());
          CHECK (mock.ensureNot("expanded"));
          CHECK (nexusLog.ensureNot("state-mark"));
          
          trigger_expand(); // emit signal
          
          CHECK (mock.isTouched());
          CHECK (mock.isExpanded());
          CHECK (mock.verifyCall("expand").arg(true)
                     .beforeEvent("expanded"));
          
          // and now the important part: state mark notification was sent over the bus...
          CHECK (nexusLog.verifyCall("note").arg(targetID, GenNode{"expand", true})
                         .before("handling state-mark"));
          
          
          trigger_collapse(); // emit other signal
          CHECK (not mock.isExpanded());
          CHECK (mock.isTouched());
          
          CHECK (mock.verifyEvent("create", "target")
                     .beforeEvent("expanded")
                     .beforeEvent("collapsed"));
          CHECK (nexusLog.verifyCall("note").arg(targetID, GenNode{"expand", true})
                         .before("handling state-mark")
                         .beforeCall("note").arg(targetID, GenNode{"expand", false})
                         .before("handling state-mark"));
          
          trigger_collapse();
          CHECK (not mock.isExpanded());
          
          // but note: redundant state changes do not cause sending of further state marks
          CHECK (mock.ensureNot("collapsed")
                     .beforeCall("expand")
                     .beforeEvent("collapsed"));
          CHECK (nexusLog.ensureNot("handling state-mark")
                         .beforeCall("note").arg(targetID, GenNode{"expand", false})
                         .before("handling state-mark")
                         .beforeCall("note").arg(targetID, GenNode{"expand", false}));
          
          
          
          // Second part: replay of a state mark via UI-Bus....
          auto stateMark = GenNode{"expand", true};
          auto& uiBus = stage::test::Nexus::testUI();
          
          CHECK (not mock.isExpanded());
          CHECK (mock.ensureNot("mark"));
          
          uiBus.mark (targetID, stateMark);
          
          CHECK (nexusLog.verifyCall("mark").arg(targetID, stateMark)
                         .before("delivered mark to "+string(targetID)).arg(stateMark));
          
          CHECK (mock.verifyMark("expand", "true")
                     .beforeCall("expand").arg(true)
                     .beforeEvent("expanded"));
          CHECK (mock.isExpanded());
          CHECK (mock.isTouched());
          
          // the default handler defined in model::Tangible
          // already supports some rather generic state changes,
          // like e.g. a reset to the element's default state.
          // Note that the actual implementation doReset()
          // is a virtual function, here implemented in MockElm.
          uiBus.mark (targetID, GenNode{"reset", true});
                                              // note: payload is irrelevant for "reset" mark
          
          // and we're back to pristine state...
          CHECK (not mock.isTouched());
          CHECK (not mock.isExpanded());
          CHECK (mock.verifyMark("reset", "true")
                     .afterEvent("expanded")
                     .beforeCall("reset")
                     .beforeEvent("reset"));
          
          
          cout << "____Event-Log_________________\n"
               << util::join(mock.getLog(), "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
          
          cout << "____Nexus-Log_________________\n"
               << util::join(nexusLog, "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
        }
      
      
      void
      revealer ()
        {
          MARK_TEST_FUN
          EventLog nexusLog = stage::test::Nexus::startNewLog();
          
          MockElm mock("target");
          ID targetID = mock.getID();
          
          sigc::signal<void> trigger_reveal;
          trigger_reveal.connect   (sigc::mem_fun(mock, &Tangible::slotReveal));
          
          CHECK (not mock.isTouched());
          CHECK (not mock.isExpanded());
          CHECK (mock.ensureNot("reveal"));
          CHECK (mock.ensureNot("expanded"));
          CHECK (nexusLog.ensureNot("state-mark"));
          
          bool revealed = false;
          mock.installRevealer([&]()
                                  {                        // NOTE: our mock "implementation" of the »reveal yourself« functionality
                                    mock.slotExpand();     //       explicitly prompts the element to expand itself,
                                    revealed = true;       //       and then via closure sets a flag we can verify.
                                  });
          
          trigger_reveal();
          
          CHECK (true == revealed);
          CHECK (mock.isExpanded());
          CHECK (mock.verifyEvent("create","target")
                     .beforeCall("reveal")
                     .beforeCall("expand").arg(true)
                     .beforeEvent("expanded"));
          
          // invoking the slotExpand() also emitted a state mark to persist that expansion state...
          CHECK (nexusLog.verifyCall("note").arg(targetID, GenNode{"expand", true})
                         .before("handling state-mark"));
          
          
          // second test: the same can be achieved via UI-Bus message...
          revealed = false;
          auto stateMark = GenNode{"reveal", 47};  // (payload argument irrelevant)
          auto& uiBus = stage::test::Nexus::testUI();
          CHECK (nexusLog.ensureNot("reveal"));
          
          uiBus.mark (targetID, stateMark);                // send the state mark message to reveal the element
          
          CHECK (true == revealed);
          CHECK (mock.verifyMark("reveal", 47)
                     .afterEvent("expanded")
                     .beforeCall("reveal")
                     .beforeCall("expand").arg(true));
          
          CHECK (nexusLog.verifyCall("mark").arg(targetID, stateMark)
                         .after("handling state-mark")
                         .before("reveal")
                         .beforeEvent("delivered mark"));
          
          // Note the fine point: the target element /was/ already expanded
          // and thus there is no second "expanded" event, nor is there a
          // second state mark emitted into the UI-Bus...
          CHECK (mock.ensureNot("expanded")
                     .afterCall("reveal")
                     .afterEvent("expanded"));
          CHECK (nexusLog.ensureNot("note")
                         .afterCall("mark").arg(targetID, stateMark)
                         .after("handling state-mark"));
          
          
          
          cout << "____Event-Log_________________\n"
               << util::join(mock.getLog(), "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
          
          cout << "____Nexus-Log_________________\n"
               << util::join(nexusLog, "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
        }
      
      
      void
      notify ()
        {
          MARK_TEST_FUN
          EventLog nexusLog = stage::test::Nexus::startNewLog();
          
          MockElm mock("target");
          ID targetID = mock.getID();
          auto& uiBus = stage::test::Nexus::testUI();
          
          CHECK (mock.ensureNot("Flash"));
          CHECK (mock.ensureNot("Error"));
          CHECK (mock.ensureNot("Message"));
          CHECK (isnil(mock.getMessage()));
          CHECK (isnil(mock.getError()));
          CHECK (not mock.isError());
          
          // now send a "Flash" mark via UI-Bus....
          uiBus.mark (targetID, GenNode{"Flash", true });
          CHECK (mock.verifyMark("Flash"));
          
          CHECK (mock.ensureNot("Error"));
          CHECK (mock.ensureNot("Message"));
          CHECK (isnil(mock.getMessage()));
          CHECK (isnil(mock.getError()));
          
          uiBus.mark (targetID, GenNode{"Error", "getting serious"});
          CHECK (mock.verifyMark("Error", "serious"));
          CHECK (mock.isError());
          CHECK ("getting serious" == mock.getError());
          CHECK (isnil(mock.getMessage()));
          
          uiBus.mark (targetID, GenNode{"Message", "by mistake"});
          CHECK (mock.verifyMark("Message", "mistake"));
          CHECK ("by mistake" == mock.getMessage());
          CHECK ("getting serious" == mock.getError());
          
          CHECK (mock.verify("target")
                     .before("Flash")
                     .before("serious")
                     .before("mistake"));
          
          // type mismatch: when receiving a "Message" mark, we expect a string payload
          VERIFY_ERROR(WRONG_TYPE, uiBus.mark(targetID, GenNode{"Message", Time::NEVER }))
          
          // the type error happens while resolving the payload,
          // and thus the actual "doMsg()" function on the target was not invoked
          CHECK (mock.ensureNot(string(Time::NEVER)));
          CHECK (nexusLog.verifyCall("mark").arg(targetID, Time::NEVER));
          CHECK (nexusLog.ensureNot("delivered mark").arg(Time::NEVER));
          CHECK ("getting serious" == mock.getError());
          
          mock.reset();
          CHECK (isnil(mock.getMessage()));
          CHECK (isnil(mock.getError()));
          CHECK (not mock.isError());
          
          
          cout << "____Event-Log_________________\n"
               << util::join(mock.getLog(), "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
          
          cout << "____Nexus-Log_________________\n"
               << util::join(nexusLog, "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
        }
      
      
      
      void
      mutate ()
        {
          MARK_TEST_FUN
          EventLog nexusLog = stage::test::Nexus::startNewLog();
          
          MockElm rootMock("root");
          ID rootID = rootMock.getID();
          
          rootMock.attrib["α"] = "Centauri";
          CHECK ("Centauri" == rootMock.attrib["α"]);
          CHECK (isnil (rootMock.scope));
          
          
            // simulated source for structural diff
            struct : lib::diff::TreeDiffLanguage
              {
                const GenNode
                  ATTRIB_AL = GenNode("α", "quadrant"),
                  ATTRIB_PI = GenNode("π", 3.14159265),
                  CHILD_1   = MakeRec().genNode("a"),
                  CHILD_2   = MakeRec().genNode("b");
                
                auto
                generateDiff()
                  {
                    using lib::diff::Ref;
                    
                    return MutationMessage{ after(Ref::ATTRIBS)   // start after the existing attributes (of root)
                                          , ins(CHILD_1)          // insert first child (with name "a")
                                          , ins(CHILD_2)          // insert second child (with name "b")
                                          , set(ATTRIB_AL)        // assign a new value to attribute "α" <- "quadrant"
                                          , mut(CHILD_2)          // open nested scope of child "b" for recursive mutation
                                            , ins(ATTRIB_PI)      // ..within nested scope, add a new attribute "π" := 3.14159265
                                          , emu(CHILD_2)          // leave nested scope
                                          };
                  }
              }
              diffSrc;
          
          
          auto& uiBus = stage::test::Nexus::testUI();
          
          
          // send a Diff message via UI-Bus to the rootMock
          uiBus.change(rootID, diffSrc.generateDiff());
          
          
          // Verify the rootMock has been properly altered....
          MockElm& childA = *rootMock.scope[0];
          MockElm& childB = *rootMock.scope[1];
          
          CHECK (2 == rootMock.scope.size());             // we've got two children now
          CHECK (rootMock.attrib["α"] == "quadrant");     // alpha attribute has been reassigned
          CHECK (childA.getID() == diffSrc.CHILD_1.idi);  // children have the expected IDs
          CHECK (childB.getID() == diffSrc.CHILD_2.idi);
          CHECK (childB.attrib["π"]  == "3.1415927");     // and the second child got attribute Pi
          
          
          CHECK (rootMock.verifyEvent("create","root")
                         .beforeCall("buildMutator").on(&rootMock)
                         .beforeEvent("diff","root accepts mutation...")        // start of diff mutation
                         .beforeEvent("diff","create child \"a\"")              // insert first child
                         .beforeEvent("create", "a")
                         .beforeEvent("diff","create child \"b\"")              // insert second child
                         .beforeEvent("create", "b")
                         .beforeEvent("diff","set Attrib α <-quadrant")         // assign value to existing attribute α
                         .beforeCall("buildMutator").on(&childB)                // establish nested mutator for second child
                         .beforeEvent("diff","b accepts mutation...")
                         .beforeEvent("diff",">>Scope>> b")                     // recursively mutate second child
                         .beforeEvent("diff","++Attrib++ π = 3.1415927"));      // insert new attribute π within nested scope
          
          
          CHECK (nexusLog.verifyCall("routeAdd").arg(rootMock.getID(), memLocation(rootMock))      // rootMock was attached to Nexus
                         .beforeCall("change")  .argMatch(rootMock.getID(),
                                                          "after.+ins.+ins.+set.+mut.+ins.+emu")   // diff message sent via UI-Bus
                         .beforeCall("routeAdd").arg(childA.getID(), memLocation(childA))          // first new child was attached to Nexus
                         .beforeCall("routeAdd").arg(childB.getID(), memLocation(childB))          // second new child was attached to Nexus
                         .beforeEvent("applied diff to "+string(rootMock.getID()))
                         );
          
          cout << "____Event-Log_________________\n"
               << util::join(rootMock.getLog(), "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
          
          cout << "____Nexus-Log_________________\n"
               << util::join(nexusLog, "\n")
               << "\n───╼━━━━━━━━━╾────────────────"<<endl;
        }
      
      
      
      static string
      memLocation (Tangible& uiElm)
        {
          return lib::idi::instanceTypeID (&uiElm);
        }
    };
  
  
  LAUNCHER (AbstractTangible_test, "unit stage");
  
  
}}}// namespace stage::model::test