Ichthyostega
bf6532a69d
Future C++ versions will no longer generate default copy operations once any single one was defined explicitly. So the goal is to kind-of ''enforce the rule of five'' (if you define one, define them all). However, sometimes one of these special operators must be defined for a different reason, e.g. because it is defined as protected, yet should not be exposed on the public API. In such cases, any other copy operation which still is valid in the default form must be declared explicitly ''as defaulted'' Overall this seems to be quite an improvement -- and it highlights (again) some known instances of questionable design, which are mostly obsoleted and require clean-up anyway, or (as in the case of the Placements) indicate »placeholder code« where the actual solution still needs to be worked out
362 lines
11 KiB
C++
362 lines
11 KiB
C++
/*
|
||
CommandArgument(Test) - checking storage of specifically typed command arguments
|
||
|
||
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 command-argument-test.cpp
|
||
** unit test \ref CommandArgument_test
|
||
*/
|
||
|
||
|
||
#include "lib/test/run.hpp"
|
||
#include "lib/test/test-helper.hpp"
|
||
#include "steam/control/command-storage-holder.hpp"
|
||
#include "lib/scoped-ptrvect.hpp"
|
||
#include "lib/format-string.hpp"
|
||
#include "lib/format-cout.hpp"
|
||
#include "lib/util-foreach.hpp"
|
||
#include "lib/util.hpp"
|
||
|
||
#include <functional>
|
||
#include <sstream>
|
||
#include <cstdlib>
|
||
#include <string>
|
||
#include <tuple>
|
||
|
||
using util::_Fmt;
|
||
using util::isnil;
|
||
using util::for_each;
|
||
using lib::time::Time;
|
||
using lib::time::TimeVar;
|
||
using lib::time::TimeValue;
|
||
using std::string;
|
||
using std::ostringstream;
|
||
using std::make_tuple;
|
||
using std::rand;
|
||
|
||
|
||
namespace steam {
|
||
namespace control {
|
||
namespace test {
|
||
|
||
using lib::test::showSizeof;
|
||
using lib::test::randTime;
|
||
using namespace lib::meta;
|
||
using LERR_(MISSING_MEMENTO);
|
||
|
||
|
||
|
||
namespace { // test helpers
|
||
|
||
ostringstream protocol; ///< used to verify the test function calls
|
||
|
||
|
||
/**
|
||
* watching the instance creation
|
||
* of some parameter values
|
||
*/
|
||
template<typename TY>
|
||
struct Tracker
|
||
{
|
||
TY element_;
|
||
static int instanceCnt;
|
||
|
||
Tracker (TY init = TY()) : element_(init) { ++instanceCnt; }
|
||
Tracker (Tracker const& otr) : element_(otr.element_) { ++instanceCnt; }
|
||
~Tracker() { --instanceCnt; }
|
||
|
||
Tracker& operator= (Tracker const&) = default;
|
||
|
||
TY&
|
||
operator* ()
|
||
{
|
||
return element_;
|
||
}
|
||
|
||
operator string() const { return element_; }
|
||
|
||
|
||
friend bool
|
||
operator== (Tracker const& tra1, Tracker const& tra2)
|
||
{
|
||
return tra1.element_ == tra2.element_;
|
||
}
|
||
};
|
||
|
||
template<typename TY>
|
||
int Tracker<TY>::instanceCnt (0);
|
||
|
||
/** prepare a (singleton) _empty value_ for the memento.
|
||
* @remarks This is done prior to observing the Tracker instanceCnt,
|
||
* because this empty value obviously remains allocated forever.
|
||
* The memento is stored within a [special holder](\ref lib::ReplaceableItem)
|
||
* to allow capturing memento state even from immutable values, which only can
|
||
* be copy constructed. This mechanism uses lib::NullValue to retrieve an
|
||
* empty placeholder value when the memento has not yet been captured.
|
||
*/
|
||
void
|
||
prepareEmptyMemento()
|
||
{
|
||
lib::NullValue<Tracker<string>>::get();
|
||
}
|
||
|
||
/** Dummy custom memento datatype
|
||
* @note memento needs to be equality comparable
|
||
*/
|
||
struct Sint5
|
||
{
|
||
int i[5];
|
||
|
||
friend bool
|
||
operator== (Sint5 const& i1, Sint5 const& i2)
|
||
{
|
||
return i1.i == i2.i;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
/* === functions to implement test-"operation" & UNDO === */
|
||
|
||
void
|
||
doIt (Tracker<TimeVar> time, Tracker<string> str, int rand)
|
||
{
|
||
static _Fmt fmt ("doIt( Time=%s \"%s\" rand=%2d )");
|
||
cout << "invoke operation..." << endl;
|
||
protocol << fmt % *time % *str % rand;
|
||
}
|
||
|
||
Tracker<string>
|
||
captureState (Tracker<TimeVar>, Tracker<string> xstr, int)
|
||
{
|
||
cout << "capture state..." << endl;
|
||
return protocol.str() + *xstr;
|
||
}
|
||
|
||
void
|
||
undoIt (Tracker<TimeVar> time, Tracker<string>, int, Tracker<string> memento)
|
||
{
|
||
cout << "undo... memento=" << memento << endl;
|
||
protocol << "undoIt(time="<<time<<")----memento-:"<< *memento;
|
||
}
|
||
|
||
|
||
/// another dummy-UNDO function
|
||
void dummyU (int,int,int) { }
|
||
int dummyC (int u,int o) { return u + rani(o-u+1); }
|
||
|
||
|
||
|
||
void
|
||
showIt (CmdClosure& clo)
|
||
{
|
||
cout << clo << endl;
|
||
}
|
||
|
||
void
|
||
checkSerialisation (CmdClosure& clo)
|
||
{
|
||
TODO ("implement serialisation/de-serialisation-Check");
|
||
cout << "would be serialised....." << clo << endl;
|
||
|
||
// serialise, then de-serialise into a new instance and compare both
|
||
}
|
||
|
||
|
||
int
|
||
twoRandomDigits()
|
||
{
|
||
return 10 + rani(90);
|
||
}
|
||
|
||
|
||
} // test-helper implementation
|
||
|
||
|
||
|
||
|
||
|
||
|
||
typedef lib::ScopedPtrVect<CmdClosure> ArgTuples;
|
||
|
||
/***********************************************************************//**
|
||
* @test Check storage handling of the command parameters and state memento.
|
||
*
|
||
* @see control::CommandStorageHolder
|
||
* @see command-basic-test.hpp
|
||
*/
|
||
class CommandArgument_test : public Test
|
||
{
|
||
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
seedRand();
|
||
ArgTuples testTuples;
|
||
prepareEmptyMemento();
|
||
Tracker<TimeVar>::instanceCnt = 0;
|
||
Tracker<string>::instanceCnt = 0;
|
||
|
||
createTuples (testTuples);
|
||
serialiseArgTuples (testTuples);
|
||
testTuples.clear();
|
||
|
||
simulateCmdLifecycle();
|
||
|
||
// verify all dtors properly called...
|
||
CHECK (0 == Tracker<TimeVar>::instanceCnt);
|
||
CHECK (0 == Tracker<string>::instanceCnt);
|
||
}
|
||
|
||
|
||
typedef Tracker<TimeVar> TTime;
|
||
typedef Tracker<string> Tstr;
|
||
|
||
|
||
|
||
|
||
/** @test create various argument tuples and re-access their contents */
|
||
void
|
||
createTuples (ArgTuples& tup)
|
||
{
|
||
typedef StorageHolder<void(), bool> A1;
|
||
typedef StorageHolder<void(int), void*> A2;
|
||
typedef StorageHolder<void(int,TimeVar), int> A3;
|
||
typedef StorageHolder<void(int,TimeVar), Sint5> A4;
|
||
|
||
typedef StorageHolder<void(TTime,Tstr,int), Tstr> A5;
|
||
|
||
|
||
A1* arg1 = new A1(); tup.manage (arg1);
|
||
A2* arg2 = new A2(); tup.manage (arg2);
|
||
A3* arg3 = new A3(); tup.manage (arg3);
|
||
A4* arg4 = new A4(); tup.manage (arg4);
|
||
A5* arg5 = new A5(); tup.manage (arg5);
|
||
|
||
CHECK (isnil (*arg1));
|
||
CHECK (isnil (*arg2));
|
||
CHECK (isnil (*arg3));
|
||
CHECK (isnil (*arg4));
|
||
CHECK (isnil (*arg5));
|
||
|
||
for_each (tup, showIt);
|
||
|
||
arg1->storeTuple (std::tuple<>());
|
||
arg2->storeTuple (make_tuple (rani(10)));
|
||
arg3->storeTuple (make_tuple (rani(10), TimeVar(randTime())));
|
||
arg4->storeTuple (make_tuple (rani(10), TimeVar(randTime())));
|
||
|
||
arg5->storeTuple (make_tuple (TTime (randTime()), Tstr("glorious"), twoRandomDigits() ));
|
||
|
||
CHECK (!arg5->canUndo());
|
||
|
||
arg5->tie(undoIt, captureState)
|
||
.tieCaptureFunc() // bind capturing function to memento storage,
|
||
(TTime(), Tstr("destruction"), 11); // then invoke the bound capturing mechanism
|
||
|
||
CHECK (arg5->canUndo());
|
||
CHECK (*arg5->memento() == "destruction");
|
||
|
||
VERIFY_ERROR(MISSING_MEMENTO, arg4->memento().i[3] = 513 );
|
||
|
||
for_each (tup, showIt);
|
||
}
|
||
|
||
|
||
|
||
/** @test serialise and de-serialise each tuple and check validity
|
||
* @todo unimplemented, waiting on Serialiser
|
||
*/
|
||
void
|
||
serialiseArgTuples (ArgTuples& tup)
|
||
{
|
||
for_each (tup, checkSerialisation);
|
||
}
|
||
|
||
|
||
|
||
/** @test simulate a complete command lifecycle with regards to the
|
||
* storage handling of the command parameters and state memento.
|
||
*/
|
||
void
|
||
simulateCmdLifecycle()
|
||
{
|
||
typedef void SIG_do(Tracker<TimeVar>, Tracker<string>, int);
|
||
using Args = StorageHolder<SIG_do, Tracker<string>>;
|
||
using MemHolder = MementoTie<SIG_do, Tracker<string>>;
|
||
|
||
Args args;
|
||
CHECK (isnil (args));
|
||
cout << showSizeof(args) << endl;
|
||
|
||
// store a set of parameter values, later to be used on invocation
|
||
args.storeTuple (
|
||
make_tuple (TTime(randTime()), Tstr("Lumiera rocks"), twoRandomDigits() ));
|
||
CHECK (!isnil (args));
|
||
cout << args << endl;
|
||
|
||
CHECK (!args.canUndo());
|
||
VERIFY_ERROR(MISSING_MEMENTO, args.memento() );
|
||
|
||
MemHolder& memHolder = args.tie(undoIt,captureState);
|
||
CHECK (!memHolder); // no stored memento....
|
||
CHECK (!args.canUndo());
|
||
|
||
function<SIG_do> doItFun = doIt;
|
||
function<SIG_do> undoFun = memHolder.tieUndoFunc();
|
||
function<SIG_do> captFun = memHolder.tieCaptureFunc();
|
||
|
||
typedef function<void()> OpFun;
|
||
|
||
// now close all the functions with the stored parameter values...
|
||
OpFun bound_doItFun = std::bind (&CmdClosure::invoke, args, CmdFunctor(doItFun));
|
||
OpFun bound_undoFun = std::bind (&CmdClosure::invoke, args, CmdFunctor(undoFun));
|
||
OpFun bound_captFun = std::bind (&CmdClosure::invoke, args, CmdFunctor(captFun));
|
||
|
||
protocol.seekp(0);
|
||
protocol << "START...";
|
||
|
||
bound_captFun();
|
||
cout << "captured state: " << args.memento() << endl;
|
||
CHECK (memHolder);
|
||
CHECK (!isnil (*args.memento()));
|
||
CHECK (args.canUndo());
|
||
cout << args << endl;
|
||
|
||
bound_doItFun();
|
||
cout << protocol.str() << endl;
|
||
bound_undoFun();
|
||
cout << protocol.str() << endl;
|
||
|
||
// Commands can serve as prototype to be copied....
|
||
Args argsCopy (args);
|
||
bound_captFun();
|
||
protocol.seekp(0);
|
||
protocol << "RESET...";
|
||
|
||
args.storeTuple (
|
||
make_tuple (TTime(TimeValue(123456)), Tstr("unbelievable"), twoRandomDigits() ));
|
||
cout << "modified: " << args << endl;
|
||
cout << "copied : " << argsCopy << endl; // holds still the old params & memento
|
||
|
||
bound_undoFun();
|
||
cout << protocol.str() << endl;
|
||
}
|
||
|
||
};
|
||
|
||
|
||
|
||
/** Register this test class... */
|
||
LAUNCHER (CommandArgument_test, "unit controller");
|
||
|
||
|
||
}}} // namespace steam::control::test
|