390 lines
11 KiB
C++
390 lines
11 KiB
C++
/*
|
||
IterTools(Test) - building combined and filtering iterators based on the Iterator tools
|
||
|
||
Copyright (C)
|
||
2009, 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.
|
||
|
||
* *****************************************************************/
|
||
|
||
/** @file itertools-test.cpp
|
||
** unit test \ref IterTools_test
|
||
*/
|
||
|
||
|
||
|
||
#include "lib/test/run.hpp"
|
||
#include "lib/test/test-helper.hpp"
|
||
#include "lib/util-foreach.hpp"
|
||
#include "lib/format-cout.hpp"
|
||
#include "lib/util.hpp"
|
||
|
||
#include "lib/itertools.hpp"
|
||
|
||
#include <boost/lexical_cast.hpp>
|
||
#include <vector>
|
||
|
||
|
||
|
||
namespace lib {
|
||
namespace test{
|
||
|
||
using ::Test;
|
||
using boost::lexical_cast;
|
||
using util::for_each;
|
||
using util::isnil;
|
||
using std::vector;
|
||
|
||
using LERR_(ITER_EXHAUST);
|
||
|
||
|
||
|
||
namespace { // Test data
|
||
|
||
struct TestSource
|
||
{
|
||
vector<int> data_;
|
||
|
||
TestSource(uint num)
|
||
{
|
||
while (num)
|
||
data_.push_back(num--);
|
||
}
|
||
|
||
typedef vector<int>::iterator sourceIter;
|
||
typedef RangeIter<sourceIter> iterator;
|
||
|
||
iterator begin() { return iterator(data_.begin(),data_.end()); }
|
||
iterator end() { return iterator(); }
|
||
|
||
};
|
||
|
||
} // (END) Test data
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/***************************************************************************//**
|
||
* @test build combined and filtering iterators with the help of lib::IterTool.
|
||
* Check correct behaviour of the resulting iterators and
|
||
* verify they fulfil the Lumiera Forward Iterator concept
|
||
*
|
||
* @todo implement more iterator tools.... see Ticket #347
|
||
*/
|
||
class IterTools_test : public Test
|
||
{
|
||
|
||
typedef TestSource::iterator Iter;
|
||
|
||
uint NUM_ELMS{0};
|
||
|
||
|
||
virtual void
|
||
run (Arg arg)
|
||
{
|
||
NUM_ELMS = firstVal (arg, 10);
|
||
|
||
TestSource source(NUM_ELMS);
|
||
|
||
pullOut (source.begin());
|
||
verifyComparisons (source.begin());
|
||
|
||
|
||
buildFilterIterator (source.begin());
|
||
Iter ii (source.begin());
|
||
++++++ii;
|
||
buildFilterIterator (ii);
|
||
verify_filterExtension();
|
||
verify_filterRepetitions();
|
||
|
||
buildWrappedSingleElement();
|
||
|
||
buildTransformingIterator (source.begin());
|
||
|
||
verifyPullLast(source.begin());
|
||
}
|
||
|
||
|
||
|
||
template<class IT>
|
||
void
|
||
pullOut (IT const& ii)
|
||
{
|
||
for (IT iter(ii) ; iter; ++iter )
|
||
cout << "::" << *iter;
|
||
cout << endl;
|
||
}
|
||
|
||
|
||
|
||
static bool takeAll (int) { return true; }
|
||
static bool takeOdd (int i) { return 0 != i % 2; }
|
||
static bool takeEve (int i) { return 0 == i % 2; }
|
||
static bool takeTrd (int i) { return 0 == i % 3; }
|
||
|
||
void
|
||
buildFilterIterator (Iter const& ii)
|
||
{
|
||
pullOut (filterIterator (ii, takeAll)); // note: using the convenient builder function
|
||
pullOut (filterIterator (ii, takeEve));
|
||
pullOut (filterIterator (ii, takeOdd));
|
||
|
||
FilterIter<Iter> all (ii, takeAll);
|
||
FilterIter<Iter> odd (ii, takeOdd);
|
||
verifyComparisons (all);
|
||
verifyComparisons (odd);
|
||
|
||
while (++all && ++odd)
|
||
CHECK (all != odd);
|
||
|
||
while (++all) { }
|
||
CHECK (isnil (odd));
|
||
CHECK (all == odd);
|
||
}
|
||
|
||
|
||
/** @test verify the ability to extend a filter condition
|
||
* while in the middle of an ongoing iteration.
|
||
* Typically this means sharpening the filter condition
|
||
* and thus making the filter more restrictive, filtering
|
||
* away more elements of the source stream. But through
|
||
* the ability to add disjunctive and negated clauses,
|
||
* it is also possible to weaken the filter condition
|
||
* @note in case of a weakened filter condition, there is
|
||
* \em no reset of the source iterator, i.e. we don't
|
||
* re-evaluate from start, but just from current head.
|
||
*/
|
||
void
|
||
verify_filterExtension ()
|
||
{
|
||
typedef vector<uint64_t> Src;
|
||
typedef Src::iterator SrcIter;
|
||
typedef RangeIter<SrcIter> SeqIter;
|
||
typedef ExtensibleFilterIter<SeqIter> FilteredSeq;
|
||
|
||
Src src;
|
||
for (uint i=0; i < 3*NUM_ELMS; ++i)
|
||
src.push_back(i);
|
||
|
||
SeqIter completeSequence (src.begin(), src.end());
|
||
FilteredSeq filterIter (completeSequence, takeAll);
|
||
|
||
CHECK (!isnil (filterIter));
|
||
CHECK (0 == *filterIter);
|
||
++filterIter;
|
||
CHECK (1 == *filterIter);
|
||
|
||
filterIter.andFilter(takeEve);
|
||
CHECK (!isnil (filterIter));
|
||
CHECK (2 == *filterIter);
|
||
++filterIter;
|
||
CHECK (4 == *filterIter);
|
||
|
||
// sharpen the condition...
|
||
filterIter.andFilter(takeTrd);
|
||
CHECK (!isnil (filterIter));
|
||
CHECK (6 == *filterIter); // divisible by two and by three
|
||
++filterIter;
|
||
CHECK (12 == *filterIter);
|
||
|
||
verifyComparisons (filterIter);
|
||
pullOut (filterIter);
|
||
|
||
// adding a disjunctive clause actually weakens the filter...
|
||
filterIter = {completeSequence, takeTrd};
|
||
CHECK (!isnil (filterIter));
|
||
CHECK (0 == *filterIter);
|
||
++filterIter;
|
||
CHECK (3 == *filterIter);
|
||
|
||
filterIter.orFilter(takeEve);
|
||
CHECK (3 == *filterIter);
|
||
++filterIter;
|
||
CHECK (4 == *filterIter);
|
||
++filterIter;
|
||
CHECK (6 == *filterIter);
|
||
verifyComparisons (filterIter);
|
||
|
||
// flip filter logic
|
||
filterIter.flipFilter();
|
||
CHECK (7 == *filterIter); // not even and not divisible by three
|
||
++filterIter;
|
||
CHECK (11 == *filterIter);
|
||
++filterIter;
|
||
CHECK (13 == *filterIter);
|
||
|
||
verifyComparisons (filterIter);
|
||
pullOut (filterIter);
|
||
}
|
||
|
||
|
||
/** @test verify the helper to filter duplicate elements
|
||
* emitted by an source iterator. This test creates
|
||
* a sequence of numbers with random repetitions.
|
||
*/
|
||
void
|
||
verify_filterRepetitions ()
|
||
{
|
||
vector<uint> numberz;
|
||
for (uint i=0; i<NUM_ELMS; ++i)
|
||
{
|
||
uint n = 1 + rani (100);
|
||
do numberz.push_back(i);
|
||
while (--n);
|
||
}
|
||
CHECK (NUM_ELMS < numberz.size(), "no repetition in test data??");
|
||
|
||
typedef vector<uint>::iterator SrcIter;
|
||
typedef RangeIter<SrcIter> SeqIter;
|
||
typedef FilterIter<SeqIter> FilteredSeq;
|
||
|
||
SeqIter completeSequence (numberz.begin(), numberz.end());
|
||
FilteredSeq filtered = filterRepetitions (completeSequence);
|
||
|
||
uint num=0;
|
||
for (; num<NUM_ELMS and not isnil(filtered);
|
||
++num,
|
||
++filtered
|
||
)
|
||
CHECK (num == *filtered);
|
||
|
||
CHECK (num == NUM_ELMS and isnil(filtered));
|
||
}
|
||
|
||
|
||
|
||
/** @test wrap an arbitrary single element as pseudo-iterator */
|
||
void
|
||
buildWrappedSingleElement()
|
||
{
|
||
uint i{12};
|
||
|
||
auto i1 = singleValIterator(12);
|
||
auto i2 = singleValIterator( i);
|
||
auto i3 = singleValIterator(&i);
|
||
|
||
CHECK (not isnil(i1));
|
||
CHECK (not isnil(i2));
|
||
CHECK (not isnil(i3));
|
||
CHECK (12 == *i1);
|
||
CHECK (12 == *i2);
|
||
CHECK (12 == **i3);
|
||
|
||
i = 23;
|
||
CHECK (12 == *i1);
|
||
CHECK (23 == *i2);
|
||
CHECK (23 == **i3);
|
||
|
||
++i1;
|
||
++i2;
|
||
++i3;
|
||
CHECK (isnil(i1));
|
||
CHECK (isnil(i2));
|
||
CHECK (isnil(i3));
|
||
VERIFY_ERROR (ITER_EXHAUST, *i1 );
|
||
VERIFY_ERROR (ITER_EXHAUST, *i2 );
|
||
VERIFY_ERROR (ITER_EXHAUST, *i3 );
|
||
|
||
// assignable as any iterator..
|
||
i1 = singleValIterator(13);
|
||
CHECK (13 == *i1);
|
||
|
||
i1 = SingleValIter<int>{};
|
||
CHECK (isnil(i1));
|
||
}
|
||
|
||
|
||
|
||
static ulong addTwo (int i) { return i+2; }
|
||
static int negate (int i) { return -i; }
|
||
static int idFunc (int i) { return i; }
|
||
|
||
void
|
||
buildTransformingIterator (Iter const& ii)
|
||
{
|
||
pullOut (transformIterator(ii, idFunc));
|
||
pullOut (transformIterator(ii, negate));
|
||
pullOut (transformIterator(ii, addTwo)); // note: changing output type to unsigned
|
||
|
||
TransformIter<Iter, int> idi (ii, idFunc);
|
||
TransformIter<Iter, int> neg (ii, negate);
|
||
verifyComparisons (idi);
|
||
verifyComparisons (neg);
|
||
|
||
CHECK (idi);
|
||
CHECK (neg);
|
||
for ( ;idi&&neg;
|
||
++idi,++neg)
|
||
CHECK (idi != neg);
|
||
|
||
CHECK (!idi and !neg);
|
||
CHECK (idi == neg);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
/** @test verify equality handling and NIL detection
|
||
* for the given iterator/wrapper handed in */
|
||
template<class IT>
|
||
void
|
||
verifyComparisons (IT const& ii)
|
||
{
|
||
IT i1(ii);
|
||
IT i2(ii);
|
||
IT iN;
|
||
CHECK ( isnil (iN));
|
||
CHECK (!isnil (i1));
|
||
CHECK (!isnil (i2));
|
||
|
||
CHECK (i1 == i2); CHECK (i2 == i1);
|
||
CHECK (i1 != iN); CHECK (iN != i1);
|
||
CHECK (i2 != iN); CHECK (iN != i2);
|
||
|
||
++i1;
|
||
CHECK (i1 != i2);
|
||
CHECK (i1 != iN);
|
||
|
||
++i2;
|
||
CHECK (i1 == i2);
|
||
CHECK (i1 != iN);
|
||
CHECK (i2 != iN);
|
||
|
||
while (++i1) { }
|
||
CHECK (isnil(i1));
|
||
CHECK (i1 != i2);
|
||
CHECK (i1 == iN);
|
||
|
||
while (++i2) { }
|
||
CHECK (isnil(i2));
|
||
CHECK (i2 == i1);
|
||
CHECK (i2 == iN);
|
||
}
|
||
|
||
|
||
void
|
||
verifyPullLast(Iter const& ii)
|
||
{
|
||
Iter::value_type lastElm = pull_last (ii);
|
||
CHECK (1 == lastElm); // TestSource holds a decreasing sequence of numbers ending with 1
|
||
|
||
Iter emptyIterator;
|
||
CHECK (isnil (emptyIterator));
|
||
|
||
VERIFY_ERROR (ITER_EXHAUST, pull_last(emptyIterator) );
|
||
}
|
||
};
|
||
|
||
LAUNCHER (IterTools_test, "unit common");
|
||
|
||
|
||
}} // namespace lib::test
|
||
|