diff-tree-mutation-listener-test.cpp

Go to the documentation of this file.

/*
  DiffTreeMutationListener(Test)  -  verify notification on structural changes

  Copyright (C)         Lumiera.org
    2019,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

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

#include "lib/test/run.hpp"
#include "lib/diff/mutation-message.hpp"
#include "lib/diff/tree-diff-application.hpp"
#include "lib/format-util.hpp"
#include "lib/util.hpp"

#include <boost/algorithm/string.hpp>
#include <string>
#include <vector>

using util::isnil;
using std::string;
using std::vector;


namespace lib {
namespace diff{
namespace test{
  
  namespace {//Test fixture....
    
    // some symbolic values to be used within the diff
    const GenNode VAL_A{"a"},
                  VAL_B{"b"},
                  VAL_C{"c"},
                  VAL_D{"d"},
                  
                  VAL_C_UPPER{"C"},
                  VAL_D_UPPER{"D"};
    
    string
    contents (vector<string> const& strings)
    {
      return util::join (strings);
    }
    
    string
    lowerCase (string src)
    {
      return boost::algorithm::to_lower_copy(src); //WARNING: only works for ASCII
    }
    
    bool
    caseInsensitiveEqual (string a, string b)
    {
      return lowerCase (a) == lowerCase (b);
    }
  }//(End)Test fixture
  
  
  
  
  
  
  
  
  
  /****************************************************************************/
  class DiffTreeMutationListener_test
    : public Test
    , public DiffMutable
    , TreeDiffLanguage
    {
      std::vector<string> subject_;
      int structChanges_ = 0;
      int localChanges_ = 0;
      
      void
      buildMutator (TreeMutator::Handle buff)  override
        {
          buff.emplace (
            TreeMutator::build()
              .attach (collection (subject_)
                        .matchElement ([](GenNode const& spec, string const& elm) -> bool
                                          {                                    // »Matcher« : what target string "matches" a diff spec?
                                            return caseInsensitiveEqual(elm, spec.data.get<string>());
                                          })
                        .assignElement ([](string& target, GenNode const& spec) -> bool
                                          {                                    // »Setter« : how to assign the value from the spec to the target
                                            target = spec.data.get<string>();
                                            return true;
                                          }))
              .onSeqChange ([&]()
                  {
                    ++structChanges_;    // Note: these lambdas are the key point for this test
                  })
              .onLocalChange ([&]()
                  {
                    ++localChanges_;
                  })
            );
        }
      
      
      virtual void
      run (Arg)
        {
          CHECK (isnil (subject_));
          CHECK (0 == structChanges_);
          CHECK (0 == localChanges_);
          
          DiffApplicator<DiffTreeMutationListener_test> applicator{*this};
          
          applicator.consume (MutationMessage{{ins (VAL_A)
                                             , ins (VAL_C)
                                             , ins (VAL_D)
                                             , ins (VAL_C)
                                             }});
          CHECK ("a, c, d, c" == contents(subject_));
          CHECK (1 == structChanges_);
          CHECK (1 == localChanges_);
          
          applicator.consume (MutationMessage{{after(Ref::END)
                                             , set (VAL_C_UPPER)    // Note: the current element is tried first, which happens to match
                                             , set (VAL_D_UPPER)    //       ...while in this case, a linear search finds the "d"
                                             }});
          CHECK ("a, c, D, C" == contents(subject_));
          CHECK (1 == structChanges_);                              // Note: the listener has not fired, since this counts as value change.
          CHECK (2 == localChanges_);
          
          applicator.consume (MutationMessage{{pick(VAL_A)
                                             , ins (VAL_B)
                                             , find(VAL_D)
                                             , pick(VAL_C)
                                             , skip(VAL_D)
                                             , del (VAL_C)
                                             }});
          CHECK ("a, b, D, c" == contents(subject_));
          CHECK (2 == structChanges_);                              // Note: this obviously is a structure change, so both listeners fired.
          CHECK (3 == localChanges_);
          
          applicator.consume (MutationMessage{{after(Ref::END)
                                             }});
          CHECK ("a, b, D, c" == contents(subject_));
          CHECK (2 == structChanges_);                              // Note: contents confirmed as-is, none of the listeners is invoked.
          CHECK (3 == localChanges_);
        }
    };
  
  
  LAUNCHER (DiffTreeMutationListener_test, "unit common");
  
  
  
}}} // namespace lib::diff::test