Ichthyostega
acc77654d1
after all the relevant library components do support both kinds of type sequences transparently, any usages in core code can now be switched over to the new, variadic type sequences.
167 lines
5.1 KiB
C++
167 lines
5.1 KiB
C++
/*
|
||
CommandCloneBuilder(Test) - verify building an implementation clone
|
||
|
||
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-clone-builder-test.cpp
|
||
** unit test \ref CommandCloneBuilder_test
|
||
*/
|
||
|
||
|
||
#include "lib/test/run.hpp"
|
||
#include "steam/control/command-impl.hpp"
|
||
#include "steam/control/command-registry.hpp"
|
||
#include "steam/control/argument-erasure.hpp"
|
||
#include "steam/control/handling-pattern.hpp"
|
||
#include "lib/meta/tuple-helper.hpp"
|
||
#include "lib/symbol.hpp"
|
||
#include "lib/util.hpp"
|
||
#include "lib/p.hpp"
|
||
|
||
#include "steam/control/test-dummy-commands.hpp"
|
||
|
||
|
||
namespace steam {
|
||
namespace control {
|
||
namespace test {
|
||
|
||
using namespace lib::meta;
|
||
|
||
typedef lib::P<CommandImpl> PCmdImpl;
|
||
|
||
|
||
namespace { // test config...
|
||
HandlingPattern::ID TEST_HANDLING_PATTERN = HandlingPattern::DUMMY;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/****************************************************************************//**
|
||
* @test check creation of a command implementation clone from top level,
|
||
* without disclosing specific type information about the involved closure.
|
||
* This includes verifying sane allocation management.
|
||
* @note this test covers a very specific low-level perspective, but on an
|
||
* integration level, involving TypedAllocationManager, CommandRegistry,
|
||
* CommandImpl, CmdClosure, StorageHolder, UndoMutation, MementoTie.
|
||
* Closes: Ticket #298
|
||
*
|
||
* @see Command
|
||
* @see CommandRegistry
|
||
* @see command.cpp
|
||
* @see command-use1-test.cpp
|
||
*/
|
||
class CommandCloneBuilder_test : public Test
|
||
{
|
||
|
||
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
seedRand();
|
||
CommandRegistry& registry = CommandRegistry::instance();
|
||
CHECK (®istry);
|
||
uint cnt_inst = registry.instance_count();
|
||
|
||
{
|
||
PCmdImpl source = buildTestImplFrame (registry);
|
||
PCmdImpl clone = registry.createCloneImpl (*source);
|
||
|
||
verifySeparation (source, clone);
|
||
}
|
||
|
||
CHECK (cnt_inst == registry.instance_count());
|
||
}
|
||
|
||
|
||
|
||
PCmdImpl
|
||
buildTestImplFrame (CommandRegistry& registry)
|
||
{
|
||
// simulate what normally happens within a CommandDef
|
||
typedef void Sig_oper(int);
|
||
typedef long Sig_capt(int);
|
||
typedef void Sig_undo(int,long);
|
||
|
||
function<Sig_oper> o_Fun (command1::operate);
|
||
function<Sig_capt> c_Fun (command1::capture);
|
||
function<Sig_undo> u_Fun (command1::undoIt);
|
||
|
||
CHECK (o_Fun && c_Fun && u_Fun);
|
||
PCmdImpl cmd = registry.newCommandImpl(o_Fun,c_Fun,u_Fun);
|
||
|
||
// make ready for execution
|
||
bindRandArgument (*cmd);
|
||
CHECK (cmd->canExec());
|
||
return cmd;
|
||
}
|
||
|
||
|
||
/** Helper: create random command parameter binding */
|
||
void
|
||
bindRandArgument (CommandImpl& cmd)
|
||
{
|
||
using ArgType = TySeq<int>;
|
||
TypedArguments<Tuple<ArgType>> arg (std::make_tuple (rani (10000)));
|
||
cmd.setArguments (arg);
|
||
CHECK (cmd.canExec());
|
||
}
|
||
|
||
|
||
/** @test verify the two command implementation frames are
|
||
* indeed separate objects without interconnection.
|
||
* Performing an simulated command execution-undo
|
||
* cycle on both instances and verify difference.
|
||
*/
|
||
void
|
||
verifySeparation (PCmdImpl orig, PCmdImpl copy)
|
||
{
|
||
CHECK (orig && copy);
|
||
CHECK (orig->canExec());
|
||
CHECK (copy->canExec());
|
||
|
||
|
||
// prepare for command invocation on implementation level....
|
||
HandlingPattern const& testExec = HandlingPattern::get(TEST_HANDLING_PATTERN);
|
||
command1::check_ = 0;
|
||
|
||
bindRandArgument (*orig);
|
||
CHECK ( orig->canExec());
|
||
CHECK (!orig->canUndo());
|
||
testExec.exec (*orig, "Execute original"); // EXEC 1
|
||
long state_after_exec1 = command1::check_;
|
||
CHECK (command1::check_ > 0);
|
||
CHECK (orig->canUndo());
|
||
|
||
CHECK (!copy->canUndo());
|
||
testExec.exec (*copy, "Execute clone"); // EXEC 2
|
||
CHECK (command1::check_ != state_after_exec1);
|
||
CHECK (copy->canUndo());
|
||
|
||
// invoke UNDO on the clone
|
||
testExec.undo (*copy, "Undo clone"); // UNDO 2
|
||
CHECK (command1::check_ == state_after_exec1);
|
||
|
||
// invoke UNDO on original
|
||
testExec.undo (*orig, "Undo original"); // UNDO 1
|
||
CHECK (command1::check_ ==0);
|
||
}
|
||
|
||
};
|
||
|
||
|
||
/** Register this test class... */
|
||
LAUNCHER (CommandCloneBuilder_test, "function controller");
|
||
|
||
|
||
}}} // namespace steam::control::test
|