activity-detector.hpp

Go to the documentation of this file.

/*
  ACTIVITY-DETECTOR.hpp  -  test scaffolding to observe activities within the scheduler
 
   Copyright (C)
     2023,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** 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. See the file COPYING for further details.
 
*/
 
#ifndef VAULT_GEAR_TEST_ACTIVITY_DETECTOR_H
#define VAULT_GEAR_TEST_ACTIVITY_DETECTOR_H
 
 
#include "vault/common.hpp"
#include "lib/test/test-helper.hpp"
#include "lib/test/event-log.hpp"
 
#include "vault/gear/job.h"
#include "vault/gear/activity.hpp"
#include "vault/gear/nop-job-functor.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/meta/variadic-rebind.hpp"
#include "lib/meta/typeseq-util.hpp"
#include "lib/meta/function.hpp"
#include "lib/item-wrapper.hpp"
#include "lib/format-util.hpp"
#include "lib/random.hpp"
#include "lib/util.hpp"
 
#include <functional>
#include <utility>
#include <string>
#include <deque>
 
 
namespace vault{
namespace gear {
namespace test {
  
  using std::string;
  using std::function;
  using lib::time::TimeValue;
  using lib::time::Time;
  using lib::time::FSecs;
  using lib::time::Offset;
  using lib::meta::RebindVariadic;
  using util::unConst;
  using util::isnil;
  using lib::rani;
  using std::forward;
  using std::move;
  
  
  namespace {// Diagnostic markers
    const string MARK_INC{"IncSeq"};
    const string MARK_SEQ{"Seq"};
    
    using SIG_JobDiagnostic = void(Time, int32_t);
    const size_t JOB_ARG_POS_TIME = 0;
    
    const string CTX_POST{"CTX-post"};
    const string CTX_WORK{"CTX-work"};
    const string CTX_DONE{"CTX-done"};
    const string CTX_TICK{"CTX-tick"};
    
    Time SCHED_TIME_MARKER{555,5};  
  }
  
  class ActivityDetector;
  
  
  class ActivityMatch
    : private lib::test::EventMatch
    {
      using _Parent = lib::test::EventMatch;
      
      ActivityMatch (lib::test::EventMatch&& matcher)
        : _Parent{move (matcher)}
        { }
      
      friend class ActivityDetector;
      
    public:
      // standard copy acceptable
      
      operator bool()  const { return _Parent::operator bool(); }
      
      
      /* query builder(s) to find a match stepping forwards */
      ActivityMatch& beforeInvocation (string match) { return delegate (&EventMatch::beforeCall, move(match)); }
      // more here...
 
      /* query builders to find a match stepping backwards */
      ActivityMatch& afterInvocation (string match) { return delegate (&EventMatch::afterCall, move(match)); }
      // more here...
      
      
      template<typename...ARGS>
      ActivityMatch&
      arg (ARGS const& ...args)
        {
          return delegate (&EventMatch::arg<ARGS...>, args...);
        }
      
      ActivityMatch&
      seq (uint seqNr)
        {
          _Parent::attrib (MARK_SEQ, util::toString (seqNr));
          return *this;
        }
      
      ActivityMatch&
      beforeSeqIncrement (uint seqNr)
        {
          _Parent::beforeEvent(MARK_INC, util::toString(seqNr));
          return  *this;
        }
      ActivityMatch&
      afterSeqIncrement (uint seqNr)
        {
          _Parent::afterEvent(MARK_INC, util::toString(seqNr));
          return  *this;
        }
      
      ActivityMatch&
      timeArg (Time const& time)
        {
          return delegate (&EventMatch::argPos<Time const&>, size_t(JOB_ARG_POS_TIME), time);
        }
      
      
    private:
      template<typename...ARGS>
      ActivityMatch&
      delegate (_Parent& (_Parent::*fun) (ARGS...),  ARGS&& ...args)
        {
          return static_cast<ActivityMatch&> (
                   (this->*fun) (forward<ARGS> (args)...));
        }
    };
  
  
  
  class ActivityDetector
    : util::NonCopyable
    {
      using EventLog = lib::test::EventLog;
      
      EventLog eventLog_;
      uint invocationSeq_;
      
      template<typename RET, typename...ARGS>
      class DiagnosticFun
        {
          using RetVal   = lib::wrapper::ItemWrapper<RET>;
          using ImplFun  = std::function<RET(ARGS...)>;
          
          string id_;
          EventLog* log_;
          uint const* seqNr_;
          ImplFun implFun_;
          RetVal retVal_;
          
        public:
          DiagnosticFun (string id, EventLog& masterLog, uint const& invocationSeqNr)
            : id_{id}
            , log_{&masterLog}
            , seqNr_{&invocationSeqNr}
            , implFun_{}
            , retVal_{}
            {
              retVal_.defaultInit();
            }
          
          template<typename VAL>
          DiagnosticFun&&
          returning (VAL&& riggedResponse)
            {
              retVal_ = std::forward<VAL> (riggedResponse);
              return std::move (*this);
            }
          
          template<class FUN>
          DiagnosticFun&&
          implementedAs (FUN&& customImpl)
            {
              implFun_ = std::forward<FUN> (customImpl);
              return std::move (*this);
            }
          
          // default copyable
          
          RET
          operator() (ARGS ...args)  const
            {
              log_->call (log_->getID(), id_, args...)
                   .addAttrib (MARK_SEQ, util::toString(*seqNr_));
              return implFun_? implFun_(std::forward<ARGS>(args)...)
                             : *retVal_;
            }
          
          operator string()  const
            {
              return log_->getID()+"."+id_;
            }
        };
      
      template<typename SIG>
      struct _DiagnosticFun
        {
          using Ret      = lib::meta::_Fun<SIG>::Ret;
          using Args     = lib::meta::_Fun<SIG>::Args;
          using SigTypes = lib::meta::Prepend<Ret, Args>::Seq;
          
          using Type  = RebindVariadic<DiagnosticFun, SigTypes>::Type;
        };
      
      using Logger = _DiagnosticFun<void(string)>::Type;
      
      
      class MockJobFunctor
        : public NopJobFunctor
        {
          using MockOp = _DiagnosticFun<SIG_JobDiagnostic>::Type;
          
          MockOp mockOperation_;
          
          void
          invokeJobOperation (JobParameter param)  override
            {
              mockOperation_(Time{TimeValue{param.nominalTime}}, param.invoKey.part.a);
            }
          
          string diagnostic()  const override
            {
              return "JobFun-"+string{mockOperation_};
            }
          
          JobKind
          getJobKind()  const
            {
              return TEST_JOB;
            }
          
        public:
          MockJobFunctor (MockOp mockedJobOperation)
            : mockOperation_{move (mockedJobOperation)}
            { }
        };
      
      
      class ActivityProbe
        : public Activity
        , public activity::Hook
        {
          Logger log_;
          TimeVar invoked_{Time::ANYTIME};
          
          Activity*
          target()
            {
              return reinterpret_cast<Activity*> (data_.callback.arg);
            }
          
          Activity const*
          target()  const
            {
              return unConst(this)->target();
            }
          
          activity::Proc
          activation ( Activity& thisHook
                     , Time now
                     , void* executionCtx)  override
            {
              REQUIRE (thisHook.is (Activity::HOOK));
              invoked_ = now;
              if (not target())
                {// no adapted target; just record this activation
                  log_(util::toString(now) + " ⧐ ");
                  return activity::PASS;
                }
              else
                {// forward activation to the adapted target Activity
                  auto ctx = *static_cast<FakeExecutionCtx*> (executionCtx);
                  log_(util::toString(now) + " ⧐ " + util::toString (*target()));
                  return target()->activate (now, ctx);
                }
            }
          
          activity::Proc
          notify     ( Activity& thisHook
                     , Time now
                     , void* executionCtx)  override
            {
              REQUIRE (thisHook.is (Activity::HOOK));
              invoked_ = now;
              if (not target())
                {// no adapted target; just record this notification
                  log_(util::toString(now) + " --notify-↯• ");
                  return activity::PASS;
                }
              else
                {// forward notification-dispatch to the adapted target Activity
                  auto ctx = *static_cast<FakeExecutionCtx*> (executionCtx);
                  log_(util::toString(now) + " --notify-↯> " + util::toString (*target()));
                  return target()->dispatch (now, ctx);
                }
            }
          
          Time
          getDeadline()  const override
            {
              if (target() and target()->is(Activity::GATE))
                return target()->data_.condition.getDeadline();
              else
                return Time::NEVER;
            }
          
          std::string
          diagnostic()  const override
            {
              return "Probe("+string{log_}+")";
            }
          
        public:
          ActivityProbe (string id, EventLog& masterLog, uint const& invocationSeqNr)
            : Activity{*this, 0}
            , log_{id, masterLog, invocationSeqNr}
            { }
          
          ActivityProbe (Activity const& subject, string id, EventLog& masterLog, uint const& invocationSeqNr)
            : Activity{*this, reinterpret_cast<size_t> (&subject)}
            , log_{id, masterLog, invocationSeqNr}
            {
              next = subject.next;
            }
          
          operator string()  const
            {
              return diagnostic();
            }
          
          
          static Time
          lastInvoked (Activity const* act)
            {
              if (act and act->verb_ == HOOK)
                {
                  ActivityProbe* probe = dynamic_cast<ActivityProbe*> (act->data_.callback.hook);
                  if (probe)
                    return probe->invoked_;
                }
              return Time::NEVER;
            }
        };
      
      
      /* ===== Maintain throw-away mock instances ===== */
      
      std::deque<MockJobFunctor> mockOps_{};
      std::deque<ActivityProbe> mockActs_{};
      
      
    public:
      ActivityDetector(string id ="")
        : eventLog_{"ActivityDetector" + (isnil (id)? string{}: "("+id+")")}
        , invocationSeq_{0}
        { }
      
      operator string()  const
        {
          return util::join (eventLog_);
        }
      
      string
      showLog()  const
        {
          return "\n____Event-Log___________________________\n"
               + util::join (eventLog_, "\n")
               + "\n────╼━━━━━━━━╾──────────────────────────"
               ;
        }
      
      void
      clear(string newID)
        {
          if (isnil (newID))
            eventLog_.clear();
          else
            eventLog_.clear (newID);
        }
      
      uint
      incrementSeq()
        {
          ++invocationSeq_;
          eventLog_.event (MARK_INC, util::toString(invocationSeq_));
          return invocationSeq_;
        }
      
      uint
      currSeq()  const
        {
          return invocationSeq_;
        }
      
      
      template<typename SIG>
      auto
      buildDiagnosticFun (string id)
        {
          using Functor = _DiagnosticFun<SIG>::Type;
          return Functor{id, eventLog_, invocationSeq_};
        }
      
      JobClosure&                         
      buildMockJobFunctor (string id)
        {
          return mockOps_.emplace_back (
                   buildDiagnosticFun<SIG_JobDiagnostic> (id));
        }
      
      Job
      buildMockJob (string id =""
                   ,Time nominal = lib::test::randTime()
                   ,size_t extra = rani())
        {
          InvocationInstanceID invoKey;
          invoKey.part.a = extra;
          invoKey.part.t = _raw(nominal);
          return Job{buildMockJobFunctor (isnil(id)? "mockJob-"+util::toString(nominal) : id)
                    ,invoKey
                    ,nominal};
        }
      
      Activity&
      buildActivationProbe (string id)
        {
          return mockActs_.emplace_back (id, eventLog_, invocationSeq_);
        }
      
      Activity&
      buildActivationTap (Activity const& subject, string id ="")
        {
          return mockActs_.emplace_back (subject
                                        ,isnil(id)? "tap-"+subject.showVerb()+util::showAdr(subject)
                                                  : id
                                        ,eventLog_
                                        ,invocationSeq_);
        }
      
      Activity&
      insertActivationTap (Activity*& wiring, string id ="")
        {
          wiring = wiring? & buildActivationTap (*wiring, id)
                         : & buildActivationProbe (isnil(id)? "tail-"+util::showAdr(&wiring) : id);
          return *wiring;
        }
      
      Activity&
      buildGateWatcher (Activity& gate, string id ="")
        {
          insertActivationTap (gate.next, "after-" + (isnil(id)? gate.showVerb()+util::showAdr(gate) : id));
          return buildActivationTap (gate, id);
        }
      
      Activity&
      watchGate (Activity*& wiring, string id ="")
        {
          wiring = wiring? & buildGateWatcher (*wiring, id)
                         : & buildActivationProbe (isnil(id)? "tail-"+util::showAdr(&wiring) : id);
          return *wiring;
        }
      
      
      Time invokeTime (Activity const* hook) { return ActivityProbe::lastInvoked (hook); }
      bool wasInvoked (Activity const* hook) { return invokeTime(hook).isRegular(); }
      Time invokeTime (Activity const& hook) { return invokeTime (&hook); }
      bool wasInvoked (Activity const& hook) { return wasInvoked (&hook); }
      
      
      struct FakeExecutionCtx;
      using SIG_post = activity::Proc(Time, Time, Activity*, FakeExecutionCtx&);
      using SIG_work = void(Time, size_t);
      using SIG_done = void(Time, size_t);
      using SIG_tick = activity::Proc(Time);
      
      struct FakeExecutionCtx
        {
          _DiagnosticFun<SIG_post>::Type post;
          _DiagnosticFun<SIG_work>::Type work;
          _DiagnosticFun<SIG_done>::Type done;
          _DiagnosticFun<SIG_tick>::Type tick;
          
          function<Time()>   getSchedTime = [this]{ return SCHED_TIME_MARKER;};
          
          FakeExecutionCtx (ActivityDetector& detector)
            : post{detector.buildDiagnosticFun<SIG_post>(CTX_POST).returning(activity::PASS)}
            , work{detector.buildDiagnosticFun<SIG_work>(CTX_WORK)}
            , done{detector.buildDiagnosticFun<SIG_done>(CTX_DONE)}
            , tick{detector.buildDiagnosticFun<SIG_tick>(CTX_TICK).returning(activity::PASS)}
            { }
          
          operator string()  const { return "≺test::CTX≻"; }
        };
      
      FakeExecutionCtx executionCtx{*this};
      
      
      
      ActivityMatch
      verifyInvocation (string fun)
        {
          return ActivityMatch{move (eventLog_.verifyCall(fun))};
        }
      
      ActivityMatch
      ensureNoInvocation (string fun)
        {
          return ActivityMatch{move (eventLog_.ensureNot(fun).locateCall(fun))};
        }
      
      ActivityMatch
      verifySeqIncrement (uint seqNr)
        {
          return ActivityMatch{move (eventLog_.verifyEvent(MARK_INC, util::toString(seqNr)))};
        }
      
      
    private:
    };
  
  
}}} // namespace vault::gear::test
#endif /*VAULT_GEAR_TEST_ACTIVITY_DETECTOR_H*/