mock-dispatcher.hpp

Go to the documentation of this file.

/*
  MOCK-DISPATCHER.hpp  -  test scaffolding to verify render job planning and dispatch
 
   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 STEAM_ENGINE_TEST_MOCK_DISPATCHER_H
#define STEAM_ENGINE_TEST_MOCK_DISPATCHER_H
 
 
#include "lib/test/test-helper.hpp"
#include "steam/play/dummy-play-connection.hpp"
#include "steam/fixture/node-graph-attachment.hpp"
#include "steam/fixture/segmentation.hpp"
#include "steam/mobject/model-port.hpp"
#include "steam/engine/dispatcher.hpp"
#include "steam/engine/job-ticket.hpp"
#include "vault/gear/job.h"
#include "vault/real-clock.hpp"
#include "lib/allocator-handle.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/diff/gen-node.hpp"
#include "lib/linked-elements.hpp"
#include "lib/itertools.hpp"
#include "lib/depend.hpp"
#include "lib/util.hpp"
 
#include <tuple>
#include <map>
 
 
namespace steam  {
namespace engine {
namespace test   {
  
  using std::make_tuple;
  using lib::diff::GenNode;
  using lib::diff::MakeRec;
  using lib::time::TimeValue;
  using lib::time::Time;
  using lib::HashVal;
  using lib::ranHash;
  using lib::rani;
  using util::isnil;
  using util::isSameObject;
  using fixture::Segmentation;
  using vault::RealClock;
  using vault::gear::Job;
  using vault::gear::JobClosure;
  
  
  
  
  
  class MockJob
    : public Job
    {
      static Job build(); 
      static Job build (Time nominalTime, int additionalKey);
      
    public:
      MockJob()
        : Job{build()}
        { }
      
      MockJob (Time nominalTime, int additionalKey)
        : Job{build (nominalTime,additionalKey)}
        { }
      
      
      static bool was_invoked (Job const& job);
      static Time invocationTime (Job const& job);
      static Time invocationNominalTime (Job const& job);
      static int  invocationAdditionalKey (Job const& job);
      
      static bool isNopJob (Job const&);
      static JobClosure& getFunctor();
    };
  
 
  
  
  
  
  class MockJobTicket
    : private lib::AllocatorHandle<JobTicket>
    , public JobTicket
    {
      auto&
      allocator()
        {
          return static_cast<lib::AllocatorHandle<JobTicket>&> (*this);
        }
      
      static ExitNode
      defineSimpleSpec (HashVal seed =ranHash())
        {
          return ExitNode{seed, DUMMY_JOB_RUNTIME
                         ,ExitNodes{}
                         ,& MockJob::getFunctor()};
        }
      
    public:
      MockJobTicket()
        : JobTicket{defineSimpleSpec(), allocator()}
      { }
      
      MockJobTicket (HashVal seed)
        : JobTicket{defineSimpleSpec (seed), allocator()}
      { }
      
      
      /* ===== Diagnostics ===== */
      
      bool verify_associated (Job const&) const;
      static bool isAssociated (Job const&, JobTicket const&);
    };
  
  
  
  class MockSegmentation
    : public Segmentation
    {
      
    public:
      MockSegmentation()
        : Segmentation{}
      { }
      
      MockSegmentation (std::initializer_list<GenNode> specs)
        : MockSegmentation{}
        {
          for (auto& spec : specs)
            {
              auto start = spec.retrieveAttribute<Time> ("start");
              auto after = spec.retrieveAttribute<Time> ("after");
              Segmentation::splitSplice (start, after
                                        ,ExitNodes{buildExitNodeFromSpec (spec)}
                                        );
            }
        }
      
      
      ExitNode
      buildExitNodeFromSpec (GenNode const& spec)
        {
          return ExitNode{buildSeed (spec)
                         ,buildRuntime (spec)
                         ,buildPrerequisites (spec)
                         ,& MockJob::getFunctor()};
        }
      
      void duplicateExitNodeSpec (uint times);
      
      
    private: /* ======== Implementation: build fake ExitNodes from test specification ==== */
      
      HashVal
      buildSeed (GenNode const& spec)
        {
          auto seed = spec.retrieveAttribute<int> ("mark");
          return seed? HashVal(*seed) : HashVal(1 +rani(1000));
        }
      
      Duration
      buildRuntime (GenNode const& spec)
        {
          auto runtime = spec.retrieveAttribute<Duration> ("runtime");
          return runtime? *runtime : DUMMY_JOB_RUNTIME;
        }
      
      ExitNodes
      buildPrerequisites (GenNode const& spec)
        {
          ExitNodes prerequisites;
          for (auto& child : spec.getChildren())
            prerequisites.emplace_back (
              buildExitNodeFromSpec (child));
          return prerequisites;
        }
    };
  
  
  
  
  inline void
  MockSegmentation::duplicateExitNodeSpec (uint times)
    {
      using Spec = fixture::NodeGraphAttachment;
      
      Segmentation::adaptSpecification ([times](Spec const& spec)
                                                {
                                                  return Spec{ExitNodes(times, spec[0])};
                                                });        // vector with <times> copies of spec[0]
    }                                                     //  (Warning: use parens, not braces for this ctor...)
  
  
  inline bool
  MockJobTicket::verify_associated (Job const& job)  const
  {
    JobFunctor& functor = dynamic_cast<JobFunctor&> (static_cast<JobClosure&> (*job.jobClosure));
    Time nominalTime {TimeValue{job.parameter.nominalTime}};
    InvocationInstanceID const& invoKey = job.parameter.invoKey;
    return this->isValid()
       and this->verifyInstance(functor, invoKey, nominalTime);
  }
  
  inline bool
  MockJobTicket::isAssociated (Job const& job, JobTicket const& ticket)
  {                                    // should work always, since storage is the same
    MockJobTicket const& backdoor = static_cast<MockJobTicket const&> (ticket);
    return backdoor.verify_associated (job);
  }
  
  
  
  namespace { // used internally by MockDispatcher....
    using play::test::ModelPorts;
    using play::test::PlayTestFrames_Strategy;
    
    using DummyPlaybackSetup = play::test::DummyPlayConnection<PlayTestFrames_Strategy>;
  }
  
  
  
  class MockDispatcher
    : public Dispatcher
    {
      
      DummyPlaybackSetup dummySetup_;
      MockSegmentation mockSeg_;
      
      using PortIdxMap = std::map<ModelPort, size_t>;
      
      const PortIdxMap portIdx_;
      
    public:
      /* == mock implementation of the Dispatcher interface == */
      
      size_t
      resolveModelPort (ModelPort modelPort)  override
        {
          auto entry = portIdx_.find(modelPort);
          if (entry == portIdx_.end())
            throw error::Logic{"Invalid ModelPort for this Dispatcher"};
          else
            return entry->second;
        }
      
      
      JobTicket&
      getJobTicketFor (size_t portIDX, TimeValue nominalTime)  override
        {
          auto& seg = mockSeg_[nominalTime];
          return seg.jobTicket(portIDX);
        }
      
      
    public:
      MockDispatcher()
        : dummySetup_{}
        , mockSeg_{MakeRec().genNode()}                 // Node: generate a single active Segment to cover all
        , portIdx_{buildPortIndex()}
        {
          mockSeg_.duplicateExitNodeSpec(portIdx_.size());
        }
      
      MockDispatcher (std::initializer_list<GenNode> specs)
        : dummySetup_{}
        , mockSeg_(specs)
        , portIdx_{buildPortIndex()}
        {
          mockSeg_.duplicateExitNodeSpec(portIdx_.size());
        }
      
      
      ModelPort
      provideMockModelPort()
        {
          ModelPorts mockModelPorts = dummySetup_.getAllModelPorts();
          return *mockModelPorts;  // using just the first dummy port
        }
      
      play::test::DummyOutputLink
      getDummyConnection(uint index)
        {
          return dummySetup_.getModelPort (index);
        }
      
      bool verify(Job const& job, ModelPort const& port, play::DataSink const& sink)
        {
          if (not dummySetup_.isSupported (port, sink)) return false;
          
          TimeValue nominalTime{job.parameter.nominalTime};
          size_t portIDX = resolveModelPort (port);
          JobTicket& ticket = getJobTicketFor (portIDX, nominalTime);
          return isnil (ticket)? MockJob::isNopJob (job)
                               : MockJobTicket::isAssociated (job, ticket);
        }
      
    private:
      PortIdxMap
      buildPortIndex()
        {
          PortIdxMap newIndex;
          uint i{0};
          for (auto it=dummySetup_.getAllModelPorts()
              ; bool{it}
              ; ++it, ++i
              )
            newIndex[*it] = i;
          
          return newIndex;
        }
    };
  
  
}}} // namespace steam::engine::test
#endif /*STEAM_ENGINE_TEST_MOCK_DISPATCHER_H*/