HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1203:ea04bef9c90c

Passes FuzzingState and variable id instead VariableState to the methods of operations

Alexandre Leroux -

r1203:ea04bef9c90c

parent child

Context file:

r1203:ea04bef9c90c

Collapse all files

plugins/amda/tests/FuzzingOperations.cpp +18 -22

             namespace {
             struct CreateOperation : public IFuzzingOperation {
-                bool canExecute(const VariableState &variableState) const override
+                bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     // A variable can be created only if it doesn't exist yet
-                    return variableState.m_Variable == nullptr;
+                    return fuzzingState.variableState(variableId).m_Variable == nullptr;
                 }
-                void execute(VariableState &variableState, VariableController &variableController,
+                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
                         = 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(const VariableState &variableState) const override
+                bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     // A variable can be delete only if it exists
-                    return variableState.m_Variable != nullptr;
+                    return fuzzingState.variableState(variableId).m_Variable != nullptr;
                 }
-                void execute(VariableState &variableState, VariableController &variableController,
+                void execute(VariableId variableId, FuzzingState &fuzzingState,
-                             const Properties &properties) const override
+                             VariableController &variableController, const Properties &) const override
                 {
-                    Q_UNUSED(properties);
+                    auto &variableState = fuzzingState.variableState(variableId);
                     qCInfo(LOG_FuzzingOperations()).noquote()
                         << "Deleting variable" << variableState.m_Variable->name() << "...";
                 {
                 }
-                bool canExecute(const VariableState &variableState) const override
+                bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
-                    return variableState.m_Variable != nullptr;
+                    return fuzzingState.variableState(variableId).m_Variable != nullptr;
                 }
-                void execute(VariableState &variableState, VariableController &variableController,
+                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
             };
             struct UnknownOperation : public IFuzzingOperation {
-                bool canExecute(const VariableState &variableState) const override
+                bool canExecute(VariableId, const FuzzingState &) const override { return false; }
-                    Q_UNUSED(variableState);
-                    return false;
-                void execute(VariableState &variableState, VariableController &variableController,
+                void execute(VariableId, FuzzingState &, VariableController &,
-                             const Properties &properties) const override
+                             const Properties &) const override
                 {
-                    Q_UNUSED(variableState);
-                    Q_UNUSED(variableController);
-                    Q_UNUSED(properties);
-                    // Does nothing
                 }
             };

plugins/amda/tests/FuzzingOperations.h +11 -9

             struct IFuzzingOperation {
                 virtual ~IFuzzingOperation() noexcept = default;
-                /// Checks if the operation can be executed according to the current variable state passed in
+                /// Checks if the operation can be executed according to the current test's state for the
-                /// parameter
+                /// variable passed in parameter
-                virtual bool canExecute(const VariableState &variableState) const = 0;
+                virtual bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const = 0;
-                /// Executes the operation on the variable state passed in parameter
+                /// Executes the operation on the variable for which its identifier is passed in parameter
-                /// @param variableState the variable state on which to execute the operation
+                /// @param variableId the variable identifier
+                /// @param fuzzingState the current test's state on which to find the variable and 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
+                /// @remarks fuzzingState is passed as a reference because, according to the operation, it can
-                /// be
+                /// be modified (in/out parameter)
-                /// modified (in/out parameter)
+                virtual void execute(VariableId variableId, FuzzingState &fuzzingState,
-                virtual void execute(VariableState &variableState, VariableController &variableController,
+                                     VariableController &variableController,
                                      const Properties &properties = {}) const = 0;
             };

plugins/amda/tests/TestAmdaFuzzing.cpp +10 -14

             // Aliases //
             // /////// //
-            using VariableId = int;
             using Weight = double;
             using Weights = std::vector<Weight>;
             using VariablesOperations = std::vector<VariableOperation>;
             using WeightedOperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, Weight>;
-            using VariablesPool = std::map<VariableId, VariableState>;
             using Validators = std::vector<std::shared_ptr<IFuzzingValidator> >;
             // ///////// //
             /// 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,
+            availableOperations(const FuzzingState &fuzzingState, const WeightedOperationsPool &operationsPool)
-                                const WeightedOperationsPool &operationsPool)
             {
                 VariablesOperations result{};
                 Weights weights{};
-                for (const auto &variablesPoolEntry : variablesPool) {
+                for (const auto &variablesPoolEntry : fuzzingState.m_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)) {
+                        if (operation->canExecute(variableId, fuzzingState)) {
                             result.push_back({variableId, operation});
                             weights.push_back(weight);
                         }
                 explicit FuzzingTest(VariableController &variableController, Properties properties)
                         : m_VariableController{variableController},
                           m_Properties{std::move(properties)},
-                          m_VariablesPool{}
+                          m_FuzzingState{}
                 {
                     // Inits variables pool: at init, all variables are null
                     for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {
-                        m_VariablesPool[variableId] = VariableState{};
+                        m_FuzzingState.m_VariablesPool[variableId] = VariableState{};
                     }
                 }
                         VariablesOperations variableOperations{};
                         Weights weights{};
                         std::tie(variableOperations, weights)
-                            = availableOperations(m_VariablesPool, operationsPool());
+                            = availableOperations(m_FuzzingState, operationsPool());
                         canExecute = !variableOperations.empty();
                         if (canExecute) {
                                 = 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);
+                            fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
+                                                      m_Properties);
                             QTest::qWait(operationDelay());
                             // Validates variables
-                            validate(m_VariablesPool, validators());
+                            validate(m_FuzzingState.m_VariablesPool, validators());
                         }
                         else {
                             qCInfo(LOG_TestAmdaFuzzing()).noquote()
                 VariableController &m_VariableController;
                 Properties m_Properties;
-                VariablesPool m_VariablesPool;
+                FuzzingState m_FuzzingState;
             };
             } // namespace

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