##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Merge pull request 393 from SciQLop-fork develop...
leroux -
r1222:a28635845636 merge
parent child
Show More
Side by Side Unified
Context file:
r1222:a28635845636 Loading diff...:
Show file before | Show file after | Hide comments
@@ -0,0 +1,38
1 #ifndef SCIQLOP_SIGNALWAITER_H
2 #define SCIQLOP_SIGNALWAITER_H
3
4 #include "CoreGlobal.h"
5
6 #include <QEventLoop>
7
8 /**
9 * Class for synchronously waiting for the reception of a signal. The signal to wait is passed to
10 * the construction of the object. When starting the wait, a timeout can be set to exit if the
11 * signal has not been sent
12 */
13 class SCIQLOP_CORE_EXPORT SignalWaiter : public QObject {
14 Q_OBJECT
15 public:
16 /**
17 * Ctor
18 * @param object the sender of the signal
19 * @param signal the signal to listen
20 */
21 explicit SignalWaiter(QObject &sender, const char *signal);
22
23 /**
24 * Starts the signal and leaves after the signal has been received, or after the timeout
25 * @param timeout the timeout set (if 0, uses a default timeout)
26 * @return true if the signal was sent, false if the timeout occured
27 */
28 bool wait(int timeout);
29
30 private:
31 bool m_Timeout;
32 QEventLoop m_EventLoop;
33
34 private slots:
35 void timeout();
36 };
37
38 #endif // SCIQLOP_SIGNALWAITER_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,36
1 #include "Common/SignalWaiter.h"
2
3 #include <QTimer>
4
5 namespace {
6
7 const auto DEFAULT_TIMEOUT = 30000;
8
9 } // namespace
10
11 SignalWaiter::SignalWaiter(QObject &sender, const char *signal) : m_Timeout{false}
12 {
13 connect(&sender, signal, &m_EventLoop, SLOT(quit()));
14 }
15
16 bool SignalWaiter::wait(int timeout)
17 {
18 if (timeout == 0) {
19 timeout = DEFAULT_TIMEOUT;
20 }
21
22 QTimer timer{};
23 timer.setInterval(timeout);
24 timer.start();
25 connect(&timer, &QTimer::timeout, this, &SignalWaiter::timeout);
26
27 m_EventLoop.exec();
28
29 return !m_Timeout;
30 }
31
32 void SignalWaiter::timeout()
33 {
34 m_Timeout = true;
35 m_EventLoop.quit();
36 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,109
1 #include "FuzzingDefs.h"
2
3 const QString ACQUISITION_TIMEOUT_PROPERTY = QStringLiteral("acquisitionTimeout");
4 const QString NB_MAX_OPERATIONS_PROPERTY = QStringLiteral("component");
5 const QString NB_MAX_SYNC_GROUPS_PROPERTY = QStringLiteral("nbSyncGroups");
6 const QString NB_MAX_VARIABLES_PROPERTY = QStringLiteral("nbMaxVariables");
7 const QString AVAILABLE_OPERATIONS_PROPERTY = QStringLiteral("availableOperations");
8 const QString CACHE_TOLERANCE_PROPERTY = QStringLiteral("cacheTolerance");
9 const QString INITIAL_RANGE_PROPERTY = QStringLiteral("initialRange");
10 const QString MAX_RANGE_PROPERTY = QStringLiteral("maxRange");
11 const QString METADATA_POOL_PROPERTY = QStringLiteral("metadataPool");
12 const QString PROVIDER_PROPERTY = QStringLiteral("provider");
13 const QString OPERATION_DELAY_BOUNDS_PROPERTY = QStringLiteral("operationDelays");
14 const QString VALIDATORS_PROPERTY = QStringLiteral("validators");
15 const QString VALIDATION_FREQUENCY_BOUNDS_PROPERTY = QStringLiteral("validationFrequencyBounds");
16
17 // //////////// //
18 // FuzzingState //
19 // //////////// //
20
21 const SyncGroup &FuzzingState::syncGroup(SyncGroupId id) const
22 {
23 return m_SyncGroupsPool.at(id);
24 }
25
26 SyncGroup &FuzzingState::syncGroup(SyncGroupId id)
27 {
28 return m_SyncGroupsPool.at(id);
29 }
30
31 const VariableState &FuzzingState::variableState(VariableId id) const
32 {
33 return m_VariablesPool.at(id);
34 }
35
36 VariableState &FuzzingState::variableState(VariableId id)
37 {
38 return m_VariablesPool.at(id);
39 }
40
41 SyncGroupId FuzzingState::syncGroupId(VariableId variableId) const
42 {
43 auto end = m_SyncGroupsPool.cend();
44 auto it
45 = std::find_if(m_SyncGroupsPool.cbegin(), end, [&variableId](const auto &syncGroupEntry) {
46 const auto &syncGroup = syncGroupEntry.second;
47 return syncGroup.m_Variables.find(variableId) != syncGroup.m_Variables.end();
48 });
49
50 return it != end ? it->first : SyncGroupId{};
51 }
52
53 std::vector<SyncGroupId> FuzzingState::syncGroupsIds() const
54 {
55 std::vector<SyncGroupId> result{};
56
57 for (const auto &entry : m_SyncGroupsPool) {
58 result.push_back(entry.first);
59 }
60
61 return result;
62 }
63
64 void FuzzingState::synchronizeVariable(VariableId variableId, SyncGroupId syncGroupId)
65 {
66 if (syncGroupId.isNull()) {
67 return;
68 }
69
70 // Registers variable into sync group: if it's the first variable, sets the variable range as
71 // the sync group range
72 auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
73 syncGroup.m_Variables.insert(variableId);
74 if (syncGroup.m_Variables.size() == 1) {
75 auto &variableState = m_VariablesPool.at(variableId);
76 syncGroup.m_Range = variableState.m_Range;
77 }
78 }
79
80 void FuzzingState::desynchronizeVariable(VariableId variableId, SyncGroupId syncGroupId)
81 {
82 if (syncGroupId.isNull()) {
83 return;
84 }
85
86 // Unregisters variable from sync group: if there is no more variable in the group, resets the
87 // range
88 auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
89 syncGroup.m_Variables.erase(variableId);
90 if (syncGroup.m_Variables.empty()) {
91 syncGroup.m_Range = INVALID_RANGE;
92 }
93 }
94
95 void FuzzingState::updateRanges(VariableId variableId, const SqpRange &newRange)
96 {
97 auto syncGroupId = this->syncGroupId(variableId);
98
99 // Retrieves the variables to update:
100 // - if the variable is synchronized to others, updates all synchronized variables
101 // - otherwise, updates only the variable
102 auto variablesToUpdate = syncGroupId.isNull() ? std::set<VariableId>{variableId}
103 : m_SyncGroupsPool.at(syncGroupId).m_Variables;
104
105 // Sets new range
106 for (const auto &variableId : variablesToUpdate) {
107 m_VariablesPool.at(variableId).m_Range = newRange;
108 }
109 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,128
1 #ifndef SCIQLOP_FUZZINGDEFS_H
2 #define SCIQLOP_FUZZINGDEFS_H
3
4 #include <Data/SqpRange.h>
5
6 #include <QString>
7 #include <QUuid>
8 #include <QVariantHash>
9
10 #include <memory>
11 #include <set>
12
13 // /////// //
14 // Aliases //
15 // /////// //
16
17 using MetadataPool = std::vector<QVariantHash>;
18 Q_DECLARE_METATYPE(MetadataPool)
19
20 using Properties = QVariantHash;
21
22 // ///////// //
23 // Constants //
24 // ///////// //
25
26 /// Timeout set for data acquisition for an operation (in ms)
27 extern const QString ACQUISITION_TIMEOUT_PROPERTY;
28
29 /// Max number of operations to generate
30 extern const QString NB_MAX_OPERATIONS_PROPERTY;
31
32 /// Max number of sync groups to create through operations
33 extern const QString NB_MAX_SYNC_GROUPS_PROPERTY;
34
35 /// Max number of variables to manipulate through operations
36 extern const QString NB_MAX_VARIABLES_PROPERTY;
37
38 /// Set of operations available for the test
39 extern const QString AVAILABLE_OPERATIONS_PROPERTY;
40
41 /// Tolerance used for variable's cache (in ratio)
42 extern const QString CACHE_TOLERANCE_PROPERTY;
43
44 /// Range with which the timecontroller is initialized
45 extern const QString INITIAL_RANGE_PROPERTY;
46
47 /// Max range that an operation can reach
48 extern const QString MAX_RANGE_PROPERTY;
49
50 /// Set of metadata that can be associated to a variable
51 extern const QString METADATA_POOL_PROPERTY;
52
53 /// Provider used to retrieve data
54 extern const QString PROVIDER_PROPERTY;
55
56 /// Min/max times left for an operation to execute
57 extern const QString OPERATION_DELAY_BOUNDS_PROPERTY;
58
59 /// Validators used to validate an operation
60 extern const QString VALIDATORS_PROPERTY;
61
62 /// Min/max number of operations to execute before calling validation of the current test's state
63 extern const QString VALIDATION_FREQUENCY_BOUNDS_PROPERTY;
64
65 // /////// //
66 // Structs //
67 // /////// //
68
69 class Variable;
70 struct VariableState {
71 std::shared_ptr<Variable> m_Variable{nullptr};
72 SqpRange m_Range{INVALID_RANGE};
73 };
74
75 using VariableId = int;
76 using VariablesPool = std::map<VariableId, VariableState>;
77
78 /**
79 * Defines a synchronization group for a fuzzing state. A group reports the variables synchronized
80 * with each other, and the current range of the group (i.e. range of the last synchronized variable
81 * that has been moved)
82 */
83 struct SyncGroup {
84 std::set<VariableId> m_Variables{};
85 SqpRange m_Range{INVALID_RANGE};
86 };
87
88 using SyncGroupId = QUuid;
89 using SyncGroupsPool = std::map<SyncGroupId, SyncGroup>;
90
91 /**
92 * Defines a current state during a fuzzing state. It contains all the variables manipulated during
93 * the test, as well as the synchronization status of these variables.
94 */
95 struct FuzzingState {
96 const SyncGroup &syncGroup(SyncGroupId id) const;
97 SyncGroup &syncGroup(SyncGroupId id);
98
99 const VariableState &variableState(VariableId id) const;
100 VariableState &variableState(VariableId id);
101
102 /// @return the identifier of the synchronization group in which the variable passed in
103 /// parameter is located. If the variable is not in any group, returns an invalid identifier
104 SyncGroupId syncGroupId(VariableId variableId) const;
105
106 /// @return the set of synchronization group identifiers
107 std::vector<SyncGroupId> syncGroupsIds() const;
108
109 /// Updates fuzzing state according to a variable synchronization
110 /// @param variableId the variable that is synchronized
111 /// @param syncGroupId the synchronization group
112 void synchronizeVariable(VariableId variableId, SyncGroupId syncGroupId);
113
114 /// Updates fuzzing state according to a variable desynchronization
115 /// @param variableId the variable that is desynchronized
116 /// @param syncGroupId the synchronization group from which to remove the variable
117 void desynchronizeVariable(VariableId variableId, SyncGroupId syncGroupId);
118
119 /// Updates the range of a variable and all variables to which it is synchronized
120 /// @param the variable for which to affect the range
121 /// @param the range to affect
122 void updateRanges(VariableId variableId, const SqpRange &newRange);
123
124 VariablesPool m_VariablesPool;
125 SyncGroupsPool m_SyncGroupsPool;
126 };
127
128 #endif // SCIQLOP_FUZZINGDEFS_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,265
1 #include "FuzzingOperations.h"
2 #include "FuzzingUtils.h"
3
4 #include <Data/IDataProvider.h>
5
6 #include <Variable/Variable.h>
7 #include <Variable/VariableController.h>
8
9 #include <QUuid>
10
11 #include <functional>
12
13 Q_LOGGING_CATEGORY(LOG_FuzzingOperations, "FuzzingOperations")
14
15 namespace {
16
17 struct CreateOperation : public IFuzzingOperation {
18 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
19 {
20 // A variable can be created only if it doesn't exist yet
21 return fuzzingState.variableState(variableId).m_Variable == nullptr;
22 }
23
24 void execute(VariableId variableId, FuzzingState &fuzzingState,
25 VariableController &variableController,
26 const Properties &properties) const override
27 {
28 // Retrieves metadata pool from properties, and choose one of the metadata entries to
29 // associate it with the variable
30 auto metaDataPool = properties.value(METADATA_POOL_PROPERTY).value<MetadataPool>();
31 auto variableMetadata = RandomGenerator::instance().randomChoice(metaDataPool);
32
33 // Retrieves provider
34 auto variableProvider
35 = properties.value(PROVIDER_PROPERTY).value<std::shared_ptr<IDataProvider> >();
36
37 auto variableName = QString{"Var_%1"}.arg(QUuid::createUuid().toString());
38 qCInfo(LOG_FuzzingOperations()).noquote()
39 << "Creating variable" << variableName << "(metadata:" << variableMetadata << ")...";
40
41 auto newVariable
42 = variableController.createVariable(variableName, variableMetadata, variableProvider);
43
44 // Updates variable's state
45 auto &variableState = fuzzingState.variableState(variableId);
46 variableState.m_Range = properties.value(INITIAL_RANGE_PROPERTY).value<SqpRange>();
47 std::swap(variableState.m_Variable, newVariable);
48 }
49 };
50
51 struct DeleteOperation : public IFuzzingOperation {
52 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
53 {
54 // A variable can be delete only if it exists
55 return fuzzingState.variableState(variableId).m_Variable != nullptr;
56 }
57
58 void execute(VariableId variableId, FuzzingState &fuzzingState,
59 VariableController &variableController, const Properties &) const override
60 {
61 auto &variableState = fuzzingState.variableState(variableId);
62
63 qCInfo(LOG_FuzzingOperations()).noquote()
64 << "Deleting variable" << variableState.m_Variable->name() << "...";
65 variableController.deleteVariable(variableState.m_Variable);
66
67 // Updates variable's state
68 variableState.m_Range = INVALID_RANGE;
69 variableState.m_Variable = nullptr;
70
71 // Desynchronizes the variable if it was in a sync group
72 auto syncGroupId = fuzzingState.syncGroupId(variableId);
73 fuzzingState.desynchronizeVariable(variableId, syncGroupId);
74 }
75 };
76
77 /**
78 * Defines a move operation through a range.
79 *
80 * A move operation is determined by three functions:
81 * - Two 'move' functions, used to indicate in which direction the beginning and the end of a range
82 * are going during the operation. These functions will be:
83 * -- {<- / <-} for pan left
84 * -- {-> / ->} for pan right
85 * -- {-> / <-} for zoom in
86 * -- {<- / ->} for zoom out
87 * - One 'max move' functions, used to compute the max delta at which the operation can move a
88 * range, according to a max range. For exemple, for a range of {1, 5} and a max range of {0, 10},
89 * max deltas will be:
90 * -- {0, 4} for pan left
91 * -- {6, 10} for pan right
92 * -- {3, 3} for zoom in
93 * -- {0, 6} for zoom out (same spacing left and right)
94 */
95 struct MoveOperation : public IFuzzingOperation {
96 using MoveFunction = std::function<double(double currentValue, double maxValue)>;
97 using MaxMoveFunction = std::function<double(const SqpRange &range, const SqpRange &maxRange)>;
98
99 explicit MoveOperation(MoveFunction rangeStartMoveFun, MoveFunction rangeEndMoveFun,
100 MaxMoveFunction maxMoveFun,
101 const QString &label = QStringLiteral("Move operation"))
102 : m_RangeStartMoveFun{std::move(rangeStartMoveFun)},
103 m_RangeEndMoveFun{std::move(rangeEndMoveFun)},
104 m_MaxMoveFun{std::move(maxMoveFun)},
105 m_Label{label}
106 {
107 }
108
109 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
110 {
111 return fuzzingState.variableState(variableId).m_Variable != nullptr;
112 }
113
114 void execute(VariableId variableId, FuzzingState &fuzzingState,
115 VariableController &variableController,
116 const Properties &properties) const override
117 {
118 auto &variableState = fuzzingState.variableState(variableId);
119 auto variable = variableState.m_Variable;
120
121 // Gets the max range defined
122 auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
123 .value<SqpRange>();
124 auto variableRange = variableState.m_Range;
125
126 if (maxRange == INVALID_RANGE || variableRange.m_TStart < maxRange.m_TStart
127 || variableRange.m_TEnd > maxRange.m_TEnd) {
128 qCWarning(LOG_FuzzingOperations()) << "Can't execute operation: invalid max range";
129 return;
130 }
131
132 // Computes the max delta at which the variable can move, up to the limits of the max range
133 auto deltaMax = m_MaxMoveFun(variableRange, maxRange);
134
135 // Generates random delta that will be used to move variable
136 auto delta = RandomGenerator::instance().generateDouble(0, deltaMax);
137
138 // Moves variable to its new range
139 auto isSynchronized = !fuzzingState.syncGroupId(variableId).isNull();
140 auto newVariableRange = SqpRange{m_RangeStartMoveFun(variableRange.m_TStart, delta),
141 m_RangeEndMoveFun(variableRange.m_TEnd, delta)};
142 qCInfo(LOG_FuzzingOperations()).noquote()
143 << "Performing" << m_Label << "on" << variable->name() << "(from" << variableRange
144 << "to" << newVariableRange << ")...";
145 variableController.onRequestDataLoading({variable}, newVariableRange, isSynchronized);
146
147 // Updates state
148 fuzzingState.updateRanges(variableId, newVariableRange);
149 }
150
151 MoveFunction m_RangeStartMoveFun;
152 MoveFunction m_RangeEndMoveFun;
153 MaxMoveFunction m_MaxMoveFun;
154 QString m_Label;
155 };
156
157 struct SynchronizeOperation : public IFuzzingOperation {
158 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
159 {
160 auto variable = fuzzingState.variableState(variableId).m_Variable;
161 return variable != nullptr && !fuzzingState.m_SyncGroupsPool.empty()
162 && fuzzingState.syncGroupId(variableId).isNull();
163 }
164
165 void execute(VariableId variableId, FuzzingState &fuzzingState,
166 VariableController &variableController, const Properties &) const override
167 {
168 auto &variableState = fuzzingState.variableState(variableId);
169
170 // Chooses a random synchronization group and adds the variable into sync group
171 auto syncGroupId = RandomGenerator::instance().randomChoice(fuzzingState.syncGroupsIds());
172 qCInfo(LOG_FuzzingOperations()).noquote()
173 << "Adding" << variableState.m_Variable->name() << "into synchronization group"
174 << syncGroupId << "...";
175 variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
176
177 // Updates state
178 fuzzingState.synchronizeVariable(variableId, syncGroupId);
179 }
180 };
181
182 struct DesynchronizeOperation : public IFuzzingOperation {
183 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
184 {
185 auto variable = fuzzingState.variableState(variableId).m_Variable;
186 return variable != nullptr && !fuzzingState.syncGroupId(variableId).isNull();
187 }
188
189 void execute(VariableId variableId, FuzzingState &fuzzingState,
190 VariableController &variableController, const Properties &) const override
191 {
192 auto &variableState = fuzzingState.variableState(variableId);
193
194 // Gets the sync group of the variable
195 auto syncGroupId = fuzzingState.syncGroupId(variableId);
196
197 qCInfo(LOG_FuzzingOperations()).noquote()
198 << "Removing" << variableState.m_Variable->name() << "from synchronization group"
199 << syncGroupId << "...";
200 variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
201
202 // Updates state
203 fuzzingState.desynchronizeVariable(variableId, syncGroupId);
204 }
205 };
206
207 struct UnknownOperation : public IFuzzingOperation {
208 bool canExecute(VariableId, const FuzzingState &) const override { return false; }
209
210 void execute(VariableId, FuzzingState &, VariableController &,
211 const Properties &) const override
212 {
213 }
214 };
215
216 } // namespace
217
218 std::unique_ptr<IFuzzingOperation> FuzzingOperationFactory::create(FuzzingOperationType type)
219 {
220 switch (type) {
221 case FuzzingOperationType::CREATE:
222 return std::make_unique<CreateOperation>();
223 case FuzzingOperationType::DELETE:
224 return std::make_unique<DeleteOperation>();
225 case FuzzingOperationType::PAN_LEFT:
226 return std::make_unique<MoveOperation>(
227 std::minus<double>(), std::minus<double>(),
228 [](const SqpRange &range, const SqpRange &maxRange) {
229 return range.m_TStart - maxRange.m_TStart;
230 },
231 QStringLiteral("Pan left operation"));
232 case FuzzingOperationType::PAN_RIGHT:
233 return std::make_unique<MoveOperation>(
234 std::plus<double>(), std::plus<double>(),
235 [](const SqpRange &range, const SqpRange &maxRange) {
236 return maxRange.m_TEnd - range.m_TEnd;
237 },
238 QStringLiteral("Pan right operation"));
239 case FuzzingOperationType::ZOOM_IN:
240 return std::make_unique<MoveOperation>(
241 std::plus<double>(), std::minus<double>(),
242 [](const SqpRange &range, const SqpRange &maxRange) {
243 Q_UNUSED(maxRange)
244 return range.m_TEnd - (range.m_TStart + range.m_TEnd) / 2.;
245 },
246 QStringLiteral("Zoom in operation"));
247 case FuzzingOperationType::ZOOM_OUT:
248 return std::make_unique<MoveOperation>(
249 std::minus<double>(), std::plus<double>(),
250 [](const SqpRange &range, const SqpRange &maxRange) {
251 return std::min(range.m_TStart - maxRange.m_TStart,
252 maxRange.m_TEnd - range.m_TEnd);
253 },
254 QStringLiteral("Zoom out operation"));
255 case FuzzingOperationType::SYNCHRONIZE:
256 return std::make_unique<SynchronizeOperation>();
257 case FuzzingOperationType::DESYNCHRONIZE:
258 return std::make_unique<DesynchronizeOperation>();
259 default:
260 // Default case returns unknown operation
261 break;
262 }
263
264 return std::make_unique<UnknownOperation>();
265 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,56
1 #ifndef SCIQLOP_FUZZINGOPERATIONS_H
2 #define SCIQLOP_FUZZINGOPERATIONS_H
3
4 #include "FuzzingDefs.h"
5
6 #include <memory>
7 #include <set>
8
9 #include <QLoggingCategory>
10 #include <QMetaType>
11
12 Q_DECLARE_LOGGING_CATEGORY(LOG_FuzzingOperations)
13
14 class VariableController;
15
16 /**
17 * Enumeration of types of existing fuzzing operations
18 */
19 enum class FuzzingOperationType {
20 CREATE,
21 DELETE,
22 PAN_LEFT,
23 PAN_RIGHT,
24 ZOOM_IN,
25 ZOOM_OUT,
26 SYNCHRONIZE,
27 DESYNCHRONIZE
28 };
29
30 /// Interface that represents an operation that can be executed during a fuzzing test
31 struct IFuzzingOperation {
32 virtual ~IFuzzingOperation() noexcept = default;
33
34 /// Checks if the operation can be executed according to the current test's state for the
35 /// variable passed in parameter
36 virtual bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const = 0;
37 /// Executes the operation on the variable for which its identifier is passed in parameter
38 /// @param variableId the variable identifier
39 /// @param fuzzingState the current test's state on which to find the variable and execute the
40 /// operation
41 /// @param variableController the controller associated to the operation
42 /// @param properties properties that can be used to configure the operation
43 /// @remarks fuzzingState is passed as a reference because, according to the operation, it can
44 /// be modified (in/out parameter)
45 virtual void execute(VariableId variableId, FuzzingState &fuzzingState,
46 VariableController &variableController,
47 const Properties &properties = {}) const = 0;
48 };
49
50 /// Factory of @sa IFuzzingOperation
51 struct FuzzingOperationFactory {
52 /// Creates a fuzzing operation from a type
53 static std::unique_ptr<IFuzzingOperation> create(FuzzingOperationType type);
54 };
55
56 #endif // SCIQLOP_FUZZINGOPERATIONS_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,25
1 #include "FuzzingUtils.h"
2
3 RandomGenerator &RandomGenerator::instance()
4 {
5 static auto instance = RandomGenerator();
6 return instance;
7 }
8
9 double RandomGenerator::generateDouble(double min, double max)
10 {
11 std::uniform_real_distribution<double> dist{min, max};
12 return dist(m_Mt);
13 }
14
15 int RandomGenerator::generateInt(int min, int max)
16 {
17 std::uniform_int_distribution<int> dist{min, max};
18 return dist(m_Mt);
19 }
20
21 RandomGenerator::RandomGenerator()
22 {
23 std::random_device rd{};
24 m_Mt = std::mt19937{rd()};
25 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,63
1 #ifndef SCIQLOP_FUZZINGUTILS_H
2 #define SCIQLOP_FUZZINGUTILS_H
3
4 #include <algorithm>
5 #include <random>
6
7 /**
8 * Class that proposes random utility methods
9 */
10 class RandomGenerator {
11 public:
12 /// @return the unique instance of the random generator
13 static RandomGenerator &instance();
14
15 /// Generates a random double between [min, max]
16 double generateDouble(double min, double max);
17 /// Generates a random int between [min, max]
18 int generateInt(int min, int max);
19
20 /**
21 * Returns a random element among the elements of a container. An item may be more likely to be
22 * selected if it has an associated weight greater than other items
23 * @param container the container from which to retrieve an element
24 * @param weights the weight associated to each element of the container. The vector must have
25 * the same size of the container for the weights to be effective
26 * @param nbDraws the number of random draws to perform
27 * @return the random element retrieved, an element built by default if the container is empty
28 */
29 template <typename T, typename ValueType = typename T::value_type>
30 ValueType randomChoice(const T &container, const std::vector<double> &weights = {});
31
32 private:
33 std::mt19937 m_Mt;
34
35 explicit RandomGenerator();
36 };
37
38 template <typename T, typename ValueType>
39 ValueType RandomGenerator::randomChoice(const T &container, const std::vector<double> &weights)
40 {
41 if (container.empty()) {
42 return ValueType{};
43 }
44
45 // Generates weights for each element: if the weights passed in parameter are malformed (the
46 // number of weights defined is inconsistent with the number of elements in the container, or
47 // all weights are zero), default weights are used
48 auto nbIndexes = container.size();
49 std::vector<double> indexWeights(nbIndexes);
50 if (weights.size() != nbIndexes || std::all_of(weights.cbegin(), weights.cend(),
51 [](const auto &val) { return val == 0.; })) {
52 std::fill(indexWeights.begin(), indexWeights.end(), 1.);
53 }
54 else {
55 std::copy(weights.begin(), weights.end(), indexWeights.begin());
56 }
57
58 // Performs a draw to determine the index to return
59 std::discrete_distribution<> d{indexWeights.cbegin(), indexWeights.cend()};
60 return container.at(d(m_Mt));
61 }
62
63 #endif // SCIQLOP_FUZZINGUTILS
Show file before | Show file after | Hide comments
@@ -0,0 +1,228
1 #include "FuzzingValidators.h"
2 #include "FuzzingDefs.h"
3
4 #include <Data/DataSeries.h>
5 #include <Variable/Variable.h>
6
7 #include <QTest>
8
9 #include <functional>
10
11 Q_LOGGING_CATEGORY(LOG_FuzzingValidators, "FuzzingValidators")
12
13 namespace {
14
15 // ////////////// //
16 // DATA VALIDATOR //
17 // ////////////// //
18
19 /// Singleton used to validate data of a variable
20 class DataValidatorHelper {
21 public:
22 /// @return the single instance of the helper
23 static DataValidatorHelper &instance();
24 virtual ~DataValidatorHelper() noexcept = default;
25
26 virtual void validate(const VariableState &variableState) const = 0;
27 };
28
29 /**
30 * Default implementation of @sa DataValidatorHelper
31 */
32 class DefaultDataValidatorHelper : public DataValidatorHelper {
33 public:
34 void validate(const VariableState &variableState) const override
35 {
36 Q_UNUSED(variableState);
37 qCWarning(LOG_FuzzingValidators()).noquote() << "Checking variable's data... WARN: no data "
38 "verification is available for this server";
39 }
40 };
41
42 /// Data resolution in local server's files
43 const auto LOCALHOST_SERVER_RESOLUTION = 4;
44 /// Reference value used to generate the data on the local server (a value is the number of seconds
45 /// between the data date and this reference date)
46 const auto LOCALHOST_REFERENCE_VALUE
47 = DateUtils::secondsSinceEpoch(QDateTime{QDate{2000, 1, 1}, QTime{}, Qt::UTC});
48
49 /**
50 * Implementation of @sa DataValidatorHelper for the local AMDA server
51 */
52 class LocalhostServerDataValidatorHelper : public DataValidatorHelper {
53 public:
54 void validate(const VariableState &variableState) const override
55 {
56 // Don't check data for null variable
57 if (!variableState.m_Variable || variableState.m_Range == INVALID_RANGE) {
58 return;
59 }
60
61 auto message = "Checking variable's data...";
62 auto toDateString = [](double value) { return DateUtils::dateTime(value).toString(); };
63
64 // Checks that data are defined
65 auto variableDataSeries = variableState.m_Variable->dataSeries();
66 if (variableDataSeries == nullptr && variableState.m_Range != INVALID_RANGE) {
67 qCInfo(LOG_FuzzingValidators()).noquote()
68 << message << "FAIL: the variable has no data while a range is defined";
69 QFAIL("");
70 }
71
72 auto dataIts = variableDataSeries->xAxisRange(variableState.m_Range.m_TStart,
73 variableState.m_Range.m_TEnd);
74
75 // Checks that the data are well defined in the range:
76 // - there is at least one data
77 // - the data are consistent (no data holes)
78 if (std::distance(dataIts.first, dataIts.second) == 0) {
79 qCInfo(LOG_FuzzingValidators()).noquote()
80 << message << "FAIL: the variable has no data";
81 QFAIL("");
82 }
83
84 auto firstXAxisData = dataIts.first->x();
85 auto lastXAxisData = (dataIts.second - 1)->x();
86
87 if (std::abs(firstXAxisData - variableState.m_Range.m_TStart) > LOCALHOST_SERVER_RESOLUTION
88 || std::abs(lastXAxisData - variableState.m_Range.m_TEnd)
89 > LOCALHOST_SERVER_RESOLUTION) {
90 qCInfo(LOG_FuzzingValidators()).noquote()
91 << message << "FAIL: the data in the defined range are inconsistent (data hole "
92 "found at the beginning or the end)";
93 QFAIL("");
94 }
95
96 auto dataHoleIt = std::adjacent_find(
97 dataIts.first, dataIts.second, [](const auto &it1, const auto &it2) {
98 /// @todo: validate resolution
99 return std::abs(it1.x() - it2.x()) > 2 * (LOCALHOST_SERVER_RESOLUTION - 1);
100 });
101
102 if (dataHoleIt != dataIts.second) {
103 qCInfo(LOG_FuzzingValidators()).noquote()
104 << message << "FAIL: the data in the defined range are inconsistent (data hole "
105 "found between times "
106 << toDateString(dataHoleIt->x()) << "and " << toDateString((dataHoleIt + 1)->x())
107 << ")";
108 QFAIL("");
109 }
110
111 // Checks values
112 auto dataIndex = 0;
113 for (auto dataIt = dataIts.first; dataIt != dataIts.second; ++dataIt, ++dataIndex) {
114 auto xAxisData = dataIt->x();
115 auto valuesData = dataIt->values();
116 for (auto valueIndex = 0, valueEnd = valuesData.size(); valueIndex < valueEnd;
117 ++valueIndex) {
118 auto value = valuesData.at(valueIndex);
119 auto expectedValue = xAxisData + valueIndex * LOCALHOST_SERVER_RESOLUTION
120 - LOCALHOST_REFERENCE_VALUE;
121
122 if (value != expectedValue) {
123 qCInfo(LOG_FuzzingValidators()).noquote()
124 << message << "FAIL: incorrect value data at time"
125 << toDateString(xAxisData) << ", index" << valueIndex << "(found:" << value
126 << ", expected:" << expectedValue << ")";
127 QFAIL("");
128 }
129 }
130 }
131
132 // At this step validation is OK
133 qCInfo(LOG_FuzzingValidators()).noquote() << message << "OK";
134 }
135 };
136
137 /// Creates the @sa DataValidatorHelper according to the server passed in parameter
138 std::unique_ptr<DataValidatorHelper> createDataValidatorInstance(const QString &server)
139 {
140 if (server == QString{"localhost"}) {
141 return std::make_unique<LocalhostServerDataValidatorHelper>();
142 }
143 else {
144 return std::make_unique<DefaultDataValidatorHelper>();
145 }
146 }
147
148 DataValidatorHelper &DataValidatorHelper::instance()
149 {
150 // Creates instance depending on the SCIQLOP_AMDA_SERVER value at compile time
151 static auto instance = createDataValidatorInstance(SCIQLOP_AMDA_SERVER);
152 return *instance;
153 }
154
155 // /////////////// //
156 // RANGE VALIDATOR //
157 // /////////////// //
158
159 /**
160 * Checks that a range of a variable matches the expected range passed as a parameter
161 * @param variable the variable for which to check the range
162 * @param expectedRange the expected range
163 * @param getVariableRangeFun the function to retrieve the range from the variable
164 * @remarks if the variable is null, checks that the expected range is the invalid range
165 */
166 void validateRange(std::shared_ptr<Variable> variable, const SqpRange &expectedRange,
167 std::function<SqpRange(const Variable &)> getVariableRangeFun)
168 {
169 auto compare = [](const auto &range, const auto &expectedRange, const auto &message) {
170 if (range == expectedRange) {
171 qCInfo(LOG_FuzzingValidators()).noquote() << message << "OK";
172 }
173 else {
174 qCInfo(LOG_FuzzingValidators()).noquote()
175 << message << "FAIL (current range:" << range
176 << ", expected range:" << expectedRange << ")";
177 QFAIL("");
178 }
179 };
180
181 if (variable) {
182 compare(getVariableRangeFun(*variable), expectedRange, "Checking variable's range...");
183 }
184 else {
185 compare(INVALID_RANGE, expectedRange, "Checking that there is no range set...");
186 }
187 }
188
189 /**
190 * Default implementation of @sa IFuzzingValidator. This validator takes as parameter of its
191 * construction a function of validation which is called in the validate() method
192 */
193 class FuzzingValidator : public IFuzzingValidator {
194 public:
195 /// Signature of a validation function
196 using ValidationFunction = std::function<void(const VariableState &variableState)>;
197
198 explicit FuzzingValidator(ValidationFunction fun) : m_Fun(std::move(fun)) {}
199
200 void validate(const VariableState &variableState) const override { m_Fun(variableState); }
201
202 private:
203 ValidationFunction m_Fun;
204 };
205
206 } // namespace
207
208 std::unique_ptr<IFuzzingValidator> FuzzingValidatorFactory::create(FuzzingValidatorType type)
209 {
210 switch (type) {
211 case FuzzingValidatorType::DATA:
212 return std::make_unique<FuzzingValidator>([](const VariableState &variableState) {
213 DataValidatorHelper::instance().validate(variableState);
214 });
215 case FuzzingValidatorType::RANGE:
216 return std::make_unique<FuzzingValidator>([](const VariableState &variableState) {
217 auto getVariableRange = [](const Variable &variable) { return variable.range(); };
218 validateRange(variableState.m_Variable, variableState.m_Range, getVariableRange);
219 });
220 default:
221 // Default case returns invalid validator
222 break;
223 }
224
225 // Invalid validator
226 return std::make_unique<FuzzingValidator>(
227 [](const VariableState &) { QFAIL("Invalid validator"); });
228 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,40
1 #ifndef SCIQLOP_FUZZINGVALIDATORS_H
2 #define SCIQLOP_FUZZINGVALIDATORS_H
3
4 #include <memory>
5 #include <set>
6
7 #include <QLoggingCategory>
8 #include <QMetaType>
9
10 Q_DECLARE_LOGGING_CATEGORY(LOG_FuzzingValidators)
11
12 class VariableState;
13
14 /// Types of validators that can be defined
15 enum class FuzzingValidatorType {
16 DATA, ///< Validates variable's data
17 RANGE ///< Validates variable's range
18 };
19
20 /**
21 * Struct that represents a validator. A validator checks if the state of a variable is valid at the
22 * moment it is called during a fuzzing test
23 */
24 struct IFuzzingValidator {
25 virtual ~IFuzzingValidator() noexcept = default;
26
27 /// Validates the variable's state passed in parameter
28 virtual void validate(const VariableState &variableState) const = 0;
29 };
30
31 /// Factory of @sa IFuzzingValidator
32 struct FuzzingValidatorFactory {
33 /// Creates a validator according to the type passed in parameter
34 static std::unique_ptr<IFuzzingValidator> create(FuzzingValidatorType type);
35 };
36
37 using ValidatorsTypes = std::vector<FuzzingValidatorType>;
38 Q_DECLARE_METATYPE(ValidatorsTypes)
39
40 #endif // SCIQLOP_FUZZINGVALIDATORS_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,391
1 #include "FuzzingDefs.h"
2 #include "FuzzingOperations.h"
3 #include "FuzzingUtils.h"
4 #include "FuzzingValidators.h"
5
6 #include "AmdaProvider.h"
7
8 #include <Common/SignalWaiter.h>
9 #include <Network/NetworkController.h>
10 #include <Settings/SqpSettingsDefs.h>
11 #include <SqpApplication.h>
12 #include <Time/TimeController.h>
13 #include <Variable/Variable.h>
14 #include <Variable/VariableController.h>
15
16 #include <QLoggingCategory>
17 #include <QObject>
18 #include <QtTest>
19
20 #include <memory>
21
22 Q_LOGGING_CATEGORY(LOG_TestAmdaFuzzing, "TestAmdaFuzzing")
23
24 /**
25 * Macro used to generate a getter for a property in @sa FuzzingTest. The macro generates a static
26 * attribute that is initialized by searching in properties the property and use a default value if
27 * it's not present. Macro arguments are:
28 * - GETTER_NAME : name of the getter
29 * - PROPERTY_NAME: used to generate constants for property's name ({PROPERTY_NAME}_PROPERTY) and
30 * default value ({PROPERTY_NAME}_DEFAULT_VALUE)
31 * - TYPE : return type of the getter
32 */
33 // clang-format off
34 #define DECLARE_PROPERTY_GETTER(GETTER_NAME, PROPERTY_NAME, TYPE) \
35 TYPE GETTER_NAME() const \
36 { \
37 static auto result = m_Properties.value(PROPERTY_NAME##_PROPERTY, PROPERTY_NAME##_DEFAULT_VALUE).value<TYPE>(); \
38 return result; \
39 } \
40 // clang-format on
41
42 namespace {
43
44 // /////// //
45 // Aliases //
46 // /////// //
47
48 using IntPair = std::pair<int, int>;
49 using Weight = double;
50 using Weights = std::vector<Weight>;
51
52 struct OperationProperty {
53 Weight m_Weight{1.};
54 bool m_WaitAcquisition{false};
55 };
56
57 using VariableOperation = std::pair<VariableId, std::shared_ptr<IFuzzingOperation> >;
58 using VariablesOperations = std::vector<VariableOperation>;
59
60 using OperationsTypes = std::map<FuzzingOperationType, OperationProperty>;
61 using OperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, OperationProperty>;
62
63 using Validators = std::vector<std::shared_ptr<IFuzzingValidator> >;
64
65 // ///////// //
66 // Constants //
67 // ///////// //
68
69 // Defaults values used when the associated properties have not been set for the test
70 const auto ACQUISITION_TIMEOUT_DEFAULT_VALUE = 30000;
71 const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;
72 const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 1;
73 const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 1;
74 const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE = QVariant::fromValue(
75 OperationsTypes{{FuzzingOperationType::CREATE, {1., true}},
76 {FuzzingOperationType::DELETE, {0.1}}, // Delete operation is less frequent
77 {FuzzingOperationType::PAN_LEFT, {1.}},
78 {FuzzingOperationType::PAN_RIGHT, {1.}},
79 {FuzzingOperationType::ZOOM_IN, {1.}},
80 {FuzzingOperationType::ZOOM_OUT, {1.}},
81 {FuzzingOperationType::SYNCHRONIZE, {0.8}},
82 {FuzzingOperationType::DESYNCHRONIZE, {0.4}}});
83 const auto CACHE_TOLERANCE_DEFAULT_VALUE = 0.2;
84
85 /// Min/max delays between each operation (in ms)
86 const auto OPERATION_DELAY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(100, 3000));
87
88 /// Validators for the tests (executed in the order in which they're defined)
89 const auto VALIDATORS_DEFAULT_VALUE = QVariant::fromValue(
90 ValidatorsTypes{{FuzzingValidatorType::RANGE, FuzzingValidatorType::DATA}});
91
92 /// Min/max number of operations to execute before calling validation
93 const auto VALIDATION_FREQUENCY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(1, 10));
94
95 // /////// //
96 // Methods //
97 // /////// //
98
99 /// Goes through the variables pool and operations pool to determine the set of {variable/operation}
100 /// pairs that are valid (i.e. operation that can be executed on variable)
101 std::pair<VariablesOperations, Weights> availableOperations(const FuzzingState &fuzzingState,
102 const OperationsPool &operationsPool)
103 {
104 VariablesOperations result{};
105 Weights weights{};
106
107 for (const auto &variablesPoolEntry : fuzzingState.m_VariablesPool) {
108 auto variableId = variablesPoolEntry.first;
109
110 for (const auto &operationsPoolEntry : operationsPool) {
111 auto operation = operationsPoolEntry.first;
112 auto operationProperty = operationsPoolEntry.second;
113
114 // A pair is valid if the current operation can be executed on the current variable
115 if (operation->canExecute(variableId, fuzzingState)) {
116 result.push_back({variableId, operation});
117 weights.push_back(operationProperty.m_Weight);
118 }
119 }
120 }
121
122 return {result, weights};
123 }
124
125 OperationsPool createOperationsPool(const OperationsTypes &types)
126 {
127 OperationsPool result{};
128
129 std::transform(
130 types.cbegin(), types.cend(), std::inserter(result, result.end()), [](const auto &type) {
131 return std::make_pair(FuzzingOperationFactory::create(type.first), type.second);
132 });
133
134 return result;
135 }
136
137 Validators createValidators(const ValidatorsTypes &types)
138 {
139 Validators result{};
140
141 std::transform(types.cbegin(), types.cend(), std::inserter(result, result.end()),
142 [](const auto &type) { return FuzzingValidatorFactory::create(type); });
143
144 return result;
145 }
146
147 /**
148 * Validates all the variables' states passed in parameter, according to a set of validators
149 * @param variablesPool the variables' states
150 * @param validators the validators used for validation
151 */
152 void validate(const VariablesPool &variablesPool, const Validators &validators)
153 {
154 for (const auto &variablesPoolEntry : variablesPool) {
155 auto variableId = variablesPoolEntry.first;
156 const auto &variableState = variablesPoolEntry.second;
157
158 auto variableMessage = variableState.m_Variable ? variableState.m_Variable->name()
159 : QStringLiteral("null variable");
160 qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Validating state of variable at index"
161 << variableId << "(" << variableMessage << ")...";
162
163 for (const auto &validator : validators) {
164 validator->validate(VariableState{variableState});
165 }
166
167 qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Validation completed.";
168 }
169 }
170
171 /**
172 * Class to run random tests
173 */
174 class FuzzingTest {
175 public:
176 explicit FuzzingTest(VariableController &variableController, Properties properties)
177 : m_VariableController{variableController},
178 m_Properties{std::move(properties)},
179 m_FuzzingState{}
180 {
181 // Inits variables pool: at init, all variables are null
182 for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {
183 m_FuzzingState.m_VariablesPool[variableId] = VariableState{};
184 }
185
186 // Inits sync groups and registers them into the variable controller
187 for (auto i = 0; i < nbMaxSyncGroups(); ++i) {
188 auto syncGroupId = SyncGroupId::createUuid();
189 variableController.onAddSynchronizationGroupId(syncGroupId);
190 m_FuzzingState.m_SyncGroupsPool[syncGroupId] = SyncGroup{};
191 }
192 }
193
194 void execute()
195 {
196 qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Running" << nbMaxOperations() << "operations on"
197 << nbMaxVariables() << "variable(s)...";
198
199
200 // Inits the count of the number of operations before the next validation
201 int nextValidationCounter = 0;
202 auto updateValidationCounter = [this, &nextValidationCounter]() {
203 nextValidationCounter = RandomGenerator::instance().generateInt(
204 validationFrequencies().first, validationFrequencies().second);
205 qCInfo(LOG_TestAmdaFuzzing()).noquote()
206 << "Next validation in " << nextValidationCounter << "operation(s)...";
207 };
208 updateValidationCounter();
209
210 auto canExecute = true;
211 for (auto i = 0; i < nbMaxOperations() && canExecute; ++i) {
212 // Retrieves all operations that can be executed in the current context
213 VariablesOperations variableOperations{};
214 Weights weights{};
215 std::tie(variableOperations, weights)
216 = availableOperations(m_FuzzingState, operationsPool());
217
218 canExecute = !variableOperations.empty();
219 if (canExecute) {
220 --nextValidationCounter;
221
222 // Of the operations available, chooses a random operation and executes it
223 auto variableOperation
224 = RandomGenerator::instance().randomChoice(variableOperations, weights);
225
226 auto variableId = variableOperation.first;
227 auto fuzzingOperation = variableOperation.second;
228
229 auto waitAcquisition = nextValidationCounter == 0
230 || operationsPool().at(fuzzingOperation).m_WaitAcquisition;
231
232 fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
233 m_Properties);
234
235 if (waitAcquisition) {
236 qCDebug(LOG_TestAmdaFuzzing()) << "Waiting for acquisition to finish...";
237 SignalWaiter{m_VariableController, SIGNAL(acquisitionFinished())}.wait(
238 acquisitionTimeout());
239
240 // Validates variables
241 if (nextValidationCounter == 0) {
242 validate(m_FuzzingState.m_VariablesPool, validators());
243 updateValidationCounter();
244 }
245 }
246 else {
247 // Delays the next operation with a randomly generated time
248 auto delay = RandomGenerator::instance().generateInt(operationDelays().first,
249 operationDelays().second);
250 qCDebug(LOG_TestAmdaFuzzing())
251 << "Waiting " << delay << "ms before the next operation...";
252 QTest::qWait(delay);
253 }
254 }
255 else {
256 qCInfo(LOG_TestAmdaFuzzing()).noquote()
257 << "No more operations are available, the execution of the test will stop...";
258 }
259 }
260
261 qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Execution of the test completed.";
262 }
263
264 private:
265 OperationsPool operationsPool() const
266 {
267 static auto result = createOperationsPool(
268 m_Properties.value(AVAILABLE_OPERATIONS_PROPERTY, AVAILABLE_OPERATIONS_DEFAULT_VALUE)
269 .value<OperationsTypes>());
270 return result;
271 }
272
273 Validators validators() const
274 {
275 static auto result
276 = createValidators(m_Properties.value(VALIDATORS_PROPERTY, VALIDATORS_DEFAULT_VALUE)
277 .value<ValidatorsTypes>());
278 return result;
279 }
280
281 DECLARE_PROPERTY_GETTER(nbMaxOperations, NB_MAX_OPERATIONS, int)
282 DECLARE_PROPERTY_GETTER(nbMaxSyncGroups, NB_MAX_SYNC_GROUPS, int)
283 DECLARE_PROPERTY_GETTER(nbMaxVariables, NB_MAX_VARIABLES, int)
284 DECLARE_PROPERTY_GETTER(operationDelays, OPERATION_DELAY_BOUNDS, IntPair)
285 DECLARE_PROPERTY_GETTER(validationFrequencies, VALIDATION_FREQUENCY_BOUNDS, IntPair)
286 DECLARE_PROPERTY_GETTER(acquisitionTimeout, ACQUISITION_TIMEOUT, int)
287
288 VariableController &m_VariableController;
289 Properties m_Properties;
290 FuzzingState m_FuzzingState;
291 };
292
293 } // namespace
294
295 Q_DECLARE_METATYPE(OperationsTypes)
296
297 class TestAmdaFuzzing : public QObject {
298 Q_OBJECT
299
300 private slots:
301 /// Input data for @sa testFuzzing()
302 void testFuzzing_data();
303 void testFuzzing();
304 };
305
306 void TestAmdaFuzzing::testFuzzing_data()
307 {
308 // Note: Comment this line to run fuzzing tests
309 QSKIP("Fuzzing tests are disabled by default");
310
311 // ////////////// //
312 // Test structure //
313 // ////////////// //
314
315 QTest::addColumn<Properties>("properties"); // Properties for random test
316
317 // ////////// //
318 // Test cases //
319 // ////////// //
320
321 auto maxRange = SqpRange::fromDateTime({2017, 1, 1}, {0, 0}, {2017, 1, 5}, {0, 0});
322 MetadataPool metadataPool{{{"dataType", "vector"}, {"xml:id", "imf"}}};
323
324 // Note: we don't use auto here as we want to pass std::shared_ptr<IDataProvider> as is in the
325 // QVariant
326 std::shared_ptr<IDataProvider> provider = std::make_shared<AmdaProvider>();
327
328 QTest::newRow("fuzzingTest") << Properties{
329 {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
330 {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
331 {PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
332 }
333
334 void TestAmdaFuzzing::testFuzzing()
335 {
336 QFETCH(Properties, properties);
337
338 // Sets cache property
339 QSettings settings{};
340 auto cacheTolerance = properties.value(CACHE_TOLERANCE_PROPERTY, CACHE_TOLERANCE_DEFAULT_VALUE);
341 settings.setValue(GENERAL_TOLERANCE_AT_INIT_KEY, cacheTolerance);
342 settings.setValue(GENERAL_TOLERANCE_AT_UPDATE_KEY, cacheTolerance);
343
344 auto &variableController = sqpApp->variableController();
345 auto &timeController = sqpApp->timeController();
346
347 // Generates random initial range (bounded to max range)
348 auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
349 .value<SqpRange>();
350
351 QVERIFY(maxRange != INVALID_RANGE);
352
353 auto initialRangeStart
354 = RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
355 auto initialRangeEnd
356 = RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
357 if (initialRangeStart > initialRangeEnd) {
358 std::swap(initialRangeStart, initialRangeEnd);
359 }
360
361 // Sets initial range on time controller
362 SqpRange initialRange{initialRangeStart, initialRangeEnd};
363 qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Setting initial range to" << initialRange << "...";
364 timeController.onTimeToUpdate(initialRange);
365 properties.insert(INITIAL_RANGE_PROPERTY, QVariant::fromValue(initialRange));
366
367 FuzzingTest test{variableController, properties};
368 test.execute();
369 }
370
371 int main(int argc, char *argv[])
372 {
373 QLoggingCategory::setFilterRules(
374 "*.warning=false\n"
375 "*.info=false\n"
376 "*.debug=false\n"
377 "FuzzingOperations.info=true\n"
378 "FuzzingValidators.info=true\n"
379 "TestAmdaFuzzing.info=true\n");
380
381 SqpApplication app{argc, argv};
382 SqpApplication::setOrganizationName("LPP");
383 SqpApplication::setOrganizationDomain("lpp.fr");
384 SqpApplication::setApplicationName("SciQLop-TestFuzzing");
385 app.setAttribute(Qt::AA_Use96Dpi, true);
386 TestAmdaFuzzing testObject{};
387 QTEST_SET_MAIN_SOURCE_PATH
388 return QTest::qExec(&testObject, argc, argv);
389 }
390
391 #include "TestAmdaFuzzing.moc"
Show file before | Show file after | Hide comments
@@ -1,58 +1,66
1 1 #ifndef SCIQLOP_SQPRANGE_H
2 2 #define SCIQLOP_SQPRANGE_H
3 3
4 4 #include <QObject>
5 5
6 6 #include <QDebug>
7 7
8 8 #include <Common/DateUtils.h>
9 9 #include <Common/MetaTypes.h>
10 10
11 11 #include <cmath>
12 12
13 13 /**
14 14 * @brief The SqpRange struct holds the information of time parameters
15 15 */
16 16 struct SqpRange {
17 /// Creates SqpRange from dates and times
18 static SqpRange fromDateTime(const QDate &startDate, const QTime &startTime,
19 const QDate &endDate, const QTime &endTime)
20 {
21 return {DateUtils::secondsSinceEpoch(QDateTime{startDate, startTime, Qt::UTC}),
22 DateUtils::secondsSinceEpoch(QDateTime{endDate, endTime, Qt::UTC})};
23 }
24
17 25 /// Start time (UTC)
18 26 double m_TStart;
19 27 /// End time (UTC)
20 28 double m_TEnd;
21 29
22 30 bool contains(const SqpRange &dateTime) const noexcept
23 31 {
24 32 return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
25 33 }
26 34
27 35 bool intersect(const SqpRange &dateTime) const noexcept
28 36 {
29 37 return (m_TEnd >= dateTime.m_TStart && m_TStart <= dateTime.m_TEnd);
30 38 }
31 39
32 40 bool operator==(const SqpRange &other) const
33 41 {
34 42 auto equals = [](const auto &v1, const auto &v2) {
35 43 return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
36 44 };
37 45
38 46 return equals(m_TStart, other.m_TStart) && equals(m_TEnd, other.m_TEnd);
39 47 }
40 48 bool operator!=(const SqpRange &other) const { return !(*this == other); }
41 49 };
42 50
43 51 const auto INVALID_RANGE
44 52 = SqpRange{std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
45 53
46 54 inline QDebug operator<<(QDebug d, SqpRange obj)
47 55 {
48 56 auto tendDateTimeStart = DateUtils::dateTime(obj.m_TStart);
49 57 auto tendDateTimeEnd = DateUtils::dateTime(obj.m_TEnd);
50 58
51 59 d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
52 60 return d;
53 61 }
54 62
55 63 // Required for using shared_ptr in signals/slots
56 64 SCIQLOP_REGISTER_META_TYPE(SQPRANGE_REGISTRY, SqpRange)
57 65
58 66 #endif // SCIQLOP_SQPRANGE_H
Show file before | Show file after | Hide comments
@@ -1,138 +1,142
1 1 #ifndef SCIQLOP_VARIABLECONTROLLER_H
2 2 #define SCIQLOP_VARIABLECONTROLLER_H
3 3
4 4 #include "CoreGlobal.h"
5 5
6 6 #include <Data/AcquisitionDataPacket.h>
7 7 #include <Data/SqpRange.h>
8 8
9 9 #include <QLoggingCategory>
10 10 #include <QObject>
11 11 #include <QUuid>
12 12
13 13 #include <Common/spimpl.h>
14 14
15 15 class IDataProvider;
16 16 class QItemSelectionModel;
17 17 class TimeController;
18 18 class Variable;
19 19 class VariableModel;
20 20
21 21 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
22 22
23 23
24 24 /**
25 25 * Possible types of zoom operation
26 26 */
27 27 enum class AcquisitionZoomType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
28 28
29 29
30 30 /**
31 31 * @brief The VariableController class aims to handle the variables in SciQlop.
32 32 */
33 33 class SCIQLOP_CORE_EXPORT VariableController : public QObject {
34 34 Q_OBJECT
35 35 public:
36 36 explicit VariableController(QObject *parent = 0);
37 37 virtual ~VariableController();
38 38
39 39 VariableModel *variableModel() noexcept;
40 40 QItemSelectionModel *variableSelectionModel() noexcept;
41 41
42 42 void setTimeController(TimeController *timeController) noexcept;
43 43
44 44 /**
45 45 * Clones the variable passed in parameter and adds the duplicate to the controller
46 46 * @param variable the variable to duplicate
47 47 * @return the duplicate created, nullptr if the variable couldn't be created
48 48 */
49 49 std::shared_ptr<Variable> cloneVariable(std::shared_ptr<Variable> variable) noexcept;
50 50
51 51 /**
52 52 * Deletes from the controller the variable passed in parameter.
53 53 *
54 54 * Delete a variable includes:
55 55 * - the deletion of the various references to the variable in SciQlop
56 56 * - the deletion of the model variable
57 57 * - the deletion of the provider associated with the variable
58 58 * - removing the cache associated with the variable
59 59 *
60 60 * @param variable the variable to delete from the controller.
61 61 */
62 62 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
63 63
64 64 /**
65 65 * Deletes from the controller the variables passed in parameter.
66 66 * @param variables the variables to delete from the controller.
67 67 * @sa deleteVariable()
68 68 */
69 69 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
70 70
71 71 /// Returns the MIME data associated to a list of variables
72 72 QByteArray mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const;
73 73
74 74 /// Returns the list of variables contained in a MIME data
75 75 QList<std::shared_ptr<Variable> > variablesForMimeData(const QByteArray &mimeData) const;
76 76
77 77 static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
78 78 signals:
79 79 /// Signal emitted when a variable is about to be deleted from the controller
80 80 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
81 81
82 82 /// Signal emitted when a data acquisition is requested on a range for a variable
83 83 void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
84 84
85 85 /// Signal emitted when a sub range of the cacheRange of the variable can be displayed
86 86 void updateVarDisplaying(std::shared_ptr<Variable> variable, const SqpRange &range);
87 87
88 /// Signal emitted when all acquisitions related to the variables have been completed (whether
89 /// validated, canceled, or failed)
90 void acquisitionFinished();
91
88 92 public slots:
89 93 /// Request the data loading of the variable whithin range
90 94 void onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables, const SqpRange &range,
91 95 bool synchronise);
92 96 /**
93 97 * Creates a new variable and adds it to the model
94 98 * @param name the name of the new variable
95 99 * @param metadata the metadata of the new variable
96 100 * @param provider the data provider for the new variable
97 101 * @return the pointer to the new variable or nullptr if the creation failed
98 102 */
99 103 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata,
100 104 std::shared_ptr<IDataProvider> provider) noexcept;
101 105
102 106 /// Update the temporal parameters of every selected variable to dateTime
103 107 void onDateTimeOnSelection(const SqpRange &dateTime);
104 108
105 109 /// Update the temporal parameters of the specified variable
106 110 void onUpdateDateTime(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
107 111
108 112
109 113 void onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
110 114 const SqpRange &cacheRangeRequested,
111 115 QVector<AcquisitionDataPacket> dataAcquired);
112 116
113 117 void onVariableRetrieveDataInProgress(QUuid identifier, double progress);
114 118
115 119 /// Cancel the current request for the variable
116 120 void onAbortProgressRequested(std::shared_ptr<Variable> variable);
117 121 void onAbortAcquisitionRequested(QUuid vIdentifier);
118 122
119 123 // synchronization group methods
120 124 void onAddSynchronizationGroupId(QUuid synchronizationGroupId);
121 125 void onRemoveSynchronizationGroupId(QUuid synchronizationGroupId);
122 126 void onAddSynchronized(std::shared_ptr<Variable> variable, QUuid synchronizationGroupId);
123 127
124 128 /// Desynchronizes the variable of the group whose identifier is passed in parameter
125 129 /// @remarks the method does nothing if the variable is not part of the group
126 130 void desynchronize(std::shared_ptr<Variable> variable, QUuid synchronizationGroupId);
127 131
128 132 void initialize();
129 133 void finalize();
130 134
131 135 private:
132 136 void waitForFinish();
133 137
134 138 class VariableControllerPrivate;
135 139 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
136 140 };
137 141
138 142 #endif // SCIQLOP_VARIABLECONTROLLER_H
Show file before | Show file after | Hide comments
@@ -1,73 +1,75
1 1
2 2 qxorm_dep = dependency('QxOrm', required : true, fallback:['QxOrm','qxorm_dep'])
3 3 catalogueapi_dep = dependency('CatalogueAPI', required : true, fallback:['CatalogueAPI','CatalogueAPI_dep'])
4 4
5 5
6 6 core_moc_headers = [
7 7 'include/Catalogue/CatalogueController.h',
8 'include/Common/SignalWaiter.h',
8 9 'include/Data/IDataProvider.h',
9 10 'include/DataSource/DataSourceController.h',
10 11 'include/DataSource/DataSourceItemAction.h',
11 12 'include/Network/NetworkController.h',
12 13 'include/Time/TimeController.h',
13 14 'include/Variable/Variable.h',
14 15 'include/Variable/VariableCacheController.h',
15 16 'include/Variable/VariableController.h',
16 17 'include/Variable/VariableAcquisitionWorker.h',
17 18 'include/Variable/VariableSynchronizationGroup.h',
18 19 'include/Variable/VariableModel.h',
19 20 'include/Visualization/VisualizationController.h'
20 21 ]
21 22
22 23
23 24 core_moc_files = qt5.preprocess(moc_headers : core_moc_headers)
24 25
25 26 core_sources = [
26 27 'src/Common/DateUtils.cpp',
28 'src/Common/SignalWaiter.cpp',
27 29 'src/Common/StringUtils.cpp',
28 30 'src/Common/MimeTypesDef.cpp',
29 31 'src/Catalogue/CatalogueController.cpp',
30 32 'src/Data/ScalarSeries.cpp',
31 33 'src/Data/SpectrogramSeries.cpp',
32 34 'src/Data/DataSeriesIterator.cpp',
33 35 'src/Data/ArrayDataIterator.cpp',
34 36 'src/Data/VectorSeries.cpp',
35 37 'src/Data/OptionalAxis.cpp',
36 38 'src/Data/DataSeriesUtils.cpp',
37 39 'src/DataSource/DataSourceController.cpp',
38 40 'src/DataSource/DataSourceItem.cpp',
39 41 'src/DataSource/DataSourceItemAction.cpp',
40 42 'src/DataSource/DataSourceItemMergeHelper.cpp',
41 43 'src/Network/NetworkController.cpp',
42 44 'src/Plugin/PluginManager.cpp',
43 45 'src/Settings/SqpSettingsDefs.cpp',
44 46 'src/Time/TimeController.cpp',
45 47 'src/Variable/Variable.cpp',
46 48 'src/Variable/VariableCacheController.cpp',
47 49 'src/Variable/VariableController.cpp',
48 50 'src/Variable/VariableAcquisitionWorker.cpp',
49 51 'src/Variable/VariableSynchronizationGroup.cpp',
50 52 'src/Variable/VariableModel.cpp',
51 53 'src/Visualization/VisualizationController.cpp'
52 54 ]
53 55
54 56 core_inc = include_directories(['include', '../plugin/include'])
55 57
56 58 sciqlop_core_lib = library('sciqlopcore',
57 59 core_sources,
58 60 core_moc_files,
59 61 cpp_args : '-DCORE_LIB',
60 62 include_directories : core_inc,
61 63 dependencies : [qt5core, qt5network, catalogueapi_dep],
62 64 install : true
63 65 )
64 66
65 67
66 68 sciqlop_core = declare_dependency(link_with : sciqlop_core_lib,
67 69 include_directories : core_inc,
68 70 dependencies : [qt5core, qt5network, catalogueapi_dep])
69 71
70 72
71 73
72 74 subdir('tests')
73 75
Show file before | Show file after | Hide comments
@@ -1,1063 +1,1069
1 1 #include <Variable/Variable.h>
2 2 #include <Variable/VariableAcquisitionWorker.h>
3 3 #include <Variable/VariableCacheStrategy.h>
4 4 #include <Variable/VariableCacheStrategyFactory.h>
5 5 #include <Variable/VariableController.h>
6 6 #include <Variable/VariableModel.h>
7 7 #include <Variable/VariableSynchronizationGroup.h>
8 8
9 9 #include <Data/DataProviderParameters.h>
10 10 #include <Data/IDataProvider.h>
11 11 #include <Data/IDataSeries.h>
12 12 #include <Data/VariableRequest.h>
13 13 #include <Time/TimeController.h>
14 14
15 15 #include <QDataStream>
16 16 #include <QMutex>
17 17 #include <QThread>
18 18 #include <QUuid>
19 19 #include <QtCore/QItemSelectionModel>
20 20
21 21 #include <deque>
22 22 #include <set>
23 23 #include <unordered_map>
24 24
25 25 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
26 26
27 27 namespace {
28 28
29 29 SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
30 30 const SqpRange &oldGraphRange)
31 31 {
32 32 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
33 33
34 34 auto varRangeRequested = varRange;
35 35 switch (zoomType) {
36 36 case AcquisitionZoomType::ZoomIn: {
37 37 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
38 38 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
39 39 varRangeRequested.m_TStart += deltaLeft;
40 40 varRangeRequested.m_TEnd -= deltaRight;
41 41 break;
42 42 }
43 43
44 44 case AcquisitionZoomType::ZoomOut: {
45 45 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
46 46 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
47 47 varRangeRequested.m_TStart -= deltaLeft;
48 48 varRangeRequested.m_TEnd += deltaRight;
49 49 break;
50 50 }
51 51 case AcquisitionZoomType::PanRight: {
52 52 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
53 53 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
54 54 varRangeRequested.m_TStart += deltaLeft;
55 55 varRangeRequested.m_TEnd += deltaRight;
56 56 break;
57 57 }
58 58 case AcquisitionZoomType::PanLeft: {
59 59 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
60 60 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
61 61 varRangeRequested.m_TStart -= deltaLeft;
62 62 varRangeRequested.m_TEnd -= deltaRight;
63 63 break;
64 64 }
65 65 case AcquisitionZoomType::Unknown: {
66 66 qCCritical(LOG_VariableController())
67 67 << VariableController::tr("Impossible to synchronize: zoom type unknown");
68 68 break;
69 69 }
70 70 default:
71 71 qCCritical(LOG_VariableController()) << VariableController::tr(
72 72 "Impossible to synchronize: zoom type not take into account");
73 73 // No action
74 74 break;
75 75 }
76 76
77 77 return varRangeRequested;
78 78 }
79 79 }
80 80
81 81 enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };
82 82
83 83 struct VariableRequestHandler {
84 84
85 85 VariableRequestHandler()
86 86 {
87 87 m_CanUpdate = false;
88 88 m_State = VariableRequestHandlerState::OFF;
89 89 }
90 90
91 91 QUuid m_VarId;
92 92 VariableRequest m_RunningVarRequest;
93 93 VariableRequest m_PendingVarRequest;
94 94 VariableRequestHandlerState m_State;
95 95 bool m_CanUpdate;
96 96 };
97 97
98 98 struct VariableController::VariableControllerPrivate {
99 99 explicit VariableControllerPrivate(VariableController *parent)
100 100 : m_WorkingMutex{},
101 101 m_VariableModel{new VariableModel{parent}},
102 102 m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
103 103 // m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
104 104 m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(
105 105 CacheStrategy::SingleThreshold)},
106 106 m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
107 107 q{parent}
108 108 {
109 109
110 110 m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
111 111 m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
112 112 }
113 113
114 114
115 115 virtual ~VariableControllerPrivate()
116 116 {
117 117 qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
118 118 m_VariableAcquisitionWorkerThread.quit();
119 119 m_VariableAcquisitionWorkerThread.wait();
120 120 }
121 121
122 122
123 123 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
124 124 QUuid varRequestId);
125 125
126 126 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
127 127 std::shared_ptr<IDataSeries>
128 128 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
129 129
130 130 void registerProvider(std::shared_ptr<IDataProvider> provider);
131 131
132 132 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
133 133 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
134 134 void updateVariables(QUuid varRequestId);
135 135 void updateVariableRequest(QUuid varRequestId);
136 136 void cancelVariableRequest(QUuid varRequestId);
137 137 void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);
138 138
139 139 QMutex m_WorkingMutex;
140 140 /// Variable model. The VariableController has the ownership
141 141 VariableModel *m_VariableModel;
142 142 QItemSelectionModel *m_VariableSelectionModel;
143 143
144 144
145 145 TimeController *m_TimeController{nullptr};
146 146 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
147 147 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
148 148 QThread m_VariableAcquisitionWorkerThread;
149 149
150 150 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
151 151 m_VariableToProviderMap;
152 152 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
153 153 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
154 154 m_GroupIdToVariableSynchronizationGroupMap;
155 155 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
156 156 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
157 157
158 158 std::map<QUuid, std::list<QUuid> > m_VarGroupIdToVarIds;
159 159 std::map<QUuid, std::unique_ptr<VariableRequestHandler> > m_VarIdToVarRequestHandler;
160 160
161 161 VariableController *q;
162 162 };
163 163
164 164
165 165 VariableController::VariableController(QObject *parent)
166 166 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
167 167 {
168 168 qCDebug(LOG_VariableController()) << tr("VariableController construction")
169 169 << QThread::currentThread();
170 170
171 171 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
172 172 &VariableController::onAbortProgressRequested);
173 173
174 174 connect(impl->m_VariableAcquisitionWorker.get(),
175 175 &VariableAcquisitionWorker::variableCanceledRequested, this,
176 176 &VariableController::onAbortAcquisitionRequested);
177 177
178 178 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
179 179 &VariableController::onDataProvided);
180 180 connect(impl->m_VariableAcquisitionWorker.get(),
181 181 &VariableAcquisitionWorker::variableRequestInProgress, this,
182 182 &VariableController::onVariableRetrieveDataInProgress);
183 183
184 184
185 185 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
186 186 impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
187 187 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
188 188 impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
189 189
190 190 connect(impl->m_VariableModel, &VariableModel::requestVariableRangeUpdate, this,
191 191 &VariableController::onUpdateDateTime);
192 192
193 193 impl->m_VariableAcquisitionWorkerThread.start();
194 194 }
195 195
196 196 VariableController::~VariableController()
197 197 {
198 198 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
199 199 << QThread::currentThread();
200 200 this->waitForFinish();
201 201 }
202 202
203 203 VariableModel *VariableController::variableModel() noexcept
204 204 {
205 205 return impl->m_VariableModel;
206 206 }
207 207
208 208 QItemSelectionModel *VariableController::variableSelectionModel() noexcept
209 209 {
210 210 return impl->m_VariableSelectionModel;
211 211 }
212 212
213 213 void VariableController::setTimeController(TimeController *timeController) noexcept
214 214 {
215 215 impl->m_TimeController = timeController;
216 216 }
217 217
218 218 std::shared_ptr<Variable>
219 219 VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
220 220 {
221 221 if (impl->m_VariableModel->containsVariable(variable)) {
222 222 // Clones variable
223 223 auto duplicate = variable->clone();
224 224
225 225 // Adds clone to model
226 226 impl->m_VariableModel->addVariable(duplicate);
227 227
228 228 // Generates clone identifier
229 229 impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
230 230
231 231 // Registers provider
232 232 auto variableProvider = impl->m_VariableToProviderMap.at(variable);
233 233 auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
234 234
235 235 impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
236 236 if (duplicateProvider) {
237 237 impl->registerProvider(duplicateProvider);
238 238 }
239 239
240 240 return duplicate;
241 241 }
242 242 else {
243 243 qCCritical(LOG_VariableController())
244 244 << tr("Can't create duplicate of variable %1: variable not registered in the model")
245 245 .arg(variable->name());
246 246 return nullptr;
247 247 }
248 248 }
249 249
250 250 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
251 251 {
252 252 if (!variable) {
253 253 qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
254 254 return;
255 255 }
256 256
257 257 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
258 258 // make some treatments before the deletion
259 259 emit variableAboutToBeDeleted(variable);
260 260
261 261 // Deletes identifier
262 262 impl->m_VariableToIdentifierMap.erase(variable);
263 263
264 264 // Deletes provider
265 265 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
266 266 qCDebug(LOG_VariableController())
267 267 << tr("Number of providers deleted for variable %1: %2")
268 268 .arg(variable->name(), QString::number(nbProvidersDeleted));
269 269
270 270
271 271 // Deletes from model
272 272 impl->m_VariableModel->deleteVariable(variable);
273 273 }
274 274
275 275 void VariableController::deleteVariables(
276 276 const QVector<std::shared_ptr<Variable> > &variables) noexcept
277 277 {
278 278 for (auto variable : qAsConst(variables)) {
279 279 deleteVariable(variable);
280 280 }
281 281 }
282 282
283 283 QByteArray
284 284 VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const
285 285 {
286 286 auto encodedData = QByteArray{};
287 287
288 288 QVariantList ids;
289 289 for (auto &var : variables) {
290 290 auto itVar = impl->m_VariableToIdentifierMap.find(var);
291 291 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
292 292 qCCritical(LOG_VariableController())
293 293 << tr("Impossible to find the data for an unknown variable.");
294 294 }
295 295
296 296 ids << itVar->second.toByteArray();
297 297 }
298 298
299 299 QDataStream stream{&encodedData, QIODevice::WriteOnly};
300 300 stream << ids;
301 301
302 302 return encodedData;
303 303 }
304 304
305 305 QList<std::shared_ptr<Variable> >
306 306 VariableController::variablesForMimeData(const QByteArray &mimeData) const
307 307 {
308 308 auto variables = QList<std::shared_ptr<Variable> >{};
309 309 QDataStream stream{mimeData};
310 310
311 311 QVariantList ids;
312 312 stream >> ids;
313 313
314 314 for (auto id : ids) {
315 315 auto uuid = QUuid{id.toByteArray()};
316 316 auto var = impl->findVariable(uuid);
317 317 variables << var;
318 318 }
319 319
320 320 return variables;
321 321 }
322 322
323 323 std::shared_ptr<Variable>
324 324 VariableController::createVariable(const QString &name, const QVariantHash &metadata,
325 325 std::shared_ptr<IDataProvider> provider) noexcept
326 326 {
327 327 if (!impl->m_TimeController) {
328 328 qCCritical(LOG_VariableController())
329 329 << tr("Impossible to create variable: The time controller is null");
330 330 return nullptr;
331 331 }
332 332
333 333 auto range = impl->m_TimeController->dateTime();
334 334
335 335 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
336 336 auto varId = QUuid::createUuid();
337 337
338 338 // Create the handler
339 339 auto varRequestHandler = std::make_unique<VariableRequestHandler>();
340 340 varRequestHandler->m_VarId = varId;
341 341
342 342 impl->m_VarIdToVarRequestHandler.insert(
343 343 std::make_pair(varId, std::move(varRequestHandler)));
344 344
345 345 // store the provider
346 346 impl->registerProvider(provider);
347 347
348 348 // Associate the provider
349 349 impl->m_VariableToProviderMap[newVariable] = provider;
350 350 impl->m_VariableToIdentifierMap[newVariable] = varId;
351 351
352 352 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);
353 353
354 354 // auto varRequestId = QUuid::createUuid();
355 355 // qCInfo(LOG_VariableController()) << "createVariable: " << varId << varRequestId;
356 356 // impl->processRequest(newVariable, range, varRequestId);
357 357 // impl->updateVariableRequest(varRequestId);
358 358
359 359 return newVariable;
360 360 }
361 361
362 362 qCCritical(LOG_VariableController()) << tr("Impossible to create variable");
363 363 return nullptr;
364 364 }
365 365
366 366 void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
367 367 {
368 368 // NOTE: Even if acquisition request is aborting, the graphe range will be changed
369 369 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
370 370 << QThread::currentThread()->objectName();
371 371 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
372 372
373 373 // NOTE we only permit the time modification for one variable
374 374 // DEPRECATED
375 375 // auto variables = QVector<std::shared_ptr<Variable> >{};
376 376 // for (const auto &selectedRow : qAsConst(selectedRows)) {
377 377 // if (auto selectedVariable =
378 378 // impl->m_VariableModel->variable(selectedRow.row())) {
379 379 // variables << selectedVariable;
380 380
381 381 // // notify that rescale operation has to be done
382 382 // emit rangeChanged(selectedVariable, dateTime);
383 383 // }
384 384 // }
385 385 // if (!variables.isEmpty()) {
386 386 // this->onRequestDataLoading(variables, dateTime, synchro);
387 387 // }
388 388 if (selectedRows.size() == 1) {
389 389
390 390 if (auto selectedVariable
391 391 = impl->m_VariableModel->variable(qAsConst(selectedRows).first().row())) {
392 392
393 393 onUpdateDateTime(selectedVariable, dateTime);
394 394 }
395 395 }
396 396 else if (selectedRows.size() > 1) {
397 397 qCCritical(LOG_VariableController())
398 398 << tr("Impossible to set time for more than 1 variable in the same time");
399 399 }
400 400 else {
401 401 qCWarning(LOG_VariableController())
402 402 << tr("There is no variable selected to set the time one");
403 403 }
404 404 }
405 405
406 406 void VariableController::onUpdateDateTime(std::shared_ptr<Variable> variable,
407 407 const SqpRange &dateTime)
408 408 {
409 409 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
410 410 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
411 411 qCCritical(LOG_VariableController())
412 412 << tr("Impossible to onDateTimeOnSelection request for unknown variable");
413 413 return;
414 414 }
415 415
416 416 // notify that rescale operation has to be done
417 417 emit rangeChanged(variable, dateTime);
418 418
419 419 auto synchro
420 420 = impl->m_VariableIdGroupIdMap.find(itVar->second) != impl->m_VariableIdGroupIdMap.cend();
421 421
422 422 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);
423 423 }
424 424
425 425 void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
426 426 const SqpRange &cacheRangeRequested,
427 427 QVector<AcquisitionDataPacket> dataAcquired)
428 428 {
429 429 qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
430 430 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
431 431 auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
432 432 if (!varRequestId.isNull()) {
433 433 impl->updateVariables(varRequestId);
434 434 }
435 435 }
436 436
437 437 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
438 438 {
439 439 qCDebug(LOG_VariableController())
440 440 << "TORM: variableController::onVariableRetrieveDataInProgress"
441 441 << QThread::currentThread()->objectName() << progress;
442 442 if (auto var = impl->findVariable(identifier)) {
443 443 impl->m_VariableModel->setDataProgress(var, progress);
444 444 }
445 445 else {
446 446 qCCritical(LOG_VariableController())
447 447 << tr("Impossible to notify progression of a null variable");
448 448 }
449 449 }
450 450
451 451 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
452 452 {
453 453 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortProgressRequested"
454 454 << QThread::currentThread()->objectName() << variable->name();
455 455
456 456 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
457 457 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
458 458 qCCritical(LOG_VariableController())
459 459 << tr("Impossible to onAbortProgressRequested request for unknown variable");
460 460 return;
461 461 }
462 462
463 463 auto varId = itVar->second;
464 464
465 465 auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);
466 466 if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {
467 467 qCCritical(LOG_VariableController())
468 468 << tr("Impossible to onAbortProgressRequested for variable with unknown handler");
469 469 return;
470 470 }
471 471
472 472 auto varHandler = itVarHandler->second.get();
473 473
474 474 // case where a variable has a running request
475 475 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
476 476 impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);
477 477 }
478 478 }
479 479
480 480 void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
481 481 {
482 482 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
483 483 << QThread::currentThread()->objectName() << vIdentifier;
484 484
485 485 if (auto var = impl->findVariable(vIdentifier)) {
486 486 this->onAbortProgressRequested(var);
487 487 }
488 488 else {
489 489 qCCritical(LOG_VariableController())
490 490 << tr("Impossible to abort Acquisition Requestof a null variable");
491 491 }
492 492 }
493 493
494 494 void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
495 495 {
496 496 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
497 497 << QThread::currentThread()->objectName()
498 498 << synchronizationGroupId;
499 499 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
500 500 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
501 501 std::make_pair(synchronizationGroupId, vSynchroGroup));
502 502 }
503 503
504 504 void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
505 505 {
506 506 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
507 507 }
508 508
509 509 void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
510 510 QUuid synchronizationGroupId)
511 511
512 512 {
513 513 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
514 514 << synchronizationGroupId;
515 515 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
516 516 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
517 517 auto groupIdToVSGIt
518 518 = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
519 519 if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
520 520 impl->m_VariableIdGroupIdMap.insert(
521 521 std::make_pair(varToVarIdIt->second, synchronizationGroupId));
522 522 groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
523 523 }
524 524 else {
525 525 qCCritical(LOG_VariableController())
526 526 << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
527 527 << variable->name();
528 528 }
529 529 }
530 530 else {
531 531 qCCritical(LOG_VariableController())
532 532 << tr("Impossible to synchronize a variable with no identifier") << variable->name();
533 533 }
534 534 }
535 535
536 536 void VariableController::desynchronize(std::shared_ptr<Variable> variable,
537 537 QUuid synchronizationGroupId)
538 538 {
539 539 // Gets variable id
540 540 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
541 541 if (variableIt == impl->m_VariableToIdentifierMap.cend()) {
542 542 qCCritical(LOG_VariableController())
543 543 << tr("Can't desynchronize variable %1: variable identifier not found")
544 544 .arg(variable->name());
545 545 return;
546 546 }
547 547
548 548 // Gets synchronization group
549 549 auto groupIt = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
550 550 if (groupIt == impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
551 551 qCCritical(LOG_VariableController())
552 552 << tr("Can't desynchronize variable %1: unknown synchronization group")
553 553 .arg(variable->name());
554 554 return;
555 555 }
556 556
557 557 auto variableId = variableIt->second;
558 558
559 559 // Removes variable from synchronization group
560 560 auto synchronizationGroup = groupIt->second;
561 561 synchronizationGroup->removeVariableId(variableId);
562 562
563 563 // Removes link between variable and synchronization group
564 564 impl->m_VariableIdGroupIdMap.erase(variableId);
565 565 }
566 566
567 567 void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
568 568 const SqpRange &range, bool synchronise)
569 569 {
570 570 // variables is assumed synchronized
571 571 // TODO: Asser variables synchronization
572 572 // we want to load data of the variable for the dateTime.
573 573 if (variables.isEmpty()) {
574 574 return;
575 575 }
576 576
577 577 auto varRequestId = QUuid::createUuid();
578 578 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
579 579 << QThread::currentThread()->objectName() << varRequestId
580 580 << range << synchronise;
581 581
582 582 if (!synchronise) {
583 583 auto varIds = std::list<QUuid>{};
584 584 for (const auto &var : variables) {
585 585 auto vId = impl->m_VariableToIdentifierMap.at(var);
586 586 varIds.push_back(vId);
587 587 }
588 588 impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
589 589 for (const auto &var : variables) {
590 590 qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId
591 591 << varIds.size();
592 592 impl->processRequest(var, range, varRequestId);
593 593 }
594 594 }
595 595 else {
596 596 auto vId = impl->m_VariableToIdentifierMap.at(variables.first());
597 597 auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
598 598 if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
599 599 auto groupId = varIdToGroupIdIt->second;
600 600
601 601 auto vSynchronizationGroup
602 602 = impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);
603 603 auto vSyncIds = vSynchronizationGroup->getIds();
604 604
605 605 auto varIds = std::list<QUuid>{};
606 606 for (auto vId : vSyncIds) {
607 607 varIds.push_back(vId);
608 608 }
609 609 impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
610 610
611 611 for (auto vId : vSyncIds) {
612 612 auto var = impl->findVariable(vId);
613 613
614 614 // Don't process already processed var
615 615 if (var != nullptr) {
616 616 qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()
617 617 << varRequestId;
618 618 auto vSyncRangeRequested
619 619 = variables.contains(var)
620 620 ? range
621 621 : computeSynchroRangeRequested(var->range(), range,
622 622 variables.first()->range());
623 623 qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
624 624 impl->processRequest(var, vSyncRangeRequested, varRequestId);
625 625 }
626 626 else {
627 627 qCCritical(LOG_VariableController())
628 628
629 629 << tr("Impossible to synchronize a null variable");
630 630 }
631 631 }
632 632 }
633 633 }
634 634
635 635 impl->updateVariables(varRequestId);
636 636 }
637 637
638 638
639 639 void VariableController::initialize()
640 640 {
641 641 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
642 642 impl->m_WorkingMutex.lock();
643 643 qCDebug(LOG_VariableController()) << tr("VariableController init END");
644 644 }
645 645
646 646 void VariableController::finalize()
647 647 {
648 648 impl->m_WorkingMutex.unlock();
649 649 }
650 650
651 651 void VariableController::waitForFinish()
652 652 {
653 653 QMutexLocker locker{&impl->m_WorkingMutex};
654 654 }
655 655
656 656 AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
657 657 {
658 658 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
659 659 auto zoomType = AcquisitionZoomType::Unknown;
660 660 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
661 661 qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";
662 662 zoomType = AcquisitionZoomType::ZoomOut;
663 663 }
664 664 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
665 665 qCDebug(LOG_VariableController()) << "zoomtype: PanRight";
666 666 zoomType = AcquisitionZoomType::PanRight;
667 667 }
668 668 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
669 669 qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
670 670 zoomType = AcquisitionZoomType::PanLeft;
671 671 }
672 672 else if (range.m_TStart >= oldRange.m_TStart && oldRange.m_TEnd >= range.m_TEnd) {
673 673 qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
674 674 zoomType = AcquisitionZoomType::ZoomIn;
675 675 }
676 676 else {
677 677 qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";
678 678 }
679 679 return zoomType;
680 680 }
681 681
682 682 void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
683 683 const SqpRange &rangeRequested,
684 684 QUuid varRequestId)
685 685 {
686 686 auto itVar = m_VariableToIdentifierMap.find(var);
687 687 if (itVar == m_VariableToIdentifierMap.cend()) {
688 688 qCCritical(LOG_VariableController())
689 689 << tr("Impossible to process request for unknown variable");
690 690 return;
691 691 }
692 692
693 693 auto varId = itVar->second;
694 694
695 695 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
696 696 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
697 697 qCCritical(LOG_VariableController())
698 698 << tr("Impossible to process request for variable with unknown handler");
699 699 return;
700 700 }
701 701
702 702 auto oldRange = var->range();
703 703
704 704 auto varHandler = itVarHandler->second.get();
705 705
706 706 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
707 707 oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;
708 708 }
709 709
710 710 auto varRequest = VariableRequest{};
711 711 varRequest.m_VariableGroupId = varRequestId;
712 712 auto varStrategyRangesRequested
713 713 = m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);
714 714 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
715 715 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
716 716
717 717 switch (varHandler->m_State) {
718 718 case VariableRequestHandlerState::OFF: {
719 719 qCDebug(LOG_VariableController()) << tr("Process Request OFF")
720 720 << varRequest.m_RangeRequested
721 721 << varRequest.m_CacheRangeRequested;
722 722 varHandler->m_RunningVarRequest = varRequest;
723 723 varHandler->m_State = VariableRequestHandlerState::RUNNING;
724 724 executeVarRequest(var, varRequest);
725 725 break;
726 726 }
727 727 case VariableRequestHandlerState::RUNNING: {
728 728 qCDebug(LOG_VariableController()) << tr("Process Request RUNNING")
729 729 << varRequest.m_RangeRequested
730 730 << varRequest.m_CacheRangeRequested;
731 731 varHandler->m_State = VariableRequestHandlerState::PENDING;
732 732 varHandler->m_PendingVarRequest = varRequest;
733 733 break;
734 734 }
735 735 case VariableRequestHandlerState::PENDING: {
736 736 qCDebug(LOG_VariableController()) << tr("Process Request PENDING")
737 737 << varRequest.m_RangeRequested
738 738 << varRequest.m_CacheRangeRequested;
739 739 auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;
740 740 cancelVariableRequest(variableGroupIdToCancel);
741 741 // Cancel variable can make state downgrade
742 742 varHandler->m_State = VariableRequestHandlerState::PENDING;
743 743 varHandler->m_PendingVarRequest = varRequest;
744 744
745 745 break;
746 746 }
747 747 default:
748 748 qCCritical(LOG_VariableController())
749 749 << QObject::tr("Unknown VariableRequestHandlerState");
750 750 }
751 751 }
752 752
753 753 std::shared_ptr<Variable>
754 754 VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
755 755 {
756 756 std::shared_ptr<Variable> var;
757 757 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
758 758
759 759 auto end = m_VariableToIdentifierMap.cend();
760 760 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
761 761 if (it != end) {
762 762 var = it->first;
763 763 }
764 764 else {
765 765 qCCritical(LOG_VariableController())
766 766 << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
767 767 }
768 768
769 769 return var;
770 770 }
771 771
772 772 std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
773 773 const QVector<AcquisitionDataPacket> acqDataPacketVector)
774 774 {
775 775 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
776 776 << acqDataPacketVector.size();
777 777 std::shared_ptr<IDataSeries> dataSeries;
778 778 if (!acqDataPacketVector.isEmpty()) {
779 779 dataSeries = acqDataPacketVector[0].m_DateSeries;
780 780 for (int i = 1; i < acqDataPacketVector.size(); ++i) {
781 781 dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
782 782 }
783 783 }
784 784 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
785 785 << acqDataPacketVector.size();
786 786 return dataSeries;
787 787 }
788 788
789 789 void VariableController::VariableControllerPrivate::registerProvider(
790 790 std::shared_ptr<IDataProvider> provider)
791 791 {
792 792 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
793 793 qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
794 794 << provider->objectName();
795 795 m_ProviderSet.insert(provider);
796 796 connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
797 797 &VariableAcquisitionWorker::onVariableDataAcquired);
798 798 connect(provider.get(), &IDataProvider::dataProvidedProgress,
799 799 m_VariableAcquisitionWorker.get(),
800 800 &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
801 801 connect(provider.get(), &IDataProvider::dataProvidedFailed,
802 802 m_VariableAcquisitionWorker.get(),
803 803 &VariableAcquisitionWorker::onVariableAcquisitionFailed);
804 804 }
805 805 else {
806 806 qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
807 807 }
808 808 }
809 809
810 810 QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
811 811 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
812 812 {
813 813 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
814 814 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
815 815 return QUuid();
816 816 }
817 817
818 818 auto varHandler = itVarHandler->second.get();
819 819 if (varHandler->m_State == VariableRequestHandlerState::OFF) {
820 820 qCCritical(LOG_VariableController())
821 821 << tr("acceptVariableRequest impossible on a variable with OFF state");
822 822 }
823 823
824 824 varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;
825 825 varHandler->m_CanUpdate = true;
826 826
827 827 // Element traitΓ©, on a dΓ©jΓ  toutes les donnΓ©es necessaires
828 828 auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;
829 829 qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId
830 830 << m_VarGroupIdToVarIds.size();
831 831
832 832 return varHandler->m_RunningVarRequest.m_VariableGroupId;
833 833 }
834 834
835 835 void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)
836 836 {
837 837 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
838 838 << QThread::currentThread()->objectName() << varRequestId;
839 839
840 840 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
841 841 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
842 842 qCWarning(LOG_VariableController())
843 843 << tr("Impossible to updateVariables of unknown variables") << varRequestId;
844 844 return;
845 845 }
846 846
847 847 auto &varIds = varGroupIdToVarIdsIt->second;
848 848 auto varIdsEnd = varIds.end();
849 849 bool processVariableUpdate = true;
850 850 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
851 851 << varRequestId << varIds.size();
852 852 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
853 853 ++varIdsIt) {
854 854 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
855 855 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
856 856 processVariableUpdate &= itVarHandler->second->m_CanUpdate;
857 857 }
858 858 }
859 859
860 860 if (processVariableUpdate) {
861 861 qCDebug(LOG_VariableController()) << "Final update OK for the var request" << varIds.size();
862 862 for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {
863 863 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
864 864 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
865 865 if (auto var = findVariable(*varIdsIt)) {
866 866 auto &varRequest = itVarHandler->second->m_RunningVarRequest;
867 867 var->setRange(varRequest.m_RangeRequested);
868 868 var->setCacheRange(varRequest.m_CacheRangeRequested);
869 869 qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
870 870 << varRequest.m_RangeRequested
871 871 << varRequest.m_CacheRangeRequested;
872 872 qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")
873 873 << var->nbPoints()
874 874 << varRequest.m_DataSeries->nbPoints();
875 875 var->mergeDataSeries(varRequest.m_DataSeries);
876 876 qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")
877 877 << var->nbPoints();
878 878
879 879 emit var->updated();
880 880 qCDebug(LOG_VariableController()) << tr("Update OK");
881 881 }
882 882 else {
883 883 qCCritical(LOG_VariableController())
884 884 << tr("Impossible to update data to a null variable");
885 885 }
886 886 }
887 887 }
888 888 updateVariableRequest(varRequestId);
889 889
890 890 // cleaning varRequestId
891 891 qCDebug(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;
892 892 m_VarGroupIdToVarIds.erase(varRequestId);
893 if (m_VarGroupIdToVarIds.empty()) {
894 emit q->acquisitionFinished();
895 }
893 896 }
894 897 }
895 898
896 899
897 900 void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
898 901 {
899 902 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
900 903 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
901 904 qCCritical(LOG_VariableController()) << QObject::tr(
902 905 "Impossible to updateVariableRequest since varGroupdId isn't here anymore");
903 906
904 907 return;
905 908 }
906 909
907 910 auto &varIds = varGroupIdToVarIdsIt->second;
908 911 auto varIdsEnd = varIds.end();
909 912 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
910 913 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
911 914 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
912 915
913 916 auto varHandler = itVarHandler->second.get();
914 917 varHandler->m_CanUpdate = false;
915 918
916 919
917 920 switch (varHandler->m_State) {
918 921 case VariableRequestHandlerState::OFF: {
919 922 qCCritical(LOG_VariableController())
920 923 << QObject::tr("Impossible to update a variable with handler in OFF state");
921 924 } break;
922 925 case VariableRequestHandlerState::RUNNING: {
923 926 varHandler->m_State = VariableRequestHandlerState::OFF;
924 927 varHandler->m_RunningVarRequest = VariableRequest{};
925 928 break;
926 929 }
927 930 case VariableRequestHandlerState::PENDING: {
928 931 varHandler->m_State = VariableRequestHandlerState::RUNNING;
929 932 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
930 933 varHandler->m_PendingVarRequest = VariableRequest{};
931 934 auto var = findVariable(itVarHandler->first);
932 935 executeVarRequest(var, varHandler->m_RunningVarRequest);
933 936 break;
934 937 }
935 938 default:
936 939 qCCritical(LOG_VariableController())
937 940 << QObject::tr("Unknown VariableRequestHandlerState");
938 941 }
939 942 }
940 943 }
941 944 }
942 945
943 946
944 947 void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
945 948 {
946 949 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest") << varRequestId;
947 950
948 951 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
949 952 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
950 953 qCCritical(LOG_VariableController())
951 954 << tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;
952 955 return;
953 956 }
954 957
955 958 auto &varIds = varGroupIdToVarIdsIt->second;
956 959 auto varIdsEnd = varIds.end();
957 960 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
958 961 auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
959 962 if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
960 963
961 964 auto varHandler = itVarHandler->second.get();
962 965 varHandler->m_VarId = QUuid{};
963 966 switch (varHandler->m_State) {
964 967 case VariableRequestHandlerState::OFF: {
965 968 qCWarning(LOG_VariableController())
966 969 << QObject::tr("Impossible to cancel a variable with no running request");
967 970 break;
968 971 }
969 972 case VariableRequestHandlerState::RUNNING: {
970 973
971 974 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
972 975 auto var = findVariable(itVarHandler->first);
973 976 auto varProvider = m_VariableToProviderMap.at(var);
974 977 if (varProvider != nullptr) {
975 978 m_VariableAcquisitionWorker->abortProgressRequested(
976 979 itVarHandler->first);
977 980 }
978 981 m_VariableModel->setDataProgress(var, 0.0);
979 982 varHandler->m_CanUpdate = false;
980 983 varHandler->m_State = VariableRequestHandlerState::OFF;
981 984 varHandler->m_RunningVarRequest = VariableRequest{};
982 985 }
983 986 else {
984 987 // TODO: log Impossible to cancel the running variable request beacause its
985 988 // varRequestId isn't not the canceled one
986 989 }
987 990 break;
988 991 }
989 992 case VariableRequestHandlerState::PENDING: {
990 993 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
991 994 auto var = findVariable(itVarHandler->first);
992 995 auto varProvider = m_VariableToProviderMap.at(var);
993 996 if (varProvider != nullptr) {
994 997 m_VariableAcquisitionWorker->abortProgressRequested(
995 998 itVarHandler->first);
996 999 }
997 1000 m_VariableModel->setDataProgress(var, 0.0);
998 1001 varHandler->m_CanUpdate = false;
999 1002 varHandler->m_State = VariableRequestHandlerState::RUNNING;
1000 1003 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
1001 1004 varHandler->m_PendingVarRequest = VariableRequest{};
1002 1005 executeVarRequest(var, varHandler->m_RunningVarRequest);
1003 1006 }
1004 1007 else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {
1005 1008 varHandler->m_State = VariableRequestHandlerState::RUNNING;
1006 1009 varHandler->m_PendingVarRequest = VariableRequest{};
1007 1010 }
1008 1011 else {
1009 1012 // TODO: log Impossible to cancel the variable request beacause its
1010 1013 // varRequestId isn't not the canceled one
1011 1014 }
1012 1015 break;
1013 1016 }
1014 1017 default:
1015 1018 qCCritical(LOG_VariableController())
1016 1019 << QObject::tr("Unknown VariableRequestHandlerState");
1017 1020 }
1018 1021 }
1019 1022 }
1020 1023 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest: erase") << varRequestId;
1021 1024 m_VarGroupIdToVarIds.erase(varRequestId);
1025 if (m_VarGroupIdToVarIds.empty()) {
1026 emit q->acquisitionFinished();
1027 }
1022 1028 }
1023 1029
1024 1030 void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,
1025 1031 VariableRequest &varRequest)
1026 1032 {
1027 1033 qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");
1028 1034
1029 1035 auto varId = m_VariableToIdentifierMap.at(var);
1030 1036
1031 1037 auto varCacheRange = var->cacheRange();
1032 1038 auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
1033 1039 auto notInCacheRangeList
1034 1040 = Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);
1035 1041 auto inCacheRangeList
1036 1042 = Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);
1037 1043
1038 1044 if (!notInCacheRangeList.empty()) {
1039 1045
1040 1046 auto varProvider = m_VariableToProviderMap.at(var);
1041 1047 if (varProvider != nullptr) {
1042 1048 qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested
1043 1049 << varRequest.m_CacheRangeRequested;
1044 1050 m_VariableAcquisitionWorker->pushVariableRequest(
1045 1051 varRequest.m_VariableGroupId, varId, varRequest.m_RangeRequested,
1046 1052 varRequest.m_CacheRangeRequested,
1047 1053 DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
1048 1054 varProvider);
1049 1055 }
1050 1056 else {
1051 1057 qCCritical(LOG_VariableController())
1052 1058 << "Impossible to provide data with a null provider";
1053 1059 }
1054 1060
1055 1061 if (!inCacheRangeList.empty()) {
1056 1062 emit q->updateVarDisplaying(var, inCacheRangeList.first());
1057 1063 }
1058 1064 }
1059 1065 else {
1060 1066 acceptVariableRequest(varId,
1061 1067 var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
1062 1068 }
1063 1069 }
Show file before | Show file after | Hide comments
@@ -1,167 +1,168
1 1 ## amda - CMakeLists.txt
2 2 STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
3 3 SET(SQPAMDA_LIBRARY_NAME "${LIBRARY_PREFFIX}_amda${DEBUG_SUFFIX}")
4 4 SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
5 5 SET(INCLUDES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
6 6 SET(RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/resources")
7 7 SET(TESTS_RESOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests-resources")
8 8
9 9 # Include amda directory
10 10 INCLUDE_DIRECTORIES(${INCLUDES_DIR})
11 11 INCLUDE_DIRECTORIES(${RESOURCES_DIR})
12 12
13 13 #
14 14 # Find Qt modules
15 15 #
16 16 SCIQLOP_FIND_QT(Core Widgets Network)
17 17
18 18 #
19 19 # Find dependent libraries
20 20 # ========================
21 21
22 22 # sciqlop plugin
23 23 find_package(sciqlop-plugin)
24 24 INCLUDE_DIRECTORIES(${SCIQLOP-PLUGIN_INCLUDE_DIR})
25 25
26 26 # sciqlop core
27 27 find_package(sciqlop-core)
28 28 INCLUDE_DIRECTORIES(${SCIQLOP-CORE_INCLUDE_DIR})
29 29 list(APPEND LIBRARIES ${SCIQLOP-CORE_LIBRARIES})
30 30
31 31 # sciqlop gui
32 32 find_package(sciqlop-gui)
33 33 INCLUDE_DIRECTORIES(${SCIQLOP-GUI_INCLUDE_DIR})
34 34 list(APPEND LIBRARIES ${SCIQLOP-GUI_LIBRARIES})
35 35
36 36 # Description file
37 37 FILE (GLOB_RECURSE PLUGIN_FILE ${RESOURCES_DIR}/amda.json)
38 38
39 39 # Resources files
40 40 FILE (GLOB_RECURSE PROJECT_RESOURCES ${RESOURCES_DIR}/*.qrc)
41 41
42 42 #
43 43 # Compile the library
44 44 #
45 45
46 46 ADD_DEFINITIONS(-DAMDA_LIB)
47 47
48 48 FILE (GLOB_RECURSE MODULE_SOURCES
49 49 ${INCLUDES_DIR}/*.h
50 50 ${SOURCES_DIR}/*.c
51 51 ${SOURCES_DIR}/*.cpp
52 52 ${SOURCES_DIR}/*.h
53 53 ${PLUGIN_FILE})
54 54
55 55 QT5_ADD_RESOURCES(RCC_AMDA
56 56 ${PROJECT_RESOURCES}
57 57 )
58 58
59 59 ADD_LIBRARY(${SQPAMDA_LIBRARY_NAME} ${MODULE_SOURCES} ${RCC_AMDA})
60 60 set_property(TARGET ${SQPAMDA_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
61 61 set_property(TARGET ${SQPAMDA_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
62 62
63 63 INSTALL(TARGETS ${SQPAMDA_LIBRARY_NAME}
64 64 RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
65 65 LIBRARY DESTINATION ${INSTALL_PLUGINS_LIBRARY_DIR}
66 66 ARCHIVE DESTINATION ${INSTALL_PLUGINS_LIBRARY_DIR}
67 67 )
68 68
69 69
70 70 TARGET_LINK_LIBRARIES(${SQPAMDA_LIBRARY_NAME} ${LIBRARIES})
71 71 qt5_use_modules(${SQPAMDA_LIBRARY_NAME} Core Widgets Network)
72 72
73 73 add_dependencies(${SQPAMDA_LIBRARY_NAME} ${SQPPLUGIN_LIBRARY_NAME} ${SQPGUI_LIBRARY_NAME} ${SQPCORE_LIBRARY_NAME})
74 74
75 75 # From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
76 76 # Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
77 77 # The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
78 78 IF(BUILD_SHARED_LIBS)
79 79 SET_TARGET_PROPERTIES(${SQPAMDA_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
80 80 ELSE()
81 81 TARGET_COMPILE_DEFINITIONS(${SQPAMDA_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
82 82 ENDIF()
83 83
84 84 # Set the variable to parent scope so that the other projects can copy the
85 85 # dependent shared libraries
86 86 SCIQLOP_SET_TO_PARENT_SCOPE(SQPAMDA_LIBRARY_NAME)
87 87
88 88 # Copy extern shared libraries to the lib folder
89 89 SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPAMDA_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
90 90
91 91 # Add the files to the list of files to be analyzed
92 92 LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
93 93 SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
94 94 # Vera++ exclusion files
95 95 LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/vera-exclusions/exclusions.txt)
96 96 SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
97 97
98 98 #
99 99 # Compile the tests
100 100 #
101 101 IF(BUILD_TESTS)
102 102 INCLUDE_DIRECTORIES(${SOURCES_DIR})
103 103 FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
104 104 FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
105 105 SET( TEST_LIBRARIES ${SQPAMDA_LIBRARY_NAME})
106 106
107 107 FOREACH( testFile ${TESTS_SOURCES} )
108 108 GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
109 109 GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
110 110
111 111 # Add to the list of sources files all the sources in the same
112 112 # directory that aren't another test
113 113 FILE (GLOB currentTestSources
114 114 ${testDirectory}/*.c
115 115 ${testDirectory}/*.cpp
116 116 ${testDirectory}/*.h)
117 117 LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
118 LIST(APPEND testFilesToFormat ${currentTestSources})
118 119 # LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
119 120
120 121 ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
121 122 set_property(TARGET ${testName} PROPERTY CXX_STANDARD 14)
122 123 set_property(TARGET ${testName} PROPERTY CXX_STANDARD_REQUIRED ON)
123 124 TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
124 125 qt5_use_modules(${testName} Test)
125 126
126 127 ADD_TEST( NAME ${testName} COMMAND ${testName} )
127 128
128 129 SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
129 130 ENDFOREACH( testFile )
130 131
131 132 LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
132 133 LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
133 134 LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
134 135 SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
135 136
136 137 ADD_DEFINITIONS(-DAMDA_TESTS_RESOURCES_DIR="${TESTS_RESOURCES_DIR}")
137 138 ENDIF(BUILD_TESTS)
138 139
139 140 #
140 141 # Set the files that must be formatted by clang-format.
141 142 #
142 143 LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
143 144 SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
144 145
145 146 #
146 147 # Set the directories that doxygen must browse to generate the
147 148 # documentation.
148 149 #
149 150 # Source directories:
150 151 LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
151 152 LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
152 153 SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
153 154 # Source directories to exclude from the documentation generation
154 155 #LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
155 156 SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
156 157
157 158 #
158 159 # Set the directories with the sources to analyze and propagate the
159 160 # modification to the parent scope
160 161 #
161 162 # Source directories to analyze:
162 163 LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
163 164 LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
164 165 SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
165 166 # Source directories to exclude from the analysis
166 167 #LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
167 168 SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)
Show file before | Show file after | Hide comments
@@ -1,76 +1,89
1 1
2 2 amdaplugin_moc_headers = [
3 3 'include/AmdaPlugin.h',
4 4 'include/AmdaProvider.h'
5 5 ]
6 6
7 7 amdaplugin_sources = [
8 8 'src/AmdaDefs.cpp',
9 9 'src/AmdaParser.cpp',
10 10 'src/AmdaPlugin.cpp',
11 11 'src/AmdaProvider.cpp',
12 12 'src/AmdaResultParser.cpp',
13 13 'src/AmdaResultParserDefs.cpp',
14 14 'src/AmdaResultParserHelper.cpp',
15 15 'src/AmdaServer.cpp'
16 16 ]
17 17
18 18 amdaplugin_ui_files = []
19 19 amdaplugin_resources_files = [
20 20 'resources/amdaresources.qrc'
21 21 ]
22 22
23 23 amdaplugin_inc = include_directories(['include', '../../plugin/include'])
24 24
25 25 moc_gen = generator(moc,
26 26 output : 'moc_@BASENAME@.cpp',
27 27 arguments : ['@INPUT@',
28 28 '-DSCIQLOP_PLUGIN_JSON_FILE_PATH="'+meson.source_root()+'/plugins/amda/resources/amda.json"',
29 29 '-I', meson.current_source_dir()+'/include',
30 30 '-I', meson.current_source_dir()+'/../../plugin/include',
31 31 '-o', '@OUTPUT@'])
32 32
33 33 rcc_gen = generator(rcc,
34 34 output : 'qrc_@BASENAME@.cpp',
35 35 arguments : ['--name=@BASENAME@"',
36 36 '--output',
37 37 '@OUTPUT@',
38 38 '@INPUT@'])
39 39
40 40 amdaplugin_moc_plugin_files = moc_gen.process(amdaplugin_moc_headers)
41 41
42 42 amdaplugin_rcc_plugin_files = rcc_gen.process(amdaplugin_resources_files)
43 43
44 44 #amdaplugin_rcc_plugin_files = qt5.preprocess(
45 45 # qresources : amdaplugin_resources_files)
46 46
47 47 amdaplugin_moc_files = qt5.preprocess(
48 48 ui_files : amdaplugin_ui_files)
49 49
50 50 sciqlop_amdaplugin = library('amdaplugin',
51 51 amdaplugin_sources,
52 52 amdaplugin_moc_files,
53 53 amdaplugin_rcc_plugin_files,
54 54 amdaplugin_moc_plugin_files,
55 55 cpp_args : ['-DAMDA_LIB','-DQT_PLUGIN'],
56 56 include_directories : [amdaplugin_inc],
57 57 dependencies : [sciqlop_core, sciqlop_gui],
58 58 install : true
59 59 )
60 60
61 61
62 62 tests = [
63 63 [['tests/TestAmdaParser.cpp'],'test_amda_parser','AMDA parser test'],
64 64 [['tests/TestAmdaResultParser.cpp'],'test_amda_result_parser','AMDA result parser test'],
65 [['tests/TestAmdaAcquisition.cpp'],'test_amda_acquisition','AMDA Acquisition test']
65 [['tests/TestAmdaAcquisition.cpp'],'test_amda_acquisition','AMDA Acquisition test'],
66 [['tests/TestAmdaFuzzing.cpp'],'test_amda_fuzzing','AMDA fuzzing test']
67 ]
68
69 tests_sources = [
70 'tests/FuzzingDefs.h',
71 'tests/FuzzingDefs.cpp',
72 'tests/FuzzingOperations.h',
73 'tests/FuzzingOperations.cpp',
74 'tests/FuzzingUtils.h',
75 'tests/FuzzingUtils.cpp',
76 'tests/FuzzingValidators.h',
77 'tests/FuzzingValidators.cpp'
66 78 ]
67 79
68 80 foreach unit_test : tests
69 81 test_moc_files = qt5.preprocess(moc_sources : unit_test[0])
70 82 test_exe = executable(unit_test[1],unit_test[0] , test_moc_files,
71 83 link_with : [sciqlop_amdaplugin],
72 84 include_directories : [amdaplugin_inc],
73 85 cpp_args : ['-DAMDA_TESTS_RESOURCES_DIR="'+meson.current_source_dir()+'/tests-resources"'],
86 sources : [tests_sources],
74 87 dependencies : [sciqlop_core, sciqlop_gui, qt5test])
75 88 test(unit_test[2], test_exe, args: ['-teamcity', '-o', '@0@.teamcity.txt'.format(unit_test[1])], timeout: 3 * 60)
76 89 endforeach
General Comments 0
You need to be logged in to leave comments. Login now