diff-complex-application-test.cpp

Go to the documentation of this file.

/*
  DiffComplexApplication(Test)  -  apply structural changes to unspecific private data structures

   Copyright (C)
     2016,            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/format-util.hpp"
#include "lib/diff/tree-diff-application.hpp"
#include "lib/diff/test-mutation-target.hpp"
#include "lib/iter-adapter-stl.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/format-string.hpp"
#include "lib/format-cout.hpp"
#include "lib/util.hpp"

#include <string>
#include <vector>
#include <memory>

using util::isnil;
using util::join;
using util::_Fmt;
using util::BOTTOM_INDICATOR;
using lib::iter_stl::snapshot;
using lib::time::Time;
using std::unique_ptr;
using std::string;
using std::vector;


namespace lib {
namespace diff{
namespace test{
  
  namespace {//Test fixture....
    
    // define some GenNode elements
    // to act as templates within the concrete diff
    // NOTE: everything in this diff language is by-value
    const GenNode ATTRIB1("α", 1),                         // attribute α = 1
                  ATTRIB2("β", int64_t(2)),                // attribute α = 2L   (int64_t)
                  ATTRIB3("γ", 3.45),                      // attribute γ = 3.45 (double)
                  TYPE_X("type", "ξ"),                     // a "magic" type attribute "Xi"
                  TYPE_Z("type", "ζ"),                     // 
                  CHILD_A("a"),                            // unnamed string child node
                  CHILD_B('b'),                            // unnamed char child node
                  CHILD_T(Time(12,34,56,78)),              // unnamed time value child
                  SUB_NODE = MakeRec().genNode(),          // empty anonymous node used to open a sub scope
                  ATTRIB_NODE = MakeRec().genNode("δ"),    // empty named node to be attached as attribute δ
                  GAMMA_PI("γ", 3.14159265);               // happens to have the same identity (ID) as ATTRIB3
    
    
    class Opaque
      {
        idi::BareEntryID key_;
        string type_ = Rec::TYPE_NIL;
        
        int  alpha_   = -1;
        int64_t beta_ = -1;
        double gamma_ = -1;
        
        unique_ptr<Opaque> delta_;
        
        vector<Opaque> nestedObj_;
        vector<string> nestedData_;
        
      public:
        Opaque()
          : key_(idi::EntryID<Opaque>())
          { }
        
        explicit
        Opaque (string keyID)
          : key_(idi::EntryID<Opaque>(keyID))
          { }
        
        explicit
        Opaque (idi::BareEntryID id)
          : key_(id)
          { }
        
        Opaque (Opaque const& o)
          : key_(o.key_)
          , type_(o.type_)
          , alpha_(o.alpha_)
          , beta_(o.beta_)
          , gamma_(o.gamma_)
          , delta_()
          , nestedObj_(o.nestedObj_)
          , nestedData_(o.nestedData_)
          {
            if (o.delta_)
              delta_.reset(new Opaque(*o.delta_));
          }
        
        Opaque&
        operator= (Opaque const& o)
          {
            if (&o != this)
              {
                Opaque tmp(o);
                swap (*this, tmp);
              }
            return *this;
          }
        
        bool verifyType(string x)    const { return x == type_; }
        bool verifyAlpha(int x)      const { return x == alpha_;}
        bool verifyBeta(int64_t x)   const { return x == beta_; }
        bool verifyGamma(double x)   const { return x == gamma_;}
        bool verifyData(string desc) const { return desc == join(nestedData_); }
        const Opaque* nestedDelta()  const { return not delta_? NULL : delta_.get(); }
        const Opaque* nestedObj_1()  const { return isnil(nestedObj_)? NULL : &nestedObj_[0]; }
        
        
        operator string()  const
          {
            return _Fmt{"%s__(α:%d β:%s γ:%7.5f δ:%s\n......|nested:%s\n......|data:%s\n      )__END_%s"}
                       % identity()
                       % alpha_
                       % beta_
                       % gamma_
                       % delta_
                       % join (nestedObj_, "\n......|")
                       % join (nestedData_)
                       % identity()
                       ;
          }
        
        string
        identity()  const
          {
            string symbol = key_.getSym() + (isTyped()? "≺"+type_+"≻" : "");
            return lib::idi::format::instance_hex_format(symbol, key_.getHash());
          }
        
        bool
        isTyped()  const
          {
            return Rec::TYPE_NIL != type_;
          }
        
        
        void
        buildMutator (TreeMutator::Handle buff)
          {
            buff.emplace (
              TreeMutator::build()
                .attach (collection(nestedData_)
                       .isApplicableIf ([&](GenNode const& spec) -> bool
                          {
                            return not spec.isNamed();                // »Selector« : accept anything unnamed value-like
                          })
                       .matchElement ([&](GenNode const& spec, string const& elm) -> bool
                          {
                            return elm == render(spec.data);          // »Matcher« : does the diff verb #spec apply to this object?
                          })
                       .constructFrom ([&](GenNode const& spec) -> string
                          {
                            return render (spec.data);                // »Constructor« : build a new child entity to reflect the given diff #spec
                          })
                       .assignElement ([&](string& target, GenNode const& spec) -> bool
                          {
                            target = render (spec.data);              // »Assigner« : treat this object as value and assign data from the #spec payload
                            return true;
                          }))
                .attach (collection(nestedObj_)
                       .isApplicableIf ([&](GenNode const& spec) -> bool
                          {
                            return spec.data.isNested();              // »Selector« : require object-like sub scope
                          })
                       .matchElement ([&](GenNode const& spec, Opaque const& elm) -> bool
                          {
                            return spec.idi == elm.key_;
                          })
                       .constructFrom ([&](GenNode const& spec) -> Opaque
                          {
                            return Opaque{spec.idi};
                          })
                       .buildChildMutator ([&](Opaque& target, GenNode::ID const&, TreeMutator::Handle buff) -> bool
                          {
                            target.buildMutator (buff);               // »Recursive Mutator« : delegate to child for building a nested TreeMutator
                            return true;
                          }))
                .change("type", [&](string typeID)
                    {
                      type_ = typeID;
                    })
                .change("α", [&](int val)
                    {
                      alpha_ = val;
                    })
                .change("β", [&](int64_t val)
                    {
                      beta_ = val;
                    })
                .change("γ", [&](double val)
                    {
                      gamma_ = val;
                    })
                .mutateAttrib("δ", [&](TreeMutator::Handle buff)
                    {
                      if (not delta_)                     // note: object is managed automatically,
                        delta_.reset (new Opaque("δ"));  //        thus no INS-implementation necessary
                      REQUIRE (delta_);
                      
                      delta_->buildMutator(buff);
                    }));
          }
        
        friend constexpr size_t
        treeMutatorSize (const Opaque*)
        {
          return 430;
        }
      };
    
  }//(End)Test fixture
  
  
  
  
  
  
  
  /***********************************************************************/
  class DiffComplexApplication_test
    : public Test
    , TreeDiffLanguage
    {
      using DiffSeq = iter_stl::IterSnapshot<DiffStep>;
      
      DiffSeq
      populationDiff()
        {
          return snapshot({ins(ATTRIB1)
                         , ins(ATTRIB3)
                         , ins(ATTRIB3)
                         , ins(CHILD_B)
                         , ins(CHILD_B)
                         , ins(CHILD_T)
                         });
        }                // ==> ATTRIB1, ATTRIB3, (ATTRIB3), CHILD_B, CHILD_B, CHILD_T
      
      DiffSeq
      reorderingDiff()
        {
          return snapshot({after(Ref::ATTRIBS)
                         , ins(ATTRIB2)
                         , del(CHILD_B)
                         , ins(SUB_NODE)
                         , find(CHILD_T)
                         , pick(CHILD_B)
                         , skip(CHILD_T)
                         });
        }                // ==> ATTRIB1, ATTRIB3, (ATTRIB3), ATTRIB2, SUB_NODE, CHILD_T, CHILD_B
        
      DiffSeq
      mutationDiff()
        {
          return snapshot({after(CHILD_B)
                         , after(Ref::END)
                         , set(GAMMA_PI)
                         , mut(SUB_NODE)
                           , ins(TYPE_X)
                           , ins(ATTRIB2)
                           , ins(CHILD_B)
                           , ins(CHILD_A)
                         , emu(SUB_NODE)
                         , ins(ATTRIB_NODE)
                         , mut(ATTRIB_NODE)
                           , ins(TYPE_Z)
                           , ins(CHILD_A)
                           , ins(CHILD_A)
                           , ins(CHILD_A)
                         , emu(ATTRIB_NODE)
                         });
        }                // ==> ATTRIB1, ATTRIB3 := π, (ATTRIB3), ATTRIB2,
                         //     ATTRIB_NODE{ type ζ, CHILD_A, CHILD_A, CHILD_A }
                         //     SUB_NODE{ type ξ, ATTRIB2, CHILD_B, CHILD_A },
                         //     CHILD_T, CHILD_B
      
      
      
      
      virtual void
      run (Arg)
        {
          Opaque subject;
          DiffApplicator<Opaque> application(subject);
          //
          cout << "before..."<<endl << subject<<endl;
          CHECK (subject.verifyAlpha(-1));
          CHECK (subject.verifyBeta(-1));
          CHECK (subject.verifyGamma(-1));
          CHECK (not subject.nestedDelta());
          CHECK (not subject.nestedObj_1());
          CHECK (subject.verifyData(""));
          
          
          // Part I : apply attribute changes
          application.consume(populationDiff());
          //
          cout << "after...I"<<endl << subject<<endl;
          // ==> ATTRIB1, ATTRIB3, (ATTRIB3), CHILD_B, CHILD_B, CHILD_T
          CHECK (subject.verifyAlpha(1));
          CHECK (subject.verifyGamma(ATTRIB3.data.get<double>()));
          CHECK (subject.verifyData("b, b, 78:56:34.012"));
          // unchanged...
          CHECK (subject.verifyBeta(-1));
          CHECK (not subject.nestedDelta());
          CHECK (not subject.nestedObj_1());
          
          
          // Part II : apply child population
          application.consume(reorderingDiff());
          //
          cout << "after...II"<<endl << subject<<endl;
          // ==> ATTRIB1, ATTRIB3, (ATTRIB3), ATTRIB2, SUB_NODE, CHILD_T, CHILD_B
          CHECK (subject.verifyAlpha(1));
          CHECK (subject.verifyBeta (2));                     // attribute β has been set
          CHECK (subject.verifyGamma(3.45));
          CHECK (subject.verifyData("78:56:34.012, b"));      // one child deleted, the other ones re-ordered
          CHECK (subject.nestedObj_1());                      // plus inserted a nested child object
          CHECK (subject.nestedObj_1()->verifyType(Rec::TYPE_NIL));
          CHECK (subject.nestedObj_1()->verifyBeta(-1));      // ...which is empty (default constructed)
          CHECK (subject.nestedObj_1()->verifyData(""));
          
          
          // Part III : apply child mutations
          application.consume(mutationDiff());
          //
          cout << "after...III"<<endl << subject<<endl;
          // ==> ATTRIB1, ATTRIB3 := π, (ATTRIB3), ATTRIB2,
          //     ATTRIB_NODE{ type ζ, CHILD_A, CHILD_A, CHILD_A }
          //     SUB_NODE{ type ξ, ATTRIB2, CHILD_B, CHILD_A },
          //     CHILD_T, CHILD_B
          CHECK (subject.verifyAlpha(1));
          CHECK (subject.verifyBeta (2));
          CHECK (subject.verifyGamma(GAMMA_PI.data.get<double>())); // new value assigned to attribute γ
          CHECK (subject.nestedDelta());                      // attribute δ (object valued) is now present
          CHECK (subject.nestedDelta()->verifyType("ζ"));     // ...and has an explicitly defined type field
          CHECK (subject.nestedDelta()->verifyData("a, a, a"));//...plus three similar child values
          CHECK (subject.verifyData("78:56:34.012, b"));      // the child values weren't altered
          CHECK (subject.nestedObj_1()->verifyType("ξ"));     // but the nested child object's type has been set
          CHECK (subject.nestedObj_1()->verifyBeta(2));       // ...and the attribute β has been set on the nested object
          CHECK (subject.nestedObj_1()->verifyData("b, a"));  // ...plus some child values where added here     
        }
    };
  
  
  LAUNCHER (DiffComplexApplication_test, "unit common");
  
  
  
}}} // namespace lib::diff::test