225 lines
9.1 KiB
C++
225 lines
9.1 KiB
C++
/*
|
|
IterChainSearch(Test) - verify chained search operations with backtracking
|
|
|
|
Copyright (C) Lumiera.org
|
|
2018, 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.
|
|
|
|
* *****************************************************/
|
|
|
|
/** @file iter-chain-search-test.cpp
|
|
** unit test \ref IterChainSearch_test
|
|
*/
|
|
|
|
|
|
|
|
#include "lib/test/run.hpp"
|
|
#include "lib/test/test-helper.hpp"
|
|
#include "lib/format-util.hpp"
|
|
#include "lib/iter-chain-search.hpp"
|
|
#include "lib/iter-cursor.hpp"
|
|
#include "lib/util.hpp"
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
|
|
|
|
|
|
namespace lib {
|
|
namespace iter{
|
|
namespace test{
|
|
|
|
using ::Test;
|
|
using util::join;
|
|
using util::isnil;
|
|
using util::startsWith;
|
|
using util::isSameObject;
|
|
using std::vector;
|
|
using std::string;
|
|
|
|
using lumiera::error::LERR_(ITER_EXHAUST);
|
|
|
|
|
|
namespace { // test fixture
|
|
|
|
using Spam = vector<string>;
|
|
|
|
const Spam SPAM{"spam"
|
|
,"sausage"
|
|
,"spam"
|
|
,"spam"
|
|
,"bacon"
|
|
,"spam"
|
|
,"tomato"
|
|
,"and"
|
|
,"spam"
|
|
};
|
|
|
|
|
|
/** Diagnostic helper: join all the elements from a _copy_ of the iterator */
|
|
template<class II>
|
|
inline string
|
|
materialise (II&& ii)
|
|
{
|
|
return util::join (std::forward<II> (ii), "-");
|
|
}
|
|
}// (END)fixture
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************//**
|
|
* @test verify a setup for consecutive searches with backtracking.
|
|
* - demonstrate simple consecutive matches and iterator behaviour
|
|
* - clear the filter underway and thus return to simple iteration
|
|
* - set up two conditions, the second one capturing state at the
|
|
* point where the first one matches
|
|
* - wrap a lib::IterCursor, which allows to toggle the search
|
|
* direction underway; this creates a situation where the
|
|
* first options picked do not lead to a successful solution,
|
|
* so the search has to track back, try further options and
|
|
* in each case re-apply all the following consecutive
|
|
* search conditions.
|
|
*
|
|
* @see iter-chain-search.hpp
|
|
* @see iter-cursor.hpp
|
|
* @see [usage example](\ref event-log.hpp)
|
|
*/
|
|
class IterChainSearch_test : public Test
|
|
{
|
|
|
|
virtual void
|
|
run (Arg)
|
|
{
|
|
simpleSearch();
|
|
chainedIteration();
|
|
backtracking();
|
|
}
|
|
|
|
|
|
/** @test simple basic use case. */
|
|
void
|
|
simpleSearch ()
|
|
{
|
|
auto search = chainSearch(SPAM)
|
|
.search("bacon")
|
|
.search("tomato");
|
|
|
|
CHECK (search);
|
|
CHECK (not isnil(search));
|
|
CHECK ("tomato" == *search);
|
|
CHECK (isSameObject (*search, SPAM[6]));
|
|
|
|
search.clearFilter();
|
|
CHECK ("tomato" == *search);
|
|
++search;
|
|
CHECK ("and" == *search);
|
|
search.search("spam");
|
|
CHECK ("spam" == *search);
|
|
CHECK (isSameObject (*search, SPAM[8]));
|
|
|
|
++search;
|
|
CHECK (not search);
|
|
CHECK (isnil (search));
|
|
VERIFY_ERROR (ITER_EXHAUST, *search);
|
|
}
|
|
|
|
|
|
|
|
/** @test verify consecutive application of several functors on the underlying filter.
|
|
* In the general case, each step in the chain is a function working on a copy of the
|
|
* current filter state. Since each such step configures its own copy of the complete
|
|
* pipeline, it may reconfigure this filter pipeline in arbitrary ways. After exhausting
|
|
* the last layer, the evaluation returns to the previous layer, but immediately re-applies
|
|
* the configuration step on the then next element.
|
|
*/
|
|
void
|
|
chainedIteration ()
|
|
{
|
|
auto search = chainSearch(SPAM) // Note: 1st filter step picks all s-words
|
|
.search([](string const& str){ return startsWith (str, "s"); });
|
|
|
|
CHECK (materialise (search) =="spam-sausage-spam-spam-spam-spam");
|
|
CHECK ("spam" == *search);
|
|
|
|
search.addStep([](auto& filter)
|
|
{ // Note: pick the current value at the point
|
|
string currVal = *filter; // where the 2nd filter step is (re)applied
|
|
filter.setNewFilter ([=](string const& val) // ...and bake this value into the lambda closure
|
|
{
|
|
return val != currVal;
|
|
});
|
|
});
|
|
|
|
CHECK ("sausage" == *search);
|
|
CHECK (materialise (search)
|
|
== "sausage-bacon-tomato-and-" // everything in the rest, which is not "spam"
|
|
"spam-spam-bacon-spam-tomato-and-spam-" // everything starting at "sausage" which is not "sausage"
|
|
"bacon-tomato-and-" // any non-spam behind the 2nd spam
|
|
"bacon-tomato-and-" // any non-spam behind the 3rd spam
|
|
"tomato-and" // any non-spam behind the 4th spam
|
|
""); // and any non-spam behind the final spam
|
|
}
|
|
|
|
|
|
|
|
/** @test verify a complex search with backtracking.
|
|
* This becomes relevant when a given search condition can be "too greedy" for the
|
|
* complete chain to succeed. Most notably this is the case when the search is fundamentally
|
|
* reconfigured in some steps, e.g. by switching the search orientation. To demonstrate this,
|
|
* we use a "gear switching" iterator, which allows us to reverse the direction and to search
|
|
* backwards from the current position. We configure the second condition in the chain such
|
|
* that it can not succeed when starting from the first match on the first condition
|
|
*/
|
|
void
|
|
backtracking ()
|
|
{
|
|
using Cursor = IterCursor<decltype(SPAM.begin())>;
|
|
|
|
auto search = chainSearch(Cursor{SPAM.begin(), SPAM.end()})
|
|
.search("spam")
|
|
.addStep([](auto& filter)
|
|
{
|
|
filter.switchBackwards(); // switch search direction without moving the cursor
|
|
filter.flipFilter(); // flip from match on "spam" to match on non-spam
|
|
})
|
|
.addStep([](auto& filter)
|
|
{ // filter is still configured to search non-spam backwards
|
|
++filter; // just "advance" this filter by one step (backward)
|
|
});
|
|
|
|
CHECK (materialise (search) // Layer-0: 1-3 spam fail altogether, too greedy. Try 4rd spam....
|
|
// Layer-1: turn back, toggle to non-spam, find bacon
|
|
== "sausage-" // Layer-2: non-spam and one step further backwards yields sausage
|
|
//
|
|
// BACKTRACK to Layer-0: pick 5th (and last) spam...
|
|
// Layer-1: turn back, toggle to non-spam, find "and"
|
|
"tomato-bacon-sausage-" // Layer-2: non-spam and one step back yields tomato, next bacon, next sausage.
|
|
// BACKTRACK to Layer-1: take previous one, which is tomato
|
|
"bacon-sausage-" // Layer-2: non-spam and one step further back yields bacon, then next sausage.
|
|
// BACKTRACK to Layer-1: take previous non-spam, which is bacon
|
|
"sausage" // Layer-2: non-spam and one step further back yields sausage.
|
|
""); // BACKTRACK to Layer-1: exhausted, BACKTRACK to Layer-0: exhausted. Done.
|
|
}
|
|
};
|
|
|
|
LAUNCHER (IterChainSearch_test, "unit common");
|
|
|
|
|
|
}}} // namespace lib::iter::test
|