canvas-hook-test.cpp

Go to the documentation of this file.

/*
  CanvasHook(Test)  -  verify abstracted canvas 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/canvas-hook.hpp"
#include "lib/scoped-collection.hpp"
#include "lib/iter-explorer.hpp"
#include "lib/iter-adapter-stl.hpp"
#include "lib/util.hpp"
 
#include <vector>
#include <forward_list>
#include <algorithm>
#include <random>
 
 
using util::isnil;
using util::contains;
using util::isSameObject;
using lib::iter_stl::eachElm;
using std::vector;
using std::forward_list;
using std::shuffle;
 
 
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 = CanvasHooked<DummyWidget>;
    
    
    
    class FakeCanvas
      : public CanvasHook<DummyWidget>
      {
        struct Attachment
          {
            DummyWidget& widget;
            int posX, posY;
          };
        forward_list<Attachment> widgets_;
 
        
        auto
        allWidgetIDs()  const
          {
            return lib::explore(widgets_)
                       .transform([](Attachment const& entry)
                                    {
                                      return entry.widget.i;
                                    });
          }
        
        auto
        findEntry (DummyWidget const& someWidget)
          {
            return std::find_if (widgets_.begin()
                                ,widgets_.end()
                                , [&](Attachment const& a) { return a.widget == someWidget; });
          }
        
      public:
        /* === diagnostic functions for the test === */
        bool
        empty()  const
          {
            return widgets_.empty();
          }
        
        bool
        testContains (int someWidgetID)
          {
            return util::linearSearch (allWidgetIDs(), someWidgetID);
          }
        
        bool
        testVerifyPos (DummyWidget const& someWidget, int x_expected, int y_expected)
          {
            auto end = widgets_.end();
            auto pos = findEntry (someWidget);
            return pos != end
               and pos->posX == x_expected
               and pos->posY == y_expected;
          }
        
        
        /* === Interface CanvasHook === */
        
        void
        hook (DummyWidget& elm, int xPos, int yPos)  override
          {
            widgets_.push_front (Attachment{elm, xPos,yPos});
          }
        
        void
        move (DummyWidget& elm, int xPos, int yPos)  override
          {
            auto end = widgets_.end();
            auto pos = findEntry (elm);
            if (pos != end)
              {
                pos->posX = xPos;
                pos->posY = yPos;
              }
          }
        
        void
        remove (DummyWidget& elm)  override
          {
            widgets_.remove_if ([&](Attachment const& a) { return a.widget == elm; });
          }
        
      protected:
        DisplayMetric&
        getMetric()  const override
          {
            NOTREACHED ("Time to pixel translation not covered in this unit test");
          }
      };
  }
  
  
  
  
  /*************************************************************************************/
  class CanvasHook_test : public Test
    {
      
      virtual void
      run (Arg)
        {
          seedRand();
          attach2canvas();
          relocateWidget();
        }
      
      
      void
      attach2canvas()
        {
          FakeCanvas canvas;
          CHECK (canvas.empty());
          
          HookedWidget widget{canvas.hookedAt(1,1)};
          CHECK (canvas.testVerifyPos (widget, 1,1));
          CHECK (not canvas.empty());
          
          int someID;
          {
            HookedWidget otherWidget{canvas.hookedAt(2,2)};
            someID = otherWidget.i;
            CHECK (canvas.testContains (someID));
            CHECK (canvas.testContains (widget.i));
            CHECK (canvas.testVerifyPos (widget, 1,1));
            CHECK (canvas.testVerifyPos (otherWidget, 2,2));
          }// hook goes out of scope...
          CHECK (not canvas.testContains (someID));
          CHECK (canvas.testContains (widget.i));
          CHECK (not canvas.empty());
        }
      
      
      void
      relocateWidget()
        {
          int x1 = rani (100);
          int y1 = rani (100);
          int x2 = rani (100);
          int y2 = rani (100);
          int x3 = rani (100);
          int y3 = rani (100);
          
          FakeCanvas canvas;
          HookedWidget w1{canvas.hookedAt(x1,y1)};
          HookedWidget w3{canvas.hookedAt(x3,y3)};
          
          int id2;
          {
            HookedWidget w2{canvas.hookedAt(x2,y2)};
            id2 = w2.i;
            CHECK (canvas.testContains (id2));
            CHECK (canvas.testVerifyPos (w2, x2,y2));
            
            int newX = ++x2;
            int newY = --y2;
            w2.moveTo (newX,newY);
            
            CHECK (canvas.testVerifyPos (w2, newX,newY));
            CHECK (canvas.testVerifyPos (w1, x1,y1));
            CHECK (canvas.testVerifyPos (w3, x3,y3));
          }
          CHECK (not canvas.testContains (id2));
          CHECK (canvas.testVerifyPos (w1, x1,y1));
          CHECK (canvas.testVerifyPos (w3, x3,y3));
        }
    };
  
  
  LAUNCHER (CanvasHook_test, "unit gui");
  
  
}}} // namespace stage::model::test