GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1222:70ee007bcdd0

7

#include <Network/NetworkController.h>

7

#include <Network/NetworkController.h>

8

#include <SqpApplication.h>

8

#include <SqpApplication.h>

9

#include <Time/TimeController.h>

9

#include <Time/TimeController.h>

10

#include <Variable/Variable.h>

10

#include <Variable/VariableController.h>

11

#include <Variable/VariableController.h>

11

12

#include <QLoggingCategory>

13

#include <QLoggingCategory>

31

using VariablesOperations = std::vector<VariableOperation>;

32

using VariablesOperations = std::vector<VariableOperation>;

32

33

using WeightedOperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, Weight>;

34

using WeightedOperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, Weight>;

34

using VariablesPool = std::map<VariableId, ~~std~~::~~shared_ptr~~<Variable> >;

35

using VariablesPool = std::map<VariableId, VariableState>;

35

36

// ///////// //

37

// ///////// //

37

// Constants //

38

// Constants //

65

66

for (const auto &variablesPoolEntry : variablesPool) {

67

for (const auto &variablesPoolEntry : variablesPool) {

67

auto variableId = variablesPoolEntry.first;

68

auto variableId = variablesPoolEntry.first;

68

auto variable = variablesPoolEntry.second;

69

const auto &variableState = variablesPoolEntry.second;

69

70

for (const auto &operationsPoolEntry : operationsPool) {

71

for (const auto &operationsPoolEntry : operationsPool) {

71

auto operation = operationsPoolEntry.first;

72

auto operation = operationsPoolEntry.first;

72

auto weight = operationsPoolEntry.second;

73

auto weight = operationsPoolEntry.second;

73

74

// A pair is valid if the current operation can be executed on the current variable

75

// A pair is valid if the current operation can be executed on the current variable

75

if (operation->canExecute(variable)) {

76

if (operation->canExecute(variableState)) {

76

result.push_back({variableId, operation});

77

result.push_back({variableId, operation});

77

weights.push_back(weight);

78

weights.push_back(weight);

78

}

79

}

106

{

107

{

107

// Inits variables pool: at init, all variables are null

108

// Inits variables pool: at init, all variables are null

108

for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {

109

for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {

109

m_VariablesPool[variableId] = ~~nullptr~~;

110

m_VariablesPool[variableId] = VariableState{};

110

}

111

}

111

}

112

}

112

113

130

= RandomGenerator::instance().randomChoice(variableOperations, weights);

131

= RandomGenerator::instance().randomChoice(variableOperations, weights);

131

132

auto variableId = variableOperation.first;

133

auto variableId = variableOperation.first;

133

auto variable = m_VariablesPool.at(variableId);

134

auto &variableState = m_VariablesPool.at(variableId);

134

auto fuzzingOperation = variableOperation.second;

135

auto fuzzingOperation = variableOperation.second;

135

136

fuzzingOperation->execute(variable, m_VariableController, m_Properties);

137

fuzzingOperation->execute(variableState, m_VariableController, m_Properties);

137

QTest::qWait(operationDelay());

138

QTest::qWait(operationDelay());

138

139

// Updates variable pool with the new state of the variable after operation

140

m_VariablesPool[variableId] = variable;

141

}

140

}

142

else {

141

else {

143

qCInfo(LOG_TestAmdaFuzzing())

142

qCInfo(LOG_TestAmdaFuzzing())

	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

             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
+            #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QLoggingCategory>
             using VariablesOperations = std::vector<VariableOperation>;
             using WeightedOperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, Weight>;
-            using VariablesPool = std::map<VariableId, std::shared_ptr<Variable> >;
+            using VariablesPool = std::map<VariableId, VariableState>;
             // ///////// //
             // Constants //
                 for (const auto &variablesPoolEntry : variablesPool) {
                     auto variableId = variablesPoolEntry.first;
-                    auto variable = variablesPoolEntry.second;
+                    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(variable)) {
+                        if (operation->canExecute(variableState)) {
                             result.push_back({variableId, operation});
                             weights.push_back(weight);
                         }
                 {
                     // Inits variables pool: at init, all variables are null
                     for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {
-                        m_VariablesPool[variableId] = nullptr;
+                        m_VariablesPool[variableId] = VariableState{};
                     }
                 }
                                 = RandomGenerator::instance().randomChoice(variableOperations, weights);
                             auto variableId = variableOperation.first;
-                            auto variable = m_VariablesPool.at(variableId);
+                            auto &variableState = m_VariablesPool.at(variableId);
                             auto fuzzingOperation = variableOperation.second;
-                            fuzzingOperation->execute(variable, m_VariableController, m_Properties);
+                            fuzzingOperation->execute(variableState, m_VariableController, m_Properties);
                             QTest::qWait(operationDelay());
-                            // Updates variable pool with the new state of the variable after operation
-                            m_VariablesPool[variableId] = variable;
                         }
                         else {
                             qCInfo(LOG_TestAmdaFuzzing())