late-bind-instance-test.cpp

Go to the documentation of this file.

/*
  LateBindInstance(Test)  -  verify rewriting of member function invocation
 
   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.
 
* *****************************************************************/
 
#include "lib/test/run.hpp"
#include "lib/meta/function.hpp"
#include "lib/meta/tuple-helper.hpp"
#include "lib/test/test-helper.hpp"
#include "lib/test/tracking-dummy.hpp"
#include "lib/format-cout.hpp"
#include "lib/format-util.hpp"
#include "lib/util.hpp"
 
#include <tuple>
#include <string>
 
 
namespace lib  {
namespace meta {
namespace test {
  
  using std::move;
  using std::tuple;
  using std::string;
  using lib::meta::dump;
  using lib::test::Tracker;
  
  
  
  
  
  
  /**********************************************************************************/
  class LateBindInstance_test : public Test
    {
      void
      run (Arg)
        {
          seedRand();
          demonstrateUsage();
          verify_forwarding();
          verify_cornerCases();
        }
      
      
      
      void
      demonstrateUsage()
        {
          uint randomLimit = 2 + rani(98);
          
          auto plannedArgs
            = tuple{InstancePlaceholder<LateBindInstance_test>{}
                   ,randomLimit
                   };
          
          // the actual instance may be available only later...
          Test& instanceRef = *this;
          
          // now rewrite the argument tuple to inject the instance-ptr
          auto preparedArgs = lateBindInstance (instanceRef, plannedArgs);
          
          uint res = std::apply (&LateBindInstance_test::theMember, preparedArgs);
          CHECK (res < randomLimit);
        }
      
      uint
      theMember (uint limit)
        {
          return rani (limit);
        }
      
      
      
      void
      verify_forwarding()
        {
          auto& log = Tracker::log;
          log.clear (this);
          
          InstancePlaceholder<LateBindInstance_test> marker;
          Tracker t1(11);
          
          log.event("construct tuple");
          tuple tup(t1, marker, Tracker{23}, 55);
 
          Test& instanceRef = *this;
          
          log.event("invoke lateBindInstance");
          auto tup1r = lateBindInstance (instanceRef, tup);
          log.event("got result");
          
          // before invocation the Tracker instances are created (obviously..)
          CHECK (log.verifyCall("ctor").arg(11)
                    .beforeCall("ctor-copy").arg("Track{11}")
                    .beforeEvent("invoke lateBindInstance"));
          CHECK (log.verifyCall("ctor").arg(23)
                    .beforeCall("ctor-move").arg("Track{23}")
                    .beforeCall("dtor").arg(Tracker::DEFUNCT)
                    .beforeEvent("invoke lateBindInstance"));
          
          // but there is no copy operation after the invocation
          CHECK (log.ensureNot("ctor-copy")
                    .afterEvent("invoke lateBindInstance"));
          
          // both Tracker instances are moved two times
          // - once to create the maybeInject-invocation and
          // - once to consolidate the result
          // for each instance one moved-away temporary is destroyed
          CHECK (log.verifyEvent("invoke lateBindInstance")
                    .beforeCall("ctor-move").arg("Track{11}")
                    .beforeCall("ctor-move").arg("Track{11}")
                    .beforeCall("dtor").arg(Tracker::DEFUNCT)
                    .beforeEvent("got result"));
          CHECK (log.verifyEvent("invoke lateBindInstance")
                    .beforeCall("ctor-move").arg("Track{23}")
                    .beforeCall("ctor-move").arg("Track{23}")
                    .beforeCall("dtor").arg(Tracker::DEFUNCT)
                    .beforeEvent("got result"));
          
          cout << "____Tracker-Log_______________\n"
               << util::join(Tracker::log,      "\n")
               << "\n───╼━━━━━━━━━━━╾──────────────"<<endl;
        }
      
      
      void
      verify_cornerCases()
        {
          long dummy{555};
          InstancePlaceholder<long> marker;
         CHECK (dump(lateBindInstance (dummy, tuple<>{}))         == "()"_expect);
         CHECK (dump(lateBindInstance (dummy, tuple{42}))         == "(42)"_expect);
         CHECK (dump(lateBindInstance (dummy, tuple{1,2,3}))      == "(1,2,3)"_expect);
         CHECK (dump(lateBindInstance (dummy, tuple{marker,2,3})) == "(↗555,2,3)"_expect);
         CHECK (dump(lateBindInstance (dummy, tuple{1,marker,3})) == "(1,↗555,3)"_expect);
         CHECK (dump(lateBindInstance (dummy, tuple{1,2,marker})) == "(1,2,↗555)"_expect);
         CHECK (dump(lateBindInstance (dummy, tuple{marker}))     == "(↗555)"_expect);
         CHECK (dump(lateBindInstance (dummy, tuple{string{"1"}
                                                   ,"2"
                                                   ,marker
                                                   ,tuple(2,3)
                                                   , 5.5
                                                   }))            == "(1,2,↗555,«tuple<int, int>»──(2,3),5.5)"_expect);
        }
    };
  
  
  LAUNCHER (LateBindInstance_test, "unit meta");
  
  
  
}}} // namespace lib::meta::test