ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
LUMIERA.clone/tests/core/steam/control/command-use2-test.cpp
Ichthyostega 0b9e184fa3 Library: replace usages of rand() in the whole code base 
* most usages are drop-in replacements
 * occasionally the other convenience functions can be used
 * verify call-paths from core code to identify usages
 * ensure reseeding for all tests involving some kind of randomness...

__Note__: some tests were not yet converted,
since their usage of randomness is actually not thread-safe.
This problem existed previously, since also `rand()` is not thread safe,
albeit in most cases it is possible to ignore this problem, as
''garbled internal state'' is also somehow „random“
2024-11-13 04:23:46 +01:00

270 lines
8.7 KiB
C++
Raw Blame History

/*
CommandUse2(Test) - usage aspects II
Copyright (C) Lumiera.org
2009, Hermann Vosseler <Ichthyostega@web.de>
This program 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.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* *****************************************************/
/** @file command-use2-test.cpp
** unit test \ref CommandUse2_test
*/
#include "lib/test/run.hpp"
#include "lib/test/test-helper.hpp"
#include "steam/control/command.hpp"
#include "steam/control/command-def.hpp"
#include "steam/control/handling-pattern.hpp"
#include "lib/format-string.hpp"
#include "lib/format-obj.hpp"
#include "lib/util.hpp"
#include "steam/control/test-dummy-commands.hpp"
extern "C" {
#include "common/interfaceregistry.h"
}
#include "steam/control/steam-dispatcher.hpp"
#include "include/session-command-facade.h"
#include <functional>
#include <boost/ref.hpp>
#include <boost/lexical_cast.hpp>
#include <string>
namespace steam {
namespace control {
namespace test {
using util::_Fmt;
using std::string;
using std::function;
using std::bind;
using std::ref;
using boost::lexical_cast;
using util::contains;
using LERR_(EXTERNAL);
/** diagnostics: checks if the given value has been written
* to the test protocol (string stream) of command2
* Explanation: command2 accepts a function, invokes
* it and writes the result to the protocol stream.
*/
template<typename TY>
inline bool
protocolled (TY val2check)
{
return contains ( command2::check_.str()
, util::toString (val2check)
);
}
/***********************************************************************//**
* @test command usage aspects II: patterns of command invocation.
*
* @todo this test is still on hold, as the non-trivial patterns aren't implemented as of 10/09 ////////////////TICKET #211
*
* @see Command
* @see command-basic-test.cpp (simple usage example)
*/
class CommandUse2_test : public Test
{
int randVal_;
string randomTxt()
{
_Fmt fmt ("invoked( %2d )");
randVal_ = rani (100);
return fmt % randVal_;
}
bool blowUp_;
virtual void
run (Arg)
{
seedRand();
command2::check_.seekp(0);
uint cnt_defs = Command::definition_count();
uint cnt_inst = Command::instance_count();
function<string()> randFun = bind (&CommandUse2_test::randomTxt, this);
// prepare a command definition (prototype)
CommandDef ("test.command2")
.operation (command2::operate)
.captureUndo (command2::capture)
.undoOperation (command2::undoIt)
.bind (randFun, &blowUp_);
//note : blowUp_ is bound via pointer,
// thus we can provoke an exception at will.
blowUp_ = false;
check_defaultHandlingPattern();
// check_ThrowOnError(); //////////////////////////////////////////////////////////////////////TICKET #211
check_DispatcherInvocation();
Command::remove ("test.command2");
Command::remove ("test.command2.1");
CHECK (cnt_defs == Command::definition_count());
CHECK (cnt_inst == Command::instance_count());
}
void
check_defaultHandlingPattern()
{
Command com = Command::get("test.command2");
CHECK (!protocolled("invoked"));
bool success = com();
CHECK (success);
CHECK (protocolled("invoked"));
CHECK (protocolled(randVal_));
success = com.undo();
CHECK (success); // UNDO invoked successfully
CHECK (!protocolled(randVal_));
CHECK (protocolled("UNDO"));
blowUp_ = true;
string current = command2::check_.str();
success = com();
CHECK (not success); // NOT executed successfully (exception thrown and caught)
CHECK (command2::check_.str() == current);
CHECK (!lumiera_error_peek()); // already absorbed
success = com.undo();
CHECK (not success); // UNDO failed (exception thrown and caught)
CHECK (command2::check_.str() == current);
blowUp_ = false;
}
void
check_ThrowOnError()
{
Command com = Command::get("test.command2");
blowUp_ = false;
com.exec(HandlingPattern::SYNC_THROW);
CHECK (protocolled(randVal_));
blowUp_ = true;
string current = command2::check_.str();
HandlingPattern const& doThrow = HandlingPattern::get(HandlingPattern::SYNC_THROW);
VERIFY_ERROR( EXTERNAL, com.exec (doThrow) );
CHECK (command2::check_.str() == current);
// we can achieve the same effect,
// after changing the default HandlingPatern for this command instance
com.setHandlingPattern(HandlingPattern::SYNC_THROW);
com.storeDef ("test.command2.1");
Command com2 = Command::get("test.command2.1");
VERIFY_ERROR( EXTERNAL, com2() );
CHECK (command2::check_.str() == current);
blowUp_ = false;
com2();
CHECK (command2::check_.str() > current);
CHECK (protocolled(randVal_));
com2.undo();
CHECK (!protocolled(randVal_));
}
/** @test simplified integration test of command dispatch
* - performs the minimal actions necessary to start the session loop thread
* - then issues a test command, which will be queued and dispatched
* by the SteamDispatcher. Like in the real application, the command
* executions happens in the dedicated session loop thread, and thus
* we have to wait a moment, after which execution can be verified.
* - finally the SteamDispatcher is signalled to shut down.
* @see SessionCommandFunction_test for much more in-depth coverage of this aspect
*/
void
check_DispatcherInvocation()
{
CHECK (not SteamDispatcher::instance().isRunning());
lumiera_interfaceregistry_init();
lumiera::throwOnError();
#define __DELAY__ usleep(10000);
bool thread_has_ended{false};
SteamDispatcher::instance().start ([&] (string*) { thread_has_ended = true; });
CHECK (SteamDispatcher::instance().isRunning());
CHECK (not thread_has_ended);
//----Session-Loop-Thread-is-running------------------------
string cmdID {"test.command2"};
string prevExecLog = command2::check_.str();
// previous test cases prepared the arguments
// so that we can just trigger command execution.
// In the real application, this call is issued
// from CoreService when receiving a command
// invocation message over the UI-Bus
SessionCommand::facade().invoke(cmdID);
__DELAY__ // wait a moment for the other thread to dispatch the command...
CHECK (prevExecLog != command2::check_.str());
//----Session-Loop-Thread-is-running------------------------
// shut down the SteamDispatcher...
CHECK (SteamDispatcher::instance().isRunning());
SteamDispatcher::instance().requestStop();
__DELAY__ // wait a moment for the other thread to terminate...
CHECK (not SteamDispatcher::instance().isRunning());
CHECK (thread_has_ended);
lumiera_interfaceregistry_destroy();
}
};
/** Register this test class... */
LAUNCHER (CommandUse2_test, "function controller");
}}} // namespace steam::control::test
Reference in a new issue View git blame Copy permalink