492 lines
15 KiB
C++
492 lines
15 KiB
C++
/*
|
||
ScopedCollection(Test) - holding and owning a fixed collection of noncopyable objects
|
||
|
||
Copyright (C)
|
||
2012, 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 scoped-collection-test.cpp
|
||
** unit test \ref ScopedCollection_test
|
||
*/
|
||
|
||
|
||
|
||
#include "lib/test/run.hpp"
|
||
#include "lib/test/test-helper.hpp"
|
||
#include "lib/util.hpp"
|
||
|
||
#include "lib/scoped-collection.hpp"
|
||
#include "lib/test/tracking-dummy.hpp"
|
||
|
||
|
||
namespace lib {
|
||
namespace test{
|
||
|
||
namespace error = lumiera::error;
|
||
|
||
|
||
namespace { // our explosive special Dummy
|
||
|
||
LUMIERA_ERROR_DEFINE(SUBVERSIVE, "undercover action");
|
||
|
||
class SubDummy
|
||
: public Dummy
|
||
{
|
||
int trigger_;
|
||
|
||
/** special variant of the dummy API operation:
|
||
* @param i when zero, the trigger value will be revealed
|
||
*/
|
||
virtual long
|
||
calc (int i)
|
||
{
|
||
if (!i)
|
||
return getVal() + trigger_;
|
||
else
|
||
return Dummy::calc(i);
|
||
}
|
||
|
||
public:
|
||
SubDummy (int id, int trigger)
|
||
: Dummy(id)
|
||
, trigger_(trigger)
|
||
{
|
||
if (trigger == getVal())
|
||
throw error::Fatal ("Subversive Bomb", LUMIERA_ERROR_SUBVERSIVE);
|
||
}
|
||
|
||
SubDummy()
|
||
: Dummy()
|
||
, trigger_(-1)
|
||
{ }
|
||
};
|
||
|
||
|
||
inline uint
|
||
sum (uint n)
|
||
{
|
||
return n*(n+1) / 2;
|
||
}
|
||
|
||
}//(End) subversive test data
|
||
|
||
|
||
|
||
|
||
using util::isnil;
|
||
using LERR_(ITER_EXHAUST);
|
||
|
||
typedef ScopedCollection<Dummy, sizeof(SubDummy)> CollD;
|
||
|
||
|
||
/****************************************************************//**
|
||
* @test ScopedCollection manages a fixed set of objects, but these
|
||
* child objects are noncopyable, may be polymorphic, an can
|
||
* be created either all at once or chunk wise. The API is
|
||
* similar to a vector and allows for element access
|
||
* and iteration.
|
||
*/
|
||
class ScopedCollection_test : public Test
|
||
{
|
||
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
seedRand();
|
||
simpleUsage();
|
||
building_RAII_Style();
|
||
building_StackStyle();
|
||
iterating();
|
||
verify_defaultPopulator();
|
||
verify_iteratorPopulator();
|
||
verify_embeddedCollection();
|
||
}
|
||
|
||
|
||
void
|
||
simpleUsage()
|
||
{
|
||
CHECK (0 == Dummy::checksum());
|
||
{
|
||
CollD container(5);
|
||
CHECK (isnil (container));
|
||
CHECK (0 == container.size());
|
||
CHECK (0 == Dummy::checksum());
|
||
|
||
container.populate();
|
||
CHECK (!isnil (container));
|
||
CHECK (5 == container.size());
|
||
CHECK (0 != Dummy::checksum());
|
||
|
||
container.clear();
|
||
CHECK (isnil (container));
|
||
CHECK (0 == container.size());
|
||
CHECK (0 == Dummy::checksum());
|
||
|
||
container.populate();
|
||
CHECK (Dummy::checksum() == container[0].getVal()
|
||
+ container[1].getVal()
|
||
+ container[2].getVal()
|
||
+ container[3].getVal()
|
||
+ container[4].getVal());
|
||
}
|
||
CHECK (0 == Dummy::checksum());
|
||
}
|
||
|
||
|
||
void
|
||
iterating()
|
||
{
|
||
CHECK (0 == Dummy::checksum());
|
||
{
|
||
CollD coll(50);
|
||
for (uint i=0; i<coll.capacity(); ++i)
|
||
coll.emplace<Dummy>(i);
|
||
|
||
int check=0;
|
||
CollD::iterator ii = coll.begin();
|
||
while (ii)
|
||
{
|
||
CHECK (check == ii->getVal());
|
||
CHECK (check == ii->calc(+5) - 5);
|
||
++check;
|
||
++ii;
|
||
}
|
||
|
||
|
||
// Test the const iterator
|
||
CollD const& const_coll (coll);
|
||
check = 0;
|
||
CollD::const_iterator cii = const_coll.begin();
|
||
while (cii)
|
||
{
|
||
CHECK (check == cii->getVal());
|
||
++check;
|
||
++cii;
|
||
}
|
||
|
||
|
||
// Test c++11 foreach iteration
|
||
check = 0;
|
||
for (auto& entry : coll)
|
||
{
|
||
CHECK (check == entry.getVal());
|
||
++check;
|
||
}
|
||
check = 0;
|
||
for (auto const& entry : const_coll)
|
||
{
|
||
CHECK (check == entry.getVal());
|
||
++check;
|
||
}
|
||
|
||
|
||
// Verify correct behaviour of iteration end
|
||
CHECK (! (coll.end()));
|
||
CHECK (isnil (coll.end()));
|
||
|
||
VERIFY_ERROR (ITER_EXHAUST, *coll.end() );
|
||
VERIFY_ERROR (ITER_EXHAUST, ++coll.end() );
|
||
|
||
CHECK (ii == coll.end());
|
||
CHECK (cii == coll.end());
|
||
VERIFY_ERROR (ITER_EXHAUST, ++ii );
|
||
VERIFY_ERROR (ITER_EXHAUST, ++cii );
|
||
|
||
}
|
||
CHECK (0 == Dummy::checksum());
|
||
}
|
||
|
||
|
||
/** @test using the ScopedCollection to hold a variable
|
||
* and possibly increasing number of elements, within the
|
||
* fixed limits of the maximum capacity defined by the
|
||
* ctor parameter. Any new elements will be created
|
||
* behind the already existing objects. In case
|
||
* of failure while creating an element, only
|
||
* this element gets destroyed, the rest of
|
||
* the container remains intact.
|
||
*/
|
||
void
|
||
building_StackStyle()
|
||
{
|
||
CHECK (0 == Dummy::checksum());
|
||
{
|
||
|
||
int rr = rani(100);
|
||
|
||
CollD coll(3);
|
||
CHECK (0 == coll.size());
|
||
CHECK (0 == Dummy::checksum());
|
||
|
||
Dummy& d0 = coll.emplaceElement();
|
||
CHECK (1 == coll.size());
|
||
|
||
Dummy& d1 = coll.emplace<Dummy> (rr);
|
||
CHECK (2 == coll.size());
|
||
|
||
int sum = Dummy::checksum();
|
||
|
||
// trigger the bomb
|
||
VERIFY_ERROR (SUBVERSIVE, coll.emplace<SubDummy>(rr,rr) );
|
||
|
||
CHECK ( 2 == coll.size()); // the other objects survived
|
||
CHECK (sum == Dummy::checksum());
|
||
|
||
Dummy& d2 = coll.emplace<SubDummy> (rr, rr+1);
|
||
CHECK (3 == coll.size());
|
||
|
||
CHECK (sum + rr == Dummy::checksum());
|
||
|
||
VERIFY_ERROR (CAPACITY, coll.emplaceElement());
|
||
VERIFY_ERROR (CAPACITY, coll.emplaceElement());
|
||
VERIFY_ERROR (CAPACITY, coll.emplaceElement());
|
||
|
||
CHECK (3 == coll.size());
|
||
CHECK (sum + rr == Dummy::checksum());
|
||
|
||
|
||
CHECK (d0.calc(11) == coll[0].getVal() + 11 );
|
||
CHECK (d1.calc(22) == rr + 22);
|
||
CHECK (d2.calc(33) == rr + 33);
|
||
CHECK (d2.calc(0) == rr + (rr+1) ); // SubDummy's special implementation of the acc()-function
|
||
// returns the trigger value, when the argument is zero
|
||
|
||
coll.clear();
|
||
coll.emplace<SubDummy> (11,22);
|
||
|
||
CHECK ( 1 == coll.size());
|
||
CHECK (11 == Dummy::checksum());
|
||
|
||
// NOTE DANGEROUS:
|
||
// The previously obtained references just point into the object storage.
|
||
// Thus we're now accessing a different object, even a different type!
|
||
CHECK (d0.calc(0) == 11 + 22);
|
||
|
||
// The others even point into obsoleted storage holding zombie objects
|
||
CHECK (d1.getVal() == Dummy::DEAD);
|
||
|
||
}
|
||
CHECK (0 == Dummy::checksum());
|
||
}
|
||
|
||
|
||
/** @test using the ScopedCollection according to the RAII pattern.
|
||
* For this usage style, the collection is filled right away, during
|
||
* construction. If anything goes wrong, the whole collection is
|
||
* cleared and invalidated. Consequently there is no tangible "lifecycle"
|
||
* at the usage site. Either the collection is fully usable, or not at all.
|
||
* This requires the client to provide a functor (callback) to define
|
||
* the actual objects to be created within the ScopedCollection. These
|
||
* may as well be subclasses of the base type I, provided the general
|
||
* element storage size #siz was chosen sufficiently large to hold
|
||
* those subclass instances.
|
||
*
|
||
* This test demonstrates the most elaborate usage pattern, where
|
||
* the client provides a full blown functor object #Populator,
|
||
* which even has embedded state. Generally speaking, anything
|
||
* exposing a suitable function call operator is acceptable.
|
||
*/
|
||
void
|
||
building_RAII_Style()
|
||
{
|
||
CHECK (0 == Dummy::checksum());
|
||
{
|
||
int rr = rani(100);
|
||
int trigger = 100 + 5 + 1; // prevents the bomb from exploding (since rr < 100)
|
||
|
||
CollD coll (6, Populator(rr, trigger));
|
||
|
||
CHECK (!isnil (coll));
|
||
CHECK (6 == coll.size());
|
||
CHECK (0 != Dummy::checksum());
|
||
|
||
CHECK (coll[0].calc(0) == 0 + rr);
|
||
CHECK (coll[1].calc(0) == 1 + rr + trigger);
|
||
CHECK (coll[2].calc(0) == 2 + rr);
|
||
CHECK (coll[3].calc(0) == 3 + rr + trigger);
|
||
CHECK (coll[4].calc(0) == 4 + rr);
|
||
CHECK (coll[5].calc(0) == 5 + rr + trigger);
|
||
// what does this check prove?
|
||
// - the container was indeed populated with DubDummy objects
|
||
// since the overridden version of Dummy::acc() did run and
|
||
// reveal the trigger value
|
||
// - the population was indeed done with the anonymous Populator
|
||
// instance fed to the ctor, since this object was "marked" with
|
||
// the random value rr, and adds this mark to the built values.
|
||
|
||
coll.clear();
|
||
CHECK (0 == Dummy::checksum());
|
||
|
||
// Verify Error handling while in creation:
|
||
// SubDummy explodes on equal ctor parameters
|
||
// which here happens for i==7
|
||
VERIFY_ERROR (SUBVERSIVE, CollD(10, Populator(0, 7)) );
|
||
|
||
// any already created object was properly destroyed
|
||
CHECK (0 == Dummy::checksum());
|
||
|
||
}
|
||
CHECK (0 == Dummy::checksum());
|
||
}
|
||
|
||
/** Functor to populate the Collection */
|
||
class Populator
|
||
{
|
||
uint i_;
|
||
int off_;
|
||
int trigg_;
|
||
|
||
public:
|
||
Populator (int baseOffset, int triggerCode)
|
||
: i_(0)
|
||
, off_(baseOffset)
|
||
, trigg_(triggerCode)
|
||
{ }
|
||
|
||
void
|
||
operator() (CollD::ElementHolder& storage)
|
||
{
|
||
switch (i_ % 2)
|
||
{
|
||
case 0:
|
||
storage.create<Dummy> (i_+off_);
|
||
break;
|
||
|
||
case 1:
|
||
storage.create<SubDummy> (i_+off_, trigg_);
|
||
break;
|
||
}
|
||
++i_;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
/** @test for using ScopedCollection in RAII style,
|
||
* several pre-defined "populators" are provided.
|
||
* The most obvious one being just to fill the
|
||
* collection with default constructed objects.
|
||
*/
|
||
void
|
||
verify_defaultPopulator()
|
||
{
|
||
CHECK (0 == Dummy::checksum());
|
||
|
||
CollD coll (25, CollD::FillAll() );
|
||
|
||
CHECK (!isnil (coll));
|
||
CHECK (25 == coll.size());
|
||
CHECK (0 != Dummy::checksum());
|
||
|
||
for (CollD::iterator ii = coll.begin(); ii; ++ii)
|
||
{
|
||
CHECK ( INSTANCEOF (Dummy, & (*ii)));
|
||
CHECK (!INSTANCEOF (SubDummy, & (*ii)));
|
||
}
|
||
}
|
||
|
||
|
||
void
|
||
verify_subclassPopulator()
|
||
{
|
||
CHECK (0 == Dummy::checksum());
|
||
|
||
CollD coll (25, CollD::FillWith<SubDummy>() );
|
||
|
||
CHECK (!isnil (coll));
|
||
CHECK (25 == coll.size());
|
||
CHECK (0 != Dummy::checksum());
|
||
|
||
for (CollD::iterator ii = coll.begin(); ii; ++ii)
|
||
CHECK (INSTANCEOF (SubDummy, & (*ii)));
|
||
}
|
||
|
||
|
||
void
|
||
verify_iteratorPopulator()
|
||
{
|
||
typedef ScopedCollection<uint> CollI;
|
||
|
||
CollI source (25);
|
||
for (uint i=0; i < source.capacity(); ++i)
|
||
source.emplace<uint>(i); // holding the numbers 0..24
|
||
|
||
CollI coll (20, CollI::pull(source.begin()));
|
||
// this immediately pulls in the first 20 elements
|
||
CHECK (!isnil (coll));
|
||
CHECK (20 == coll.size());
|
||
CHECK (25 == source.size());
|
||
|
||
for (uint i=0; i < coll.size(); ++i)
|
||
{
|
||
CHECK (coll[i] == i );
|
||
CHECK (coll[i] == source[i]);
|
||
}
|
||
|
||
// note: the iterator is assumed to deliver a sufficient amount of elements
|
||
VERIFY_ERROR (ITER_EXHAUST, CollI (50, CollI::pull (source.begin())));
|
||
}
|
||
|
||
|
||
/** @test simulate the typical situation of a manager
|
||
* owning some embedded components. Here, our ManagerDemo
|
||
* instance owns a collection of numbers 50..1. They are
|
||
* created right while initialising the manager, and this
|
||
* initialisation is done by invoking a member function
|
||
* of the manager
|
||
*/
|
||
void
|
||
verify_embeddedCollection()
|
||
{
|
||
ManagerDemo object_with_embedded_Collection(50);
|
||
CHECK (sum(50) == object_with_embedded_Collection.useMyNumbers());
|
||
}
|
||
|
||
class ManagerDemo
|
||
{
|
||
typedef ScopedCollection<uint> CollI;
|
||
|
||
uint memberVar_;
|
||
const CollI my_own_Numbers_;
|
||
|
||
void
|
||
buildNumbers (CollI::ElementHolder& storage)
|
||
{
|
||
storage.create<uint>(memberVar_);
|
||
--memberVar_;
|
||
}
|
||
|
||
public:
|
||
ManagerDemo(uint cnt)
|
||
: memberVar_(cnt)
|
||
, my_own_Numbers_(cnt, &ManagerDemo::buildNumbers, this)
|
||
{
|
||
CHECK (0 == memberVar_);
|
||
CHECK (cnt == my_own_Numbers_.size());
|
||
}
|
||
|
||
uint
|
||
useMyNumbers()
|
||
{
|
||
uint sum(0);
|
||
for (CollI::const_iterator ii = my_own_Numbers_.begin(); ii; ++ii)
|
||
sum += *ii;
|
||
return sum;
|
||
}
|
||
};
|
||
};
|
||
|
||
|
||
|
||
LAUNCHER (ScopedCollection_test, "unit common");
|
||
|
||
|
||
}} // namespace lib::test
|
||
|