view-hook-test.cpp

Go to the documentation of this file.

/*
  ViewHook(Test)  -  verify abstracted presentation attachment
 
   Copyright (C)
     2019,            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/test/test-helper.hpp"
#include "stage/model/view-hook.hpp"
#include "lib/scoped-collection.hpp"
#include "lib/iter-explorer.hpp"
#include "lib/iter-adapter-stl.hpp"
#include "lib/util.hpp"
 
#include <list>
#include <vector>
#include <algorithm>
#include <random>
 
 
using util::isnil;
using util::contains;
using util::isSameObject;
using lib::iter_stl::eachElm;
using std::shuffle;
using std::vector;
 
 
namespace stage{
namespace model{
namespace test {
  
  
  namespace { // Test fixture...
    
    struct DummyWidget
      {
        int i = rani(); // "identity"
        
        friend bool
        operator== (DummyWidget const& wa, DummyWidget const& wb)
        {
          return wa.i == wb.i; // compare identity
        }
      };
    
    using HookedWidget = ViewHooked<DummyWidget>;
    
    
    
    class FakeCanvas
      : public ViewHook<DummyWidget>
      {
        std::list<DummyWidget> widgets_;
        
        auto
        allWidgetIDs()  const
          {
            return lib::explore(widgets_)
                       .transform([](DummyWidget const& entry)
                                    {
                                      return entry.i;
                                    });
          }
        
        auto
        findEntry (DummyWidget const& someWidget)
          {
            return std::find_if (widgets_.begin()
                                ,widgets_.end()
                                , [&](DummyWidget const& widget) { return widget == someWidget; });
          }
        
      public:
        /* === diagnostic functions for the test === */
        bool
        empty()  const
          {
            return widgets_.empty();
          }
        
        bool
        testContains (int someWidgetID)
          {
            return util::linearSearch (allWidgetIDs(), someWidgetID);
          }
        
        template<class IT>
        bool
        testContainsSequence (IT refSeq)
          {
            auto ids = allWidgetIDs();
            for ( ; refSeq and ids; ++refSeq, ++ids)
              if (refSeq->i != *ids) break;
            return isnil(refSeq)
               and isnil(ids);
          }
        
        
        /* === Interface ViewHook === */
        
        void
        hook (DummyWidget& elm)  override
          {
            widgets_.push_back (elm);
          }
        
        void
        remove (DummyWidget& elm)  override
          {
            widgets_.remove_if ([&](auto const& widget) { return widget == elm; });
          }
        
        
        void
        rehook (DummyWidget& existingHook)  noexcept override
          {
            auto pos = findEntry (existingHook);
            REQUIRE (pos != widgets_.end(), "the given iterator must yield previously hooked-up elements");
            DummyWidget& widget{*pos};
            this->remove (widget);
            this->hook (widget);
          }
      };
  }
  
  
  
  
  /*************************************************************************************/
  class ViewHook_test : public Test
    {
      
      virtual void
      run (Arg)
        {
          seedRand();
          verify_standardUsage();
          verify_multiplicity();
          reOrderHooked();
        }
      
      
      void
      verify_standardUsage()
        {
          FakeCanvas canvas;
          CHECK (canvas.empty());
          {
            HookedWidget widget{canvas};
            CHECK (canvas.testContains (widget.i));
            CHECK (not canvas.empty());
          }// hook goes out of scope...
          CHECK (canvas.empty());
        }
      
      
      void
      verify_multiplicity()
        {
          FakeCanvas canvas;
          CHECK (canvas.empty());
          
          HookedWidget widget{canvas};
          CHECK (canvas.testContains (widget.i));
          CHECK (not canvas.empty());
          
          int someID;
          {
            HookedWidget otherWidget{canvas};
            someID = otherWidget.i;
            CHECK (canvas.testContains (someID));
            CHECK (canvas.testContains (widget.i));
          }// hook goes out of scope...
          CHECK (not canvas.testContains (someID));
          CHECK (canvas.testContains (widget.i));
          CHECK (not canvas.empty());
        }
      
      
      void
      reOrderHooked()
        {
          using Widgets = lib::ScopedCollection<HookedWidget>;
          using OrderIdx  = vector<HookedWidget*>;
          
          FakeCanvas canvas; // WARNING: Canvas must outlive the widgets!
          
          // create 20 (random) widgets and hook them onto the canvas
          Widgets widgets{20};
          OrderIdx orderIdx;
          for (uint i=0; i<20; ++i)
            orderIdx.push_back (& widgets.emplace<HookedWidget>(canvas));
          
          // helper: use the orderIdx to generate sequence of widget refs (not pointers)
          auto orderSequence = [&] { return lib::ptrDeref(eachElm(orderIdx)); };
          
          CHECK (canvas.testContainsSequence (eachElm(widgets)));
          CHECK (canvas.testContainsSequence (orderSequence()));
          
          // now lets assume the relevant order of the widgets has been altered
          shuffle (orderIdx.begin(),orderIdx.end(), std::random_device());
          CHECK (not canvas.testContainsSequence (orderSequence()));
          
          // so we need to re-construct the canvas attachments in the new order
          canvas.reOrder (orderSequence());
          CHECK (canvas.testContainsSequence (orderSequence()));
        }
    };
  
  
  LAUNCHER (ViewHook_test, "unit gui");
  
  
}}} // namespace stage::model::test