Ichthyostega
555af315b3
- remove obsolete configuration settings - walk through all settings according to the documentation https://www.doxygen.nl/manual/config.html - now try to use the new feature to rely on Clang for C++ parsing - walk through the doxygen-warnings.txt and fix some obvious misspellings and structural problems in the documentation comments. With Debian-Trixie, we are now using Doxygen 1.9.8 — which produces massively better results in various fine points. However, there are still problems with automatic cross links, especially from implementation to the corresponding test classes.
287 lines
7.6 KiB
C++
287 lines
7.6 KiB
C++
/*
|
||
IndexIter(Test) - verify index access packaged as iterator handle
|
||
|
||
Copyright (C)
|
||
2024, 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 index-iter-test.cpp
|
||
** unit test \ref IndexIter_test
|
||
*/
|
||
|
||
|
||
|
||
#include "lib/test/run.hpp"
|
||
#include "lib/index-iter.hpp"
|
||
#include "lib/test/test-helper.hpp"
|
||
#include "lib/iter-explorer.hpp"
|
||
#include "lib/format-util.hpp"
|
||
#include "lib/util.hpp"
|
||
|
||
#include <vector>
|
||
#include <memory>
|
||
|
||
|
||
|
||
namespace lib {
|
||
namespace test{
|
||
|
||
using ::Test;
|
||
using util::join;
|
||
using util::isnil;
|
||
using std::vector;
|
||
using std::shared_ptr;
|
||
using std::make_shared;
|
||
|
||
using LERR_(ITER_EXHAUST);
|
||
using LERR_(INDEX_BOUNDS);
|
||
|
||
|
||
namespace { // test fixture
|
||
|
||
const uint NUM_ELMS = 10;
|
||
|
||
using Numz = vector<uint>;
|
||
using Iter = IndexIter<Numz>;
|
||
using CIter = IndexIter<const Numz>;
|
||
using SMIter = IndexIter<Numz, shared_ptr<Numz>>;
|
||
|
||
inline Numz
|
||
makeNumz()
|
||
{
|
||
Numz numz;
|
||
for (uint i=0; i<NUM_ELMS; ++i)
|
||
numz.push_back(i);
|
||
return numz;
|
||
}
|
||
|
||
} // (END)fixture
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/************************************************************************//**
|
||
* @test verify adapter to iterate and navigate over array-like content,
|
||
* that can be accessed through subscript operator and `size()` function.
|
||
*
|
||
* @see iter-cursor.hpp
|
||
* @see iter-adapter.hpp
|
||
* @see [usage example](\ref event-log.hpp)
|
||
*/
|
||
class IndexIter_test : public Test
|
||
{
|
||
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
simpleIteration();
|
||
verify_randomAccess();
|
||
iterTypeVariations();
|
||
}
|
||
|
||
|
||
/** @test just iterate in various ways. */
|
||
void
|
||
simpleIteration ()
|
||
{
|
||
Numz numz{makeNumz()};
|
||
Iter i1{numz};
|
||
|
||
CHECK (not isnil(i1));
|
||
CHECK (0 == *i1);
|
||
++++++i1;
|
||
CHECK (3 == *i1);
|
||
for (uint i=*i1 ; i1; ++i1, ++i)
|
||
CHECK (i == *i1);
|
||
|
||
CHECK (isnil(i1));
|
||
|
||
auto sum = explore(Iter{numz}).resultSum();
|
||
uint n = numz.size() - 1;
|
||
CHECK (sum == n*(n+1)/2);
|
||
|
||
for (auto & i : Iter{numz})
|
||
++i; // note: manipulate the contents...
|
||
CHECK (join(numz,"◇") == "1◇2◇3◇4◇5◇6◇7◇8◇9◇10"_expect);
|
||
|
||
verifyComparisons (Iter{numz});
|
||
}
|
||
|
||
|
||
|
||
/** @test verify the ability of IndexIter to access and manipulate
|
||
* the current index position, which can be done any time, while in
|
||
* the middle of iteration, and even after iteration end. That means,
|
||
* even an exhausted iterator can be „reanimated“. This manipulation
|
||
* is not allowed on a default constructed IndexIter, though.
|
||
*/
|
||
void
|
||
verify_randomAccess ()
|
||
{
|
||
Numz numz{makeNumz()};
|
||
Iter iter{numz};
|
||
|
||
CHECK (0 == *iter);
|
||
++++++++iter;
|
||
CHECK (4 == *iter);
|
||
CHECK (not isnil(iter));
|
||
CHECK (join(iter) == "4, 5, 6, 7, 8, 9"_expect);
|
||
verifyComparisons (iter);
|
||
|
||
CHECK (4 == *iter);
|
||
CHECK (4 == iter.getIDX());
|
||
iter.setIDX(7);
|
||
CHECK (7 == iter.getIDX());
|
||
CHECK (not isnil(iter));
|
||
CHECK (7 == *iter);
|
||
++iter;
|
||
CHECK (8 == *iter);
|
||
iter.setIDX(6);
|
||
CHECK (join(iter) == "6, 7, 8, 9"_expect);
|
||
verifyComparisons (iter);
|
||
|
||
++++++++iter;
|
||
CHECK (isnil(iter));
|
||
VERIFY_ERROR (ITER_EXHAUST, *iter);
|
||
VERIFY_ERROR (ITER_EXHAUST, ++iter);
|
||
VERIFY_ERROR (ITER_EXHAUST, iter.getIDX());
|
||
|
||
iter.setIDX(9);
|
||
CHECK (not isnil(iter));
|
||
CHECK (9 == *iter);
|
||
|
||
VERIFY_ERROR (INDEX_BOUNDS, iter.setIDX(10));
|
||
CHECK (9 == iter.getIDX());
|
||
VERIFY_ERROR (INDEX_BOUNDS, iter.setIDX(-1));
|
||
CHECK (9 == iter.getIDX());
|
||
|
||
Iter empty;
|
||
CHECK (isnil (empty));
|
||
VERIFY_ERROR (INDEX_BOUNDS, empty.setIDX(0));
|
||
VERIFY_ERROR (ITER_EXHAUST, empty.getIDX());
|
||
}
|
||
|
||
|
||
|
||
/** @test verify possible variations of this iterator template,
|
||
* using a const container or maintaining shared ownership.
|
||
*/
|
||
void
|
||
iterTypeVariations ()
|
||
{
|
||
auto smartNumz = make_shared<Numz> (makeNumz());
|
||
Numz & numz{*smartNumz};
|
||
Numz const& const_numz{numz};
|
||
|
||
uint i = 0;
|
||
for (Iter iter{numz};
|
||
iter; ++iter, ++i
|
||
)
|
||
{
|
||
CHECK (iter);
|
||
CHECK (iter != Iter());
|
||
CHECK (*iter == i);
|
||
--(*iter);
|
||
CHECK (*iter == i-1);
|
||
}
|
||
|
||
i = 0;
|
||
for (CIter iter{const_numz};
|
||
iter; ++iter, ++i
|
||
)
|
||
{
|
||
CHECK (iter);
|
||
CHECK (iter != CIter());
|
||
CHECK (*iter == i-1);
|
||
// Note: the preceding loop has indeed modified the contents
|
||
// ++(*iter); // but this doesn't compile, because the CIter yields a _const_
|
||
}
|
||
|
||
verifyComparisons (CIter{numz});
|
||
|
||
CHECK (1 == smartNumz.use_count());
|
||
{
|
||
SMIter smIter{smartNumz};
|
||
CIter cIter{*smartNumz};
|
||
CHECK (*cIter == uint(-1));
|
||
for (i=0; smIter; ++smIter, ++i)
|
||
{
|
||
CHECK (smIter);
|
||
CHECK (smIter != SMIter());
|
||
CHECK (*smIter == i-1);
|
||
++(*smIter);
|
||
CHECK (*smIter == i);
|
||
}
|
||
CHECK (isnil (smIter));
|
||
CHECK (smIter == SMIter());
|
||
cIter.setIDX(5);
|
||
smIter.setIDX(5);
|
||
CHECK (*smIter == *cIter);
|
||
|
||
verifyComparisons (smIter);
|
||
|
||
CHECK (5 == *cIter); // shared data modified
|
||
CHECK (2 == smartNumz.use_count());
|
||
}
|
||
CHECK (1 == smartNumz.use_count());
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
/** @test verify equality handling and NIL detection
|
||
* for the given iterator/wrapper handed in.
|
||
* @note the argument is not altered; rather we create
|
||
* several copies, to iterate and compare those
|
||
*/
|
||
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);
|
||
}
|
||
};
|
||
|
||
LAUNCHER (IndexIter_test, "unit common");
|
||
|
||
|
||
}} // namespace lib::test
|
||
|