From 991b8ace821f37f65cab39723badba89e62409ef Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Wed, 19 Sep 2018 00:21:09 +0200 Subject: [PATCH] EventLog: rectify the quirky logic for before / after chains due to the lack of real backtracking, the existing solution relied on a quirk, and started the before / after chained search conditions /at/ the current element, not after / before it. Now we're able to remove this somewhat surprising behaviour, yet to do so we also need to introduce basic "just search" variations of all search operations, in order to define the initial condition for a chained search. Without that, the first condition in a chain would never be able to match on the header entry of the log --- src/lib/test/event-log.hpp | 92 +++++++++++++++++++++++++++++++------ wiki/thinkPad.ichthyo.mm | 94 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 171 insertions(+), 15 deletions(-) diff --git a/src/lib/test/event-log.hpp b/src/lib/test/event-log.hpp index 5e13b2019..0e3f36c46 100644 --- a/src/lib/test/event-log.hpp +++ b/src/lib/test/event-log.hpp @@ -319,19 +319,23 @@ namespace test{ /* === configure the underlying search engine === */ enum Direction { - FORWARD, BACKWARD + FORWARD, BACKWARD, CURRENT }; template void attachNextSerchStep (COND&& filter, Direction direction) { - solution_.addStep ([predicate{forward (filter)}, direction] - (auto& filter) - { - filter.reverse (BACKWARD == direction); - filter.setNewFilter (predicate); - }); + if (CURRENT == direction) + solution_.search (forward (filter)); + else + solution_.addStep ([predicate{forward (filter)}, direction] + (auto& filter) + { + filter.reverse (BACKWARD == direction); + ++filter; + filter.setNewFilter (predicate); + }); } template @@ -363,6 +367,60 @@ namespace test{ } + /** + * basic search function: continue linear lookup over the elements of the + * EventLog to find a match (substring match) of the given text. The search begins + * at the current position and proceeds in the currently configured direction. + * Initially the search starts at the first record and proceeds forward. + */ + EventMatch& + locate (string match) + { + attachNextSerchStep (find(match), CURRENT); + evaluateQuery ("match(\""+match+"\")"); + return *this; + } + + /** basic search like locate() but with the given regular expression */ + EventMatch& + locateMatch (string regExp) + { + attachNextSerchStep (findRegExp(regExp), CURRENT); + evaluateQuery ("find-RegExp(\""+regExp+"\")"); + return *this; + } + + /** basic search for a matching "event" + * @param match perform a substring match against the arguments of the event + * @see beforeEvent() for a description of possible "events" + */ + EventMatch& + locateEvent (string match) + { + attachNextSerchStep (findEvent(match), CURRENT); + evaluateQuery ("match-event(\""+match+"\")"); + return *this; + } + + EventMatch& + locateEvent (string classifier, string match) + { + attachNextSerchStep (findEvent(classifier,match), CURRENT); + evaluateQuery ("match-event(ID=\""+classifier+"\", \""+match+"\")"); + return *this; + } + + /** basic search for some specific function invocation + * @param match perform a substring match against the name of the function invoked + */ + EventMatch& + locateCall (string match) + { + attachNextSerchStep (findCall(match), CURRENT); + evaluateQuery ("match-call(\""+match+"\")"); + return *this; + } + /** * find a match (substring match) of the given text * in an EventLog entry after the current position @@ -860,14 +918,15 @@ namespace test{ * The resulting matcher object will qualify on any log entry * containing the given string. By adding subsequent further * query expressions on the returned [matcher object](\ref EventMatch), - * the query can be refined. Refining a query might induce backtracking. - * The final result can be retrieved by `bool` conversion + * the query can be refined. Moreover it is possible to chain up further + * search queries, which will be executing starting from the position of the + * previous match. The final result can be retrieved by `bool` conversion */ EventMatch verify (string match) const { EventMatch matcher(*log_); - matcher.before (match); // "the start of the log is before the match" + matcher.locate (match); // new matcher starts linear search from first log element return matcher; } @@ -881,7 +940,7 @@ namespace test{ verifyMatch (string regExp) const { EventMatch matcher(*log_); - matcher.beforeMatch (regExp); + matcher.locateMatch (regExp); return matcher; } @@ -896,15 +955,18 @@ namespace test{ verifyEvent (string match) const { EventMatch matcher(*log_); - matcher.beforeEvent (match); + matcher.locateEvent (match); return matcher; } + /** start a query to match for an specific kind of element + * @param classifier select kind of event by match on type or ID + */ EventMatch verifyEvent (string classifier, string match) const { EventMatch matcher(*log_); - matcher.beforeEvent (classifier, match); + matcher.locateEvent (classifier, match); return matcher; } @@ -922,7 +984,7 @@ namespace test{ verifyCall (string match) const { EventMatch matcher(*log_); - matcher.beforeCall (match); + matcher.locateCall (match); return matcher; } @@ -940,7 +1002,7 @@ namespace test{ { EventMatch matcher(*log_); matcher.look_for_match_ = false; // flip logic; fail if match succeeds - matcher.before (match); + matcher.locate (match); return matcher; } diff --git a/wiki/thinkPad.ichthyo.mm b/wiki/thinkPad.ichthyo.mm index ef1167ee5..77dd75431 100644 --- a/wiki/thinkPad.ichthyo.mm +++ b/wiki/thinkPad.ichthyo.mm @@ -31775,8 +31775,64 @@ + + + + + + + + +

+ fun after fun matcht auf den immer gleichen Record +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -31820,6 +31876,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +