event-log.hpp

Go to the documentation of this file.

/*
  EVENT-LOG.hpp  -  test facility to verify the occurrence of expected events

   Copyright (C)
     2015,            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.

*/


#ifndef LIB_TEST_EVENT_LOG_H
#define LIB_TEST_EVENT_LOG_H


#include "lib/error.hpp"
#include "lib/iter-cursor.hpp"
#include "lib/iter-chain-search.hpp"
#include "lib/format-util.hpp"
#include "lib/format-cout.hpp"
#include "lib/diff/record.hpp"
#include "lib/idi/genfunc.hpp"
#include "lib/symbol.hpp"
#include "lib/util.hpp"

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



namespace lib {
namespace test{
  
  using lib::Symbol;
  using std::string;
  using util::collectStr;
  
  namespace {
    using Entry = lib::diff::Record<string>;
    using Log   = std::vector<Entry>;
    
    auto
    buildSearchFilter(Log const& srcSeq)
    {
      using Cursor  = lib::iter::CursorGear<Log::const_iterator>;
      return iter::chainSearch (Cursor{srcSeq.begin(), srcSeq.end()});
    }
  }
  
  
  class EventMatch
    {
      using Filter = decltype( buildSearchFilter (std::declval<Log const&>()) );
      
      using ArgSeq = lib::diff::RecordSetup<string>::Storage;
      using RExSeq = std::vector<std::regex>;
      
      
      Filter solution_;
      
      string lastMatch_;
      
      bool look_for_match_;
      
      string violation_;
      
      
      
      EventMatch(Log const& srcSeq);
      
      friend class EventLog;
      
      
    public:
      operator bool()  const
        {
          if (not util::isnil (violation_))
            {
              cerr << "__Log_condition_violated__\n"+violation_ <<"\n";
              return false;
            }
          return true;
        }
      
      
      /* query builders to continue search at current position */
      
      EventMatch& locate (string match);
      EventMatch& locateMatch (string regExp);
      EventMatch& locateEvent (string match);
      EventMatch& locateEvent (string classifier, string match);
      EventMatch& locateCall (string match);
      
      
      /* query builders to find a match stepping forwards */
      
      EventMatch& before (string match);
      EventMatch& beforeMatch (string regExp);
      EventMatch& beforeEvent (string match);
      EventMatch& beforeEvent (string classifier, string match);
      EventMatch& beforeCall (string match);
      
      
      /* query builders to find a match stepping backwards */
      
      EventMatch& after (string match);
      EventMatch& afterMatch (string regExp);
      EventMatch& afterEvent (string match);
      EventMatch& afterEvent (string classifier, string match);
      EventMatch& afterCall (string match);
      
      template<typename...ARGS>
      EventMatch&
      arg (ARGS const& ...args)
        {
          refineSerach_matchArguments (collectStr<ArgSeq> (args...));
          return *this;
        }
      
      
      template<typename...ARGS>
      EventMatch&
      argMatch (ARGS const& ...regExps)
        {
          refineSerach_matchArgsRegExp (collectStr<RExSeq> (regExps...),
                                        util::join(collectStr<ArgSeq>(regExps...)));
          return *this;
        }
      
      template<typename ARG>
      EventMatch&
      argPos (size_t idx, ARG const& arg)
        {
          refineSerach_matchArgument (idx, util::toString(arg));
          return *this;
        }
      
      
      /* query builders to augment and refine the currently defined search condition*/
      
      EventMatch& type (string typeID);
      EventMatch& key (string key);
      EventMatch& attrib (string key, string valueMatch);
      EventMatch& id (string classifier);
      EventMatch& on (string targetID);
      EventMatch& on (const char* targetID);
      
      template<typename X>
      EventMatch& on (const X *const targetObj)
        {
          string targetID = idi::instanceTypeID (targetObj);
          return this->on(targetID);
        }
      
    private:
      bool foundSolution();
      void evaluateQuery (string matchSpec, Literal rel = "after");
      
      void refineSerach_matchArgument (size_t idx, string match);
      void refineSerach_matchArguments (ArgSeq&& argSeq);
      void refineSerach_matchArgsRegExp (RExSeq&& regExpSeq, string rendered_regExps);
    };
  
  
  
  
  
  
  
  
  /****************************************************************/
  class EventLog
    {
      
      std::shared_ptr<Log> log_;
      
      
      void
      log (std::initializer_list<string> const& ili)
        {
          log_->emplace_back(ili);
        }
      
      template<typename ATTR, typename ARGS>
      void
      log (Symbol typeID, ATTR&& attribs, ARGS&& args)
        {
          log_->emplace_back(typeID, std::forward<ATTR>(attribs)
                                   , std::forward<ARGS>(args));
        }
      
      
    public:
      explicit
      EventLog (string logID);
      
      explicit
      EventLog (const char* logID)
        : EventLog(string(logID))
        { }
      
      template<class X>
      explicit
      EventLog (const X *const obj)
        : EventLog(idi::instanceTypeID (obj))
        { }
      
      
      // standard copy operations acceptable
      
      
      string
      getID()  const
        {
          return log_->front().get("this");
        }
      
      
      EventLog& joinInto (EventLog& otherLog);
      
      
      EventLog& clear();
      EventLog& clear (string alteredLogID);
      EventLog& clear (const char* alteredLogID);
      
      template<class X>
      EventLog&
      clear (const X *const obj)
        {
          return clear (idi::instanceTypeID (obj));
        }
      
      
      
      /* ==== Logging API ==== */
      
      using ArgSeq = lib::diff::RecordSetup<string>::Storage;
      
      EventLog& event (string text);
      
      EventLog& event (string classifier, string text);
      
      template<typename...ELMS>
      EventLog&
      event (string classifier, ELMS const& ...initialiser)
        {
          log ("event", ArgSeq{"ID="+classifier}, collectStr<ArgSeq> (initialiser...));
          return *this;
        }
      
      EventLog& call (string target, string function);
      
      EventLog& call (string target, string function, ArgSeq&& args);
      
      EventLog& call (const char* target, const char* function, ArgSeq&& args);
      
      template<typename...ARGS>
      EventLog&
      call (string target, string function, ARGS const& ...args)
        {
          return call (target, function, collectStr<ArgSeq>(args...));
        }
      
      template<class X, typename...ARGS>
      EventLog&
      call (const X *const targetObj, string function, ARGS const& ...args)
        {
          return call (idi::instanceTypeID (targetObj), function, args...);
        }
      
      template<typename...ARGS>
      EventLog&
      call (const char* target, string function, ARGS const& ...args)
        {
          return call (string(target), function, args...);
        }
      
      template<typename...ELMS>
      EventLog&
      note (ELMS const& ...initialiser)
        {
          log_->emplace_back (collectStr<ArgSeq> (initialiser...));
          return *this;
        }

      
      EventLog& warn (string text);
      
      EventLog& error (string text);
      
      EventLog& fatal (string text);
      
      EventLog& create (string text);

      
      EventLog& destroy (string text);
      
      
      template<typename X, typename...ARGS>
      EventLog&
      addAttrib (string const& key, X&& initialiser, ARGS&& ...args)
        {
          REQUIRE (not isnil (*log_));
          mutateInPlace (log_->back())
                        .attrib(key,initialiser, std::forward<ARGS>(args)...);
          return *this;
        }
      
      
      
      
      /* ==== Iteration ==== */
      
      bool
      empty()  const
        {
          return 1 >= log_->size();  // do not count the log header
        }
      
      
      using Iter  = lib::RangeIter<Log::const_iterator>;
      
      typedef Iter const_iterator;
      typedef const Entry value_type;
      
      const_iterator begin() const { return Iter(log_->begin(), log_->end()); }
      const_iterator end()   const { return Iter(); }
      
      friend const_iterator begin (EventLog const& log) { return log.begin(); }
      friend const_iterator end   (EventLog const& log) { return log.end(); }
      
      
      
      
      /* ==== Query/Verification API ==== */
      
      EventMatch verify (string match)  const;
      
      EventMatch verifyMatch (string regExp)  const;
      
      EventMatch verifyEvent (string match)  const;
      
      EventMatch verifyEvent (string classifier, string match)  const;
      
      template<typename X>
      EventMatch
      verifyEvent (string classifier, X const& something)  const
        {
          return verifyEvent (classifier, util::toString (something));
        }
      
      EventMatch verifyCall (string match)  const;
      
      EventMatch
      ensureNot (string match)  const;
      
      
      
      
      friend bool
      operator== (EventLog const& l1, EventLog const& l2)
      {
        return l1.log_ == l2.log_
            or (l1.log_ and l2.log_
                and *l1.log_ == *l2.log_);
      }
      friend bool
      operator!= (EventLog const& l1, EventLog const& l2)
      {
        return not (l1 == l2);
      }
    };
  
  
  
}} // namespace lib::test
#endif /*LIB_TEST_EVENT_LOG_H*/