/* CommandRegistry(Test) - verify command registration and allocation Copyright (C) 2009, Hermann Vosseler   **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-registry-test.cpp ** unit test \ref CommandRegistry_test */ #include "lib/test/run.hpp" #include "lib/test/test-helper.hpp" #include "steam/control/command-def.hpp" #include "steam/control/command-registry.hpp" #include "lib/symbol.hpp" #include "lib/util.hpp" #include "steam/control/test-dummy-commands.hpp" #include namespace steam { namespace control { namespace test { using std::function; using util::isSameObject; using lib::Symbol; namespace { // test data and helpers... Symbol TEST_CMD = "test.command1.1"; Symbol TEST_CMD2 = "test.command1.2"; } /***************************************************************************//** * @test verify sane behaviour of the relevant operations on the CommandRegistry * interface. Add/remove a command instance to the index, allocate an * CommandImpl frame and verify it is removed properly on ref count zero. * @note this test covers the internal bits of functionality, * not the behaviour of the (integrated) command framework * * @see Command * @see CommandRegistry * @see command.cpp * @see command-use1-test.cpp */ class CommandRegistry_test : public Test { uint cnt_defs; uint cnt_inst; virtual void run (Arg) { CommandRegistry& registry = CommandRegistry::instance(); CHECK (®istry); cnt_defs = registry.index_size(); cnt_inst = registry.instance_count(); // prepare a command definition (prototype) CommandDef (TEST_CMD) .operation (command1::operate) .captureUndo (command1::capture) .undoOperation (command1::undoIt) .bind(123); // this command definition is // represented internally by a prototype instance CHECK (++cnt_inst == registry.instance_count()); CHECK (++cnt_defs == registry.index_size()); checkRegistration (registry); checkAllocation(registry); CHECK (cnt_inst == registry.instance_count()); CHECK (cnt_defs == registry.index_size()); Command::remove (TEST_CMD); CHECK (--cnt_inst == registry.instance_count()); } /** @test verify the index operation. * Add, search, remove, store copy. */ void checkRegistration (CommandRegistry& registry) { CHECK (cnt_inst == registry.instance_count()); Command cmd1 = registry.queryIndex (TEST_CMD); CHECK (cmd1); CHECK (TEST_CMD == registry.findDefinition(cmd1)); Command nonexistant = registry.queryIndex("miraculous"); CHECK (!nonexistant); // now create a clone, registered under a different ID Command cmd2 = cmd1.storeDef(TEST_CMD2); CHECK (cmd2 != cmd1); // note: while they are equivalent, they are not identical Command cm2x = cmd2.bind(54321); CHECK (cm2x != cmd1); CHECK (cm2x == cmd2); // this created exactly one additional instance allocation: CHECK (1+cnt_inst == registry.instance_count()); CHECK (1+cnt_defs == registry.index_size()); // ...and another index entry Command cmdX = registry.queryIndex(TEST_CMD2); CHECK (cmdX == cmd2); CHECK (cmdX != cmd1); CHECK (registry.remove(TEST_CMD2)); CHECK (!registry.queryIndex(TEST_CMD2)); CHECK (cnt_defs == registry.index_size()); // removed from index CHECK (1+cnt_inst == registry.instance_count()); //...but still alive CHECK (cmdX.isAnonymous()); CHECK (cmd2.isAnonymous()); //......they got deached CHECK (!cmd1.isAnonymous()); // create a new registration.. registry.track(TEST_CMD2, cmd2); CHECK (registry.queryIndex(TEST_CMD2)); CHECK (1+cnt_defs == registry.index_size()); // again holding two distinct entries CHECK (cmdX == cmd2); CHECK (cmdX != cmd1); CHECK (TEST_CMD == registry.findDefinition(cmd1)); CHECK (TEST_CMD2 == registry.findDefinition(cmd2)); CHECK (TEST_CMD2 == registry.findDefinition(cmdX)); CHECK ( registry.remove(TEST_CMD2)); CHECK (!registry.remove("miraculous")); CHECK (!registry.queryIndex(TEST_CMD2)); CHECK ( registry.queryIndex(TEST_CMD)); CHECK (cnt_defs == registry.index_size()); // the index entry is gone, CHECK (1+cnt_inst == registry.instance_count()); // but the allocation still lives cmdX.close(); CHECK (1+cnt_inst == registry.instance_count()); cmd2.close(); cm2x.close(); CHECK (0+cnt_inst == registry.instance_count()); // ...as long as it's still referred } /** @test verify the allocation/de-allocation handling as * embedded into the CommandRegistry operation. * Simulates on low level what normally happens * during command lifecycle. */ void checkAllocation (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 o_Fun (command1::operate); function c_Fun (command1::capture); function u_Fun (command1::undoIt); CHECK (o_Fun && c_Fun && u_Fun); CHECK (cnt_inst == registry.instance_count()); // when the CommandDef is complete, it issues the // allocation call to the registry behind the scenes.... using PImpl = shared_ptr; PImpl pImpl = registry.newCommandImpl(o_Fun,c_Fun,u_Fun); CHECK (1+cnt_inst == registry.instance_count()); CHECK (pImpl); CHECK (pImpl->isValid()); CHECK (!pImpl->canExec()); CHECK (1 == pImpl.use_count()); // no magic involved, we hold the only instance PImpl clone = registry.createCloneImpl(*pImpl); CHECK (clone->isValid()); CHECK (!clone->canExec()); CHECK (1 == clone.use_count()); CHECK (1 == pImpl.use_count()); CHECK (2+cnt_inst == registry.instance_count()); CHECK (!isSameObject (*pImpl, *clone)); CHECK (!pImpl->canExec()); using ArgTuple = std::tuple; TypedArguments arg{ArgTuple{98765}}; pImpl->setArguments(arg); CHECK (pImpl->canExec()); CHECK (!clone->canExec()); // this proves the clone has indeed a separate identity // discard the first clone and overwrite with a new one clone = registry.createCloneImpl(*pImpl); CHECK (2+cnt_inst == registry.instance_count()); CHECK (clone->canExec()); clone.reset(); pImpl.reset(); // corresponding allocation slots cleared automatically CHECK (cnt_inst == registry.instance_count()); } }; /** Register this test class... */ LAUNCHER (CommandRegistry_test, "function controller"); }}} // namespace steam::control::test