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