HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1192:96867eb9a6ed

Adds delete operation

Alexandre Leroux -

r1192:96867eb9a6ed

parent child

Context file:

r1192:96867eb9a6ed

Collapse all files

plugins/amda/tests/FuzzingOperations.cpp +25 -1

             #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(const VariableState &variableState) const override
                 {
                     // A variable can be created only if it doesn't exist yet
                     return variableState.m_Variable == nullptr;
                 }
                 void execute(VariableState &variableState, 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 << ")";
+                        << "Creating variable" << variableName << "(metadata:" << variableMetadata << ")...";
                     auto newVariable
                         = variableController.createVariable(variableName, variableMetadata, variableProvider);
                     // Updates variable's state
                     variableState.m_Range = properties.value(INITIAL_RANGE_PROPERTY).value<SqpRange>();
                     std::swap(variableState.m_Variable, newVariable);
                 }
             };
+            struct DeleteOperation : public IFuzzingOperation {
+                bool canExecute(const VariableState &variableState) const override
+                {
+                    // A variable can be delete only if it exists
+                    return variableState.m_Variable != nullptr;
+                }
+                void execute(VariableState &variableState, VariableController &variableController,
+                             const Properties &properties) const override
+                {
+                    Q_UNUSED(properties);
+                    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(const VariableState &variableState) const override
                 {
                     return variableState.m_Variable != nullptr;
                 }
                 void execute(VariableState &variableState, VariableController &variableController,
                              const Properties &properties) const override
                 {
                     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 UnknownOperation : public IFuzzingOperation {
                 bool canExecute(const VariableState &variableState) const override
                 {
                     Q_UNUSED(variableState);
                     return false;
                 }
                 void execute(VariableState &variableState, VariableController &variableController,
                              const Properties &properties) const override
                 {
                     Q_UNUSED(variableState);
                     Q_UNUSED(variableController);
                     Q_UNUSED(properties);
                     // Does nothing
                 }
             };
             } // 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"));
                     default:
                         // Default case returns unknown operation
                         break;
                 }
                 return std::make_unique<UnknownOperation>();
             }

plugins/amda/tests/FuzzingOperations.h +1 -1

             #ifndef SCIQLOP_FUZZINGOPERATIONS_H
             #define SCIQLOP_FUZZINGOPERATIONS_H
             #include "FuzzingDefs.h"
             #include <memory>
             #include <set>
             #include <QLoggingCategory>
             #include <QMetaType>
             Q_DECLARE_LOGGING_CATEGORY(LOG_FuzzingOperations)
             class VariableController;
             /**
              * Enumeration of types of existing fuzzing operations
              */
-            enum class FuzzingOperationType { CREATE, PAN_LEFT, PAN_RIGHT, ZOOM_IN, ZOOM_OUT };
+            enum class FuzzingOperationType { CREATE, DELETE, PAN_LEFT, PAN_RIGHT, ZOOM_IN, ZOOM_OUT };
             /// Interface that represents an operation that can be executed during a fuzzing test
             struct IFuzzingOperation {
                 virtual ~IFuzzingOperation() noexcept = default;
                 /// Checks if the operation can be executed according to the current variable state passed in
                 /// parameter
                 virtual bool canExecute(const VariableState &variableState) const = 0;
                 /// Executes the operation on the variable state passed in parameter
                 /// @param variableState the variable state on which to execute the operation
                 /// @param variableController the controller associated to the operation
                 /// @param properties properties that can be used to configure the operation
                 /// @remarks variableState is passed as a reference because, according to the operation, it can
                 /// be
                 /// modified (in/out parameter)
                 virtual void execute(VariableState &variableState, VariableController &variableController,
                                      const Properties &properties = {}) const = 0;
             };
             /// Factory of @sa IFuzzingOperation
             struct FuzzingOperationFactory {
                 /// Creates a fuzzing operation from a type
                 static std::unique_ptr<IFuzzingOperation> create(FuzzingOperationType type);
             };
             using WeightedOperationsTypes = std::map<FuzzingOperationType, double>;
             Q_DECLARE_METATYPE(WeightedOperationsTypes)
             #endif // SCIQLOP_FUZZINGOPERATIONS_H

plugins/amda/tests/TestAmdaFuzzing.cpp +7 -7

             #include "FuzzingDefs.h"
             #include "FuzzingOperations.h"
             #include "FuzzingUtils.h"
             #include "AmdaProvider.h"
             #include <Network/NetworkController.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_TestAmdaFuzzing, "TestAmdaFuzzing")
             namespace {
             // /////// //
             // Aliases //
             // /////// //
             using VariableId = int;
             using Weight = double;
             using Weights = std::vector<Weight>;
             using VariableOperation = std::pair<VariableId, std::shared_ptr<IFuzzingOperation> >;
             using VariablesOperations = std::vector<VariableOperation>;
             using WeightedOperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, Weight>;
             using VariablesPool = std::map<VariableId, VariableState>;
             // ///////// //
             // Constants //
             // ///////// //
             // Defaults values used when the associated properties have not been set for the test
             const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;
             const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 1;
-            const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE
+            const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE = QVariant::fromValue(WeightedOperationsTypes{
-                = QVariant::fromValue(WeightedOperationsTypes{{FuzzingOperationType::CREATE, 1.},
+                {FuzzingOperationType::CREATE, 1.},
-                                                              {FuzzingOperationType::PAN_LEFT, 1.},
+                {FuzzingOperationType::DELETE, 0.1}, // Delete operation is less frequent
-                                                              {FuzzingOperationType::PAN_RIGHT, 1.},
+                {FuzzingOperationType::PAN_LEFT, 1.},
-                                                              {FuzzingOperationType::ZOOM_IN, 1.},
+                {FuzzingOperationType::PAN_RIGHT, 1.},
-                                                              {FuzzingOperationType::ZOOM_OUT, 1.}});
+                {FuzzingOperationType::ZOOM_IN, 1.},
+                {FuzzingOperationType::ZOOM_OUT, 1.}});
             const auto CACHE_TOLERANCE_DEFAULT_VALUE = 0.2;
             /// Delay between each operation (in ms)
             const auto OPERATION_DELAY_DEFAULT_VALUE = 3000;
             // /////// //
             // Methods //
             // /////// //
             /// Goes through the variables pool and operations pool to determine the set of {variable/operation}
             /// pairs that are valid (i.e. operation that can be executed on variable)
             std::pair<VariablesOperations, Weights>
             availableOperations(const VariablesPool &variablesPool,
                                 const WeightedOperationsPool &operationsPool)
             {
                 VariablesOperations result{};
                 Weights weights{};
                 for (const auto &variablesPoolEntry : variablesPool) {
                     auto variableId = variablesPoolEntry.first;
                     const auto &variableState = variablesPoolEntry.second;
                     for (const auto &operationsPoolEntry : operationsPool) {
                         auto operation = operationsPoolEntry.first;
                         auto weight = operationsPoolEntry.second;
                         // A pair is valid if the current operation can be executed on the current variable
                         if (operation->canExecute(variableState)) {
                             result.push_back({variableId, operation});
                             weights.push_back(weight);
                         }
                     }
                 }
                 return {result, weights};
             }
             WeightedOperationsPool createOperationsPool(const WeightedOperationsTypes &types)
             {
                 WeightedOperationsPool result{};
                 std::transform(
                     types.cbegin(), types.cend(), std::inserter(result, result.end()), [](const auto &type) {
                         return std::make_pair(FuzzingOperationFactory::create(type.first), type.second);
                     });
                 return result;
             }
             /**
              * Class to run random tests
              */
             class FuzzingTest {
             public:
                 explicit FuzzingTest(VariableController &variableController, Properties properties)
                         : m_VariableController{variableController},
                           m_Properties{std::move(properties)},
                           m_VariablesPool{}
                 {
                     // Inits variables pool: at init, all variables are null
                     for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {
                         m_VariablesPool[variableId] = VariableState{};
                     }
                 }
                 void execute()
                 {
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Running" << nbMaxOperations() << "operations on"
                                                             << nbMaxVariables() << "variable(s)...";
                     auto canExecute = true;
                     for (auto i = 0; i < nbMaxOperations() && canExecute; ++i) {
                         // Retrieves all operations that can be executed in the current context
                         VariablesOperations variableOperations{};
                         Weights weights{};
                         std::tie(variableOperations, weights)
                             = availableOperations(m_VariablesPool, operationsPool());
                         canExecute = !variableOperations.empty();
                         if (canExecute) {
                             // Of the operations available, chooses a random operation and executes it
                             auto variableOperation
                                 = RandomGenerator::instance().randomChoice(variableOperations, weights);
                             auto variableId = variableOperation.first;
                             auto &variableState = m_VariablesPool.at(variableId);
                             auto fuzzingOperation = variableOperation.second;
                             fuzzingOperation->execute(variableState, m_VariableController, m_Properties);
                             QTest::qWait(operationDelay());
                         }
                         else {
                             qCInfo(LOG_TestAmdaFuzzing()).noquote()
                                 << "No more operations are available, the execution of the test will stop...";
                         }
                     }
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Execution of the test completed.";
                 }
             private:
                 int nbMaxOperations() const
                 {
                     static auto result
                         = m_Properties.value(NB_MAX_OPERATIONS_PROPERTY, NB_MAX_OPERATIONS_DEFAULT_VALUE)
                               .toInt();
                     return result;
                 }
                 int nbMaxVariables() const
                 {
                     static auto result
                         = m_Properties.value(NB_MAX_VARIABLES_PROPERTY, NB_MAX_VARIABLES_DEFAULT_VALUE).toInt();
                     return result;
                 }
                 int operationDelay() const
                 {
                     static auto result
                         = m_Properties.value(OPERATION_DELAY_PROPERTY, OPERATION_DELAY_DEFAULT_VALUE).toInt();
                     return result;
                 }
                 WeightedOperationsPool operationsPool() const
                 {
                     static auto result = createOperationsPool(
                         m_Properties.value(AVAILABLE_OPERATIONS_PROPERTY, AVAILABLE_OPERATIONS_DEFAULT_VALUE)
                             .value<WeightedOperationsTypes>());
                     return result;
                 }
                 VariableController &m_VariableController;
                 Properties m_Properties;
                 VariablesPool m_VariablesPool;
             };
             } // namespace
             class TestAmdaFuzzing : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input data for @sa testFuzzing()
                 void testFuzzing_data();
                 void testFuzzing();
             };
             void TestAmdaFuzzing::testFuzzing_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 QTest::addColumn<Properties>("properties"); // Properties for random test
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto maxRange = SqpRange::fromDateTime({2017, 1, 1}, {0, 0}, {2017, 1, 5}, {0, 0});
                 MetadataPool metadataPool{{{"dataType", "vector"}, {"xml:id", "imf"}}};
                 // Note: we don't use auto here as we want to pass std::shared_ptr<IDataProvider> as is in the
                 // QVariant
                 std::shared_ptr<IDataProvider> provider = std::make_shared<AmdaProvider>();
                 QTest::newRow("fuzzingTest") << Properties{
                     {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
                     {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
                     {PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
             }
             void TestAmdaFuzzing::testFuzzing()
             {
                 QFETCH(Properties, properties);
                 // Sets cache property
                 QSettings settings{};
                 auto cacheTolerance = properties.value(CACHE_TOLERANCE_PROPERTY, CACHE_TOLERANCE_DEFAULT_VALUE);
                 settings.setValue(GENERAL_TOLERANCE_AT_INIT_KEY, cacheTolerance);
                 settings.setValue(GENERAL_TOLERANCE_AT_UPDATE_KEY, cacheTolerance);
                 auto &variableController = sqpApp->variableController();
                 auto &timeController = sqpApp->timeController();
                 // Generates random initial range (bounded to max range)
                 auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
                                     .value<SqpRange>();
                 QVERIFY(maxRange != INVALID_RANGE);
                 auto initialRangeStart
                     = RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
                 auto initialRangeEnd
                     = RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
                 if (initialRangeStart > initialRangeEnd) {
                     std::swap(initialRangeStart, initialRangeEnd);
                 }
                 // Sets initial range on time controller
                 SqpRange initialRange{initialRangeStart, initialRangeEnd};
                 qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Setting initial range to" << initialRange << "...";
                 timeController.onTimeToUpdate(initialRange);
                 properties.insert(INITIAL_RANGE_PROPERTY, QVariant::fromValue(initialRange));
                 FuzzingTest test{variableController, properties};
                 test.execute();
             }
             int main(int argc, char *argv[])
             {
                 QLoggingCategory::setFilterRules(
                     "*.warning=false\n"
                     "*.info=false\n"
                     "*.debug=false\n"
                     "FuzzingOperations.info=true\n"
                     "TestAmdaFuzzing.info=true\n");
                 SqpApplication app{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop-TestFuzzing");
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestAmdaFuzzing testObject{};
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&testObject, argc, argv);
             }
             #include "TestAmdaFuzzing.moc"

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages