mock-dispatcher.cpp

Go to the documentation of this file.

/*
    MockDispatcher  -  diagnostic render job and frame dispatcher

   Copyright (C)
     2013,            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.

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

#include "steam/engine/mock-dispatcher.hpp"
#include "vault/gear/nop-job-functor.hpp"
#include "lib/test/test-helper.hpp"
#include "lib/time/timevalue.hpp"
#include "vault/real-clock.hpp"
#include "lib/hash-combine.hpp"
#include "lib/null-value.hpp"
#include "lib/depend.hpp"
#include "lib/util.hpp"

#include <functional>
#include <unordered_map>


namespace steam {
namespace engine{
namespace test  {
  
  namespace { // MockJob and DummyClosure implementation details...
    
    using lib::rani;
    using lib::HashVal;
    using lib::NullValue;
    using lib::time::TimeVar;
    using std::unordered_map;
    using util::access_or_default;
    
    using vault::gear::JobParameter;
    
    
    const int MAX_PARAM_A(1000);   
    const int MAX_PARAM_B(10);     
    
    
    class DummyClosure
      : public JobClosure
      {
        void
        invokeJobOperation (JobParameter parameter)  override
          {
            invocationLog_[hash_value (parameter)] = Invocation(parameter);
          }
        
        JobKind
        getJobKind()  const override
          {
            return META_JOB;
          }
        
        InvocationInstanceID
        buildInstanceID (HashVal seed)  const override
          {
            InvocationInstanceID instance;
            instance.part.a = seed;
            return instance;
          }
        
        size_t
        hashOfInstance (InvocationInstanceID invoKey) const override
          {
            std::hash<size_t> hashr;
            HashVal res = hashr (invoKey.frameNumber);
            lib::hash::combine (res, hashr (invoKey.part.t));
            return res;
          }
        
        
        /* === Logging/Reporting of job invocation === */
        
        struct Invocation
          {
            TimeVar nominal;
            TimeVar real;
            int a,b;
            
            Invocation (JobParameter param)
              : nominal{TimeValue(param.nominalTime)}
              , real{RealClock::now()}
              , a{param.invoKey.part.a}
              , b{param.invoKey.part.b}
              { }
            
            Invocation()
              : nominal{Time::ANYTIME}
              , real{Time::NEVER}
              , a{MAX_PARAM_A}, b{0}
              { }
          };
        
        unordered_map<HashVal,Invocation> invocationLog_;
        
        
      public:
        Invocation const&
        queryInvocation (JobParameter param)  const
          {
            return access_or_default (invocationLog_, hash_value(param)
                                     ,NullValue<Invocation>::get());
          }
        
        void
        clearLog()
          {
            invocationLog_.clear();
          }
      };
    
    
    
    DummyClosure dummyClosure;
    
    lib::Depend<vault::gear::NopJobFunctor> nopFunctor;
    
  }// (End)Implementation details
  
  
  
  
  
  
  
  
  Job
  MockJob::build()
  {
    InvocationInstanceID invoKey;
    invoKey.part.a = rani (MAX_PARAM_A);
    invoKey.part.b = rani (2*MAX_PARAM_B - MAX_PARAM_B);
    
    Time nominalTime = lib::test::randTime();
    
    return Job(dummyClosure, invoKey, nominalTime);
  }
  
  
  Job
  MockJob::build (Time nominalTime, int additionalKey)
  {
    InvocationInstanceID invoKey;
    invoKey.part.a = additionalKey;
    invoKey.part.b = rani (2*MAX_PARAM_B - MAX_PARAM_B);
    
    return Job(dummyClosure, invoKey, nominalTime);
  }
  
  
  bool
  MockJob::was_invoked (Job const& job)
  {
    REQUIRE (job.usesClosure (dummyClosure));
    
    return Time::NEVER != dummyClosure.queryInvocation(job.parameter).real;
  }
  
  
  Time
  MockJob::invocationTime (Job const& job)
  {
    REQUIRE (job.usesClosure (dummyClosure));
    
    return dummyClosure.queryInvocation(job.parameter).real;
  }
  
  
  Time
  MockJob::invocationNominalTime (Job const& job)
  {
    REQUIRE (job.usesClosure (dummyClosure));
    
    return dummyClosure.queryInvocation(job.parameter).nominal;
  }
  
  
  int
  MockJob::invocationAdditionalKey (Job const& job)
  {
    REQUIRE (job.usesClosure (dummyClosure));
    
    return dummyClosure.queryInvocation(job.parameter).a;
  }
  
  
  JobClosure&
  MockJob::getFunctor()
  {
    return dummyClosure;
  }

  bool
  MockJob::isNopJob (Job const& job)
  {
    InvocationInstanceID empty; 
    JobClosure& jobFunctor = static_cast<JobClosure&> (*job.jobClosure);     
    return lumiera_invokey_eq (&util::unConst(job).parameter.invoKey, &empty)
       and util::isSameObject (jobFunctor, nopFunctor());
  }

  
  
}}} // namespace steam::engine::test