##// END OF EJS Templates
Implements execute() method of sync operation
Implements execute() method of sync operation

File last commit:

r1240:b9a9a3a9f506
r1240:b9a9a3a9f506
Show More
FuzzingOperations.cpp
245 lines | 10.2 KiB | text/x-c | CppLexer
/ plugins / amda / tests / FuzzingOperations.cpp
#include "FuzzingOperations.h"
#include "FuzzingUtils.h"
#include <Data/IDataProvider.h>
#include <Variable/Variable.h>
#include <Variable/VariableController.h>
#include <QUuid>
#include <functional>
Q_LOGGING_CATEGORY(LOG_FuzzingOperations, "FuzzingOperations")
namespace {
struct CreateOperation : public IFuzzingOperation {
bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
{
// A variable can be created only if it doesn't exist yet
return fuzzingState.variableState(variableId).m_Variable == nullptr;
}
void execute(VariableId variableId, FuzzingState &fuzzingState,
VariableController &variableController,
const Properties &properties) const override
{
// Retrieves metadata pool from properties, and choose one of the metadata entries to
// associate it with the variable
auto metaDataPool = properties.value(METADATA_POOL_PROPERTY).value<MetadataPool>();
auto variableMetadata = RandomGenerator::instance().randomChoice(metaDataPool);
// Retrieves provider
auto variableProvider
= properties.value(PROVIDER_PROPERTY).value<std::shared_ptr<IDataProvider> >();
auto variableName = QString{"Var_%1"}.arg(QUuid::createUuid().toString());
qCInfo(LOG_FuzzingOperations()).noquote()
<< "Creating variable" << variableName << "(metadata:" << variableMetadata << ")...";
auto newVariable
= variableController.createVariable(variableName, variableMetadata, variableProvider);
// Updates variable's state
auto &variableState = fuzzingState.variableState(variableId);
variableState.m_Range = properties.value(INITIAL_RANGE_PROPERTY).value<SqpRange>();
std::swap(variableState.m_Variable, newVariable);
}
};
struct DeleteOperation : public IFuzzingOperation {
bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
{
// A variable can be delete only if it exists
return fuzzingState.variableState(variableId).m_Variable != nullptr;
}
void execute(VariableId variableId, FuzzingState &fuzzingState,
VariableController &variableController, const Properties &) const override
{
auto &variableState = fuzzingState.variableState(variableId);
qCInfo(LOG_FuzzingOperations()).noquote()
<< "Deleting variable" << variableState.m_Variable->name() << "...";
variableController.deleteVariable(variableState.m_Variable);
// Updates variable's state
variableState.m_Range = INVALID_RANGE;
variableState.m_Variable = nullptr;
}
};
/**
* Defines a move operation through a range.
*
* A move operation is determined by three functions:
* - Two 'move' functions, used to indicate in which direction the beginning and the end of a range
* are going during the operation. These functions will be:
* -- {<- / <-} for pan left
* -- {-> / ->} for pan right
* -- {-> / <-} for zoom in
* -- {<- / ->} for zoom out
* - One 'max move' functions, used to compute the max delta at which the operation can move a
* range, according to a max range. For exemple, for a range of {1, 5} and a max range of {0, 10},
* max deltas will be:
* -- {0, 4} for pan left
* -- {6, 10} for pan right
* -- {3, 3} for zoom in
* -- {0, 6} for zoom out (same spacing left and right)
*/
struct MoveOperation : public IFuzzingOperation {
using MoveFunction = std::function<double(double currentValue, double maxValue)>;
using MaxMoveFunction = std::function<double(const SqpRange &range, const SqpRange &maxRange)>;
explicit MoveOperation(MoveFunction rangeStartMoveFun, MoveFunction rangeEndMoveFun,
MaxMoveFunction maxMoveFun,
const QString &label = QStringLiteral("Move operation"))
: m_RangeStartMoveFun{std::move(rangeStartMoveFun)},
m_RangeEndMoveFun{std::move(rangeEndMoveFun)},
m_MaxMoveFun{std::move(maxMoveFun)},
m_Label{label}
{
}
bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
{
return fuzzingState.variableState(variableId).m_Variable != nullptr;
}
void execute(VariableId variableId, FuzzingState &fuzzingState,
VariableController &variableController,
const Properties &properties) const override
{
auto &variableState = fuzzingState.variableState(variableId);
auto variable = variableState.m_Variable;
// Gets the max range defined
auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
.value<SqpRange>();
auto variableRange = variable->range();
if (maxRange == INVALID_RANGE || variableRange.m_TStart < maxRange.m_TStart
|| variableRange.m_TEnd > maxRange.m_TEnd) {
qCWarning(LOG_FuzzingOperations()) << "Can't execute operation: invalid max range";
return;
}
// Computes the max delta at which the variable can move, up to the limits of the max range
auto deltaMax = m_MaxMoveFun(variable->range(), maxRange);
// Generates random delta that will be used to move variable
auto delta = RandomGenerator::instance().generateDouble(0, deltaMax);
// Moves variable to its new range
auto newVariableRange = SqpRange{m_RangeStartMoveFun(variableRange.m_TStart, delta),
m_RangeEndMoveFun(variableRange.m_TEnd, delta)};
qCInfo(LOG_FuzzingOperations()).noquote()
<< "Performing" << m_Label << "on" << variable->name() << "(from" << variableRange
<< "to" << newVariableRange << ")...";
variableController.onRequestDataLoading({variable}, newVariableRange, false);
// Updates variable's state
variableState.m_Range = newVariableRange;
}
MoveFunction m_RangeStartMoveFun;
MoveFunction m_RangeEndMoveFun;
MaxMoveFunction m_MaxMoveFun;
QString m_Label;
};
struct SynchronizeOperation : public IFuzzingOperation {
bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
{
auto variable = fuzzingState.variableState(variableId).m_Variable;
return variable != nullptr && !fuzzingState.m_SyncGroupsPool.empty()
&& fuzzingState.syncGroupId(variableId).isNull();
}
void execute(VariableId variableId, FuzzingState &fuzzingState,
VariableController &variableController, const Properties &) const override
{
auto &variableState = fuzzingState.variableState(variableId);
// Chooses a random synchronization group and adds the variable into sync group
auto syncGroupId = RandomGenerator::instance().randomChoice(fuzzingState.syncGroupsIds());
qCInfo(LOG_FuzzingOperations()).noquote()
<< "Adding" << variableState.m_Variable->name() << "into synchronization group"
<< syncGroupId << "...";
variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
// Updates state
fuzzingState.synchronizeVariable(variableId, syncGroupId);
}
};
struct DesynchronizeOperation : public IFuzzingOperation {
bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
{
auto variable = fuzzingState.variableState(variableId).m_Variable;
return variable != nullptr && !fuzzingState.syncGroupId(variableId).isNull();
}
void execute(VariableId variableId, FuzzingState &fuzzingState,
VariableController &variableController, const Properties &) const override
{
struct UnknownOperation : public IFuzzingOperation {
bool canExecute(VariableId, const FuzzingState &) const override { return false; }
void execute(VariableId, FuzzingState &, VariableController &,
const Properties &) const override
{
}
};
} // namespace
std::unique_ptr<IFuzzingOperation> FuzzingOperationFactory::create(FuzzingOperationType type)
{
switch (type) {
case FuzzingOperationType::CREATE:
return std::make_unique<CreateOperation>();
case FuzzingOperationType::DELETE:
return std::make_unique<DeleteOperation>();
case FuzzingOperationType::PAN_LEFT:
return std::make_unique<MoveOperation>(
std::minus<double>(), std::minus<double>(),
[](const SqpRange &range, const SqpRange &maxRange) {
return range.m_TStart - maxRange.m_TStart;
},
QStringLiteral("Pan left operation"));
case FuzzingOperationType::PAN_RIGHT:
return std::make_unique<MoveOperation>(
std::plus<double>(), std::plus<double>(),
[](const SqpRange &range, const SqpRange &maxRange) {
return maxRange.m_TEnd - range.m_TEnd;
},
QStringLiteral("Pan right operation"));
case FuzzingOperationType::ZOOM_IN:
return std::make_unique<MoveOperation>(
std::plus<double>(), std::minus<double>(),
[](const SqpRange &range, const SqpRange &maxRange) {
Q_UNUSED(maxRange)
return range.m_TEnd - (range.m_TStart + range.m_TEnd) / 2.;
},
QStringLiteral("Zoom in operation"));
case FuzzingOperationType::ZOOM_OUT:
return std::make_unique<MoveOperation>(
std::minus<double>(), std::plus<double>(),
[](const SqpRange &range, const SqpRange &maxRange) {
return std::min(range.m_TStart - maxRange.m_TStart,
maxRange.m_TEnd - range.m_TEnd);
},
QStringLiteral("Zoom out operation"));
case FuzzingOperationType::SYNCHRONIZE:
return std::make_unique<SynchronizeOperation>();
case FuzzingOperationType::DESYNCHRONIZE:
return std::make_unique<DesynchronizeOperation>();
default:
// Default case returns unknown operation
break;
}
return std::make_unique<UnknownOperation>();
}