HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1274:6015d1ab6800

Fixes on fuzzing tests

Alexandre Leroux -

r1274:6015d1ab6800

parent child

Context file:

r1274:6015d1ab6800

Collapse all files

plugins/amda/tests/FuzzingDefs.cpp +17 -8

             #include "FuzzingDefs.h"
             const QString ACQUISITION_TIMEOUT_PROPERTY = QStringLiteral("acquisitionTimeout");
             const QString NB_MAX_OPERATIONS_PROPERTY = QStringLiteral("component");
             const QString NB_MAX_SYNC_GROUPS_PROPERTY = QStringLiteral("nbSyncGroups");
             const QString NB_MAX_VARIABLES_PROPERTY = QStringLiteral("nbMaxVariables");
             const QString AVAILABLE_OPERATIONS_PROPERTY = QStringLiteral("availableOperations");
             const QString CACHE_TOLERANCE_PROPERTY = QStringLiteral("cacheTolerance");
             const QString INITIAL_RANGE_PROPERTY = QStringLiteral("initialRange");
             const QString MAX_RANGE_PROPERTY = QStringLiteral("maxRange");
             const QString METADATA_POOL_PROPERTY = QStringLiteral("metadataPool");
             const QString PROVIDER_PROPERTY = QStringLiteral("provider");
             const QString OPERATION_DELAY_BOUNDS_PROPERTY = QStringLiteral("operationDelays");
             const QString VALIDATORS_PROPERTY = QStringLiteral("validators");
             const QString VALIDATION_FREQUENCY_BOUNDS_PROPERTY = QStringLiteral("validationFrequencyBounds");
             // //////////// //
             // FuzzingState //
             // //////////// //
             const SyncGroup &FuzzingState::syncGroup(SyncGroupId id) const
             {
                 return m_SyncGroupsPool.at(id);
             }
             SyncGroup &FuzzingState::syncGroup(SyncGroupId id)
             {
                 return m_SyncGroupsPool.at(id);
             }
             const VariableState &FuzzingState::variableState(VariableId id) const
             {
                 return m_VariablesPool.at(id);
             }
             VariableState &FuzzingState::variableState(VariableId id)
             {
                 return m_VariablesPool.at(id);
             }
             SyncGroupId FuzzingState::syncGroupId(VariableId variableId) const
             {
                 auto end = m_SyncGroupsPool.cend();
                 auto it
                     = std::find_if(m_SyncGroupsPool.cbegin(), end, [&variableId](const auto &syncGroupEntry) {
                           const auto &syncGroup = syncGroupEntry.second;
                           return syncGroup.m_Variables.find(variableId) != syncGroup.m_Variables.end();
                       });
                 return it != end ? it->first : SyncGroupId{};
             }
             std::vector<SyncGroupId> FuzzingState::syncGroupsIds() const
             {
                 std::vector<SyncGroupId> result{};
                 for (const auto &entry : m_SyncGroupsPool) {
                     result.push_back(entry.first);
                 }
                 return result;
             }
             void FuzzingState::synchronizeVariable(VariableId variableId, SyncGroupId syncGroupId)
             {
                 if (syncGroupId.isNull()) {
                     return;
                 }
-                // Registers variable into sync group: if it's the first variable, sets the variable range as
+                // Registers variable into sync group
-                // the sync group range
                 auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
+                auto &variableState = m_VariablesPool.at(variableId);
                 syncGroup.m_Variables.insert(variableId);
                 if (syncGroup.m_Variables.size() == 1) {
-                    auto &variableState = m_VariablesPool.at(variableId);
+                    // If it's the first variable, sets the variable range as the sync group range
                     syncGroup.m_Range = variableState.m_Range;
                 }
+                else {
+                    // If a variable is added to an existing group, sets its range to the group's range
+                    variableState.m_Range = syncGroup.m_Range;
+                }
             }
             void FuzzingState::desynchronizeVariable(VariableId variableId, SyncGroupId syncGroupId)
             {
                 if (syncGroupId.isNull()) {
                     return;
                 }
                 // Unregisters variable from sync group: if there is no more variable in the group, resets the
                 // range
                 auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
                 syncGroup.m_Variables.erase(variableId);
                 if (syncGroup.m_Variables.empty()) {
                     syncGroup.m_Range = INVALID_RANGE;
                 }
             }
             void FuzzingState::updateRanges(VariableId variableId, const SqpRange &newRange)
             {
                 auto syncGroupId = this->syncGroupId(variableId);
                 // Retrieves the variables to update:
-                // - if the variable is synchronized to others, updates all synchronized variables
+                // - if the variable is synchronized to others, updates the range of the group and of all
+                // synchronized variables
                 // - otherwise, updates only the variable
-                auto variablesToUpdate = syncGroupId.isNull() ? std::set<VariableId>{variableId}
+                if (syncGroupId.isNull()) {
-                                                              : m_SyncGroupsPool.at(syncGroupId).m_Variables;
+                    m_VariablesPool.at(variableId).m_Range = newRange;
+                }
+                else {
+                    auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
+                    syncGroup.m_Range = newRange;
-                // Sets new range
+                    for (const auto &variableId : syncGroup.m_Variables) {
-                for (const auto &variableId : variablesToUpdate) {
                         m_VariablesPool.at(variableId).m_Range = newRange;
                     }
                 }
+            }

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

             #include "FuzzingOperations.h"
             #include "FuzzingUtils.h"
             #include <Data/IDataProvider.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QUuid>
             #include <functional>
             Q_LOGGING_CATEGORY(LOG_FuzzingOperations, "FuzzingOperations")
             namespace {
             struct CreateOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     // A variable can be created only if it doesn't exist yet
                     return fuzzingState.variableState(variableId).m_Variable == nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController,
                              const Properties &properties) const override
                 {
                     // Retrieves metadata pool from properties, and choose one of the metadata entries to
                     // associate it with the variable
                     auto metaDataPool = properties.value(METADATA_POOL_PROPERTY).value<MetadataPool>();
                     auto variableMetadata = RandomGenerator::instance().randomChoice(metaDataPool);
                     // Retrieves provider
                     auto variableProvider
                         = properties.value(PROVIDER_PROPERTY).value<std::shared_ptr<IDataProvider> >();
                     auto variableName = QString{"Var_%1"}.arg(QUuid::createUuid().toString());
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Creating variable" << variableName
                                                               << "(metadata:" << variableMetadata << ")...";
                     auto newVariable
                         = variableController.createVariable(variableName, variableMetadata, variableProvider);
                     // Updates variable's state
                     auto &variableState = fuzzingState.variableState(variableId);
                     variableState.m_Range = properties.value(INITIAL_RANGE_PROPERTY).value<SqpRange>();
                     std::swap(variableState.m_Variable, newVariable);
                 }
             };
             struct DeleteOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     // A variable can be delete only if it exists
                     return fuzzingState.variableState(variableId).m_Variable != nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Deleting variable"
                                                               << variableState.m_Variable->name() << "...";
                     variableController.deleteVariable(variableState.m_Variable);
                     // Updates variable's state
                     variableState.m_Range = INVALID_RANGE;
                     variableState.m_Variable = nullptr;
                     // Desynchronizes the variable if it was in a sync group
                     auto syncGroupId = fuzzingState.syncGroupId(variableId);
                     fuzzingState.desynchronizeVariable(variableId, syncGroupId);
                 }
             };
             /**
              * Defines a move operation through a range.
              *
              * A move operation is determined by three functions:
              * - Two 'move' functions, used to indicate in which direction the beginning and the end of a range
              * are going during the operation. These functions will be:
              * -- {<- / <-} for pan left
              * -- {-> / ->} for pan right
              * -- {-> / <-} for zoom in
              * -- {<- / ->} for zoom out
              * - One 'max move' functions, used to compute the max delta at which the operation can move a
              * range, according to a max range. For exemple, for a range of {1, 5} and a max range of {0, 10},
              * max deltas will be:
              * -- {0, 4} for pan left
              * -- {6, 10} for pan right
              * -- {3, 3} for zoom in
              * -- {0, 6} for zoom out (same spacing left and right)
              */
             struct MoveOperation : public IFuzzingOperation {
                 using MoveFunction = std::function<double(double currentValue, double maxValue)>;
                 using MaxMoveFunction = std::function<double(const SqpRange &range, const SqpRange &maxRange)>;
                 explicit MoveOperation(MoveFunction rangeStartMoveFun, MoveFunction rangeEndMoveFun,
                                        MaxMoveFunction maxMoveFun,
                                        const QString &label = QStringLiteral("Move operation"))
                         : m_RangeStartMoveFun{std::move(rangeStartMoveFun)},
                           m_RangeEndMoveFun{std::move(rangeEndMoveFun)},
                           m_MaxMoveFun{std::move(maxMoveFun)},
                           m_Label{label}
                 {
                 }
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     return fuzzingState.variableState(variableId).m_Variable != nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController,
                              const Properties &properties) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     auto variable = variableState.m_Variable;
                     // Gets the max range defined
                     auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
                                         .value<SqpRange>();
                     auto variableRange = variableState.m_Range;
                     if (maxRange == INVALID_RANGE || variableRange.m_TStart < maxRange.m_TStart
                         || variableRange.m_TEnd > maxRange.m_TEnd) {
                         qCWarning(LOG_FuzzingOperations()) << "Can't execute operation: invalid max range";
                         return;
                     }
                     // Computes the max delta at which the variable can move, up to the limits of the max range
                     auto deltaMax = m_MaxMoveFun(variableRange, maxRange);
                     // Generates random delta that will be used to move variable
                     auto delta = RandomGenerator::instance().generateDouble(0, deltaMax);
                     // Moves variable to its new range
                     auto isSynchronized = !fuzzingState.syncGroupId(variableId).isNull();
                     auto newVariableRange = SqpRange{m_RangeStartMoveFun(variableRange.m_TStart, delta),
                                                      m_RangeEndMoveFun(variableRange.m_TEnd, delta)};
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Performing" << m_Label << "on"
                                                               << variable->name() << "(from" << variableRange
                                                               << "to" << newVariableRange << ")...";
                     variableController.onRequestDataLoading({variable}, newVariableRange, isSynchronized);
                     // Updates state
                     fuzzingState.updateRanges(variableId, newVariableRange);
                 }
                 MoveFunction m_RangeStartMoveFun;
                 MoveFunction m_RangeEndMoveFun;
                 MaxMoveFunction m_MaxMoveFun;
                 QString m_Label;
             };
             struct SynchronizeOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     auto variable = fuzzingState.variableState(variableId).m_Variable;
                     return variable != nullptr && !fuzzingState.m_SyncGroupsPool.empty()
                            && fuzzingState.syncGroupId(variableId).isNull();
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     // Chooses a random synchronization group and adds the variable into sync group
                     auto syncGroupId = RandomGenerator::instance().randomChoice(fuzzingState.syncGroupsIds());
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Adding" << variableState.m_Variable->name()
                                                               << "into synchronization group" << syncGroupId
                                                               << "...";
                     variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
                     // Updates state
                     fuzzingState.synchronizeVariable(variableId, syncGroupId);
+                    variableController.onRequestDataLoading({variableState.m_Variable}, variableState.m_Range,
+                                                            false);
                 }
             };
             struct DesynchronizeOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     auto variable = fuzzingState.variableState(variableId).m_Variable;
                     return variable != nullptr && !fuzzingState.syncGroupId(variableId).isNull();
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     // Gets the sync group of the variable
                     auto syncGroupId = fuzzingState.syncGroupId(variableId);
                     qCInfo(LOG_FuzzingOperations()).noquote() << "Removing" << variableState.m_Variable->name()
                                                               << "from synchronization group" << syncGroupId
                                                               << "...";
-                    variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
+                    variableController.desynchronize(variableState.m_Variable, syncGroupId);
                     // Updates state
                     fuzzingState.desynchronizeVariable(variableId, syncGroupId);
                 }
             };
             struct UnknownOperation : public IFuzzingOperation {
                 bool canExecute(VariableId, const FuzzingState &) const override { return false; }
                 void execute(VariableId, FuzzingState &, VariableController &,
                              const Properties &) const override
                 {
                 }
             };
             } // namespace
             std::unique_ptr<IFuzzingOperation> FuzzingOperationFactory::create(FuzzingOperationType type)
             {
                 switch (type) {
                     case FuzzingOperationType::CREATE:
                         return std::make_unique<CreateOperation>();
                     case FuzzingOperationType::DELETE:
                         return std::make_unique<DeleteOperation>();
                     case FuzzingOperationType::PAN_LEFT:
                         return std::make_unique<MoveOperation>(
                             std::minus<double>(), std::minus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return range.m_TStart - maxRange.m_TStart;
                             },
                             QStringLiteral("Pan left operation"));
                     case FuzzingOperationType::PAN_RIGHT:
                         return std::make_unique<MoveOperation>(
                             std::plus<double>(), std::plus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return maxRange.m_TEnd - range.m_TEnd;
                             },
                             QStringLiteral("Pan right operation"));
                     case FuzzingOperationType::ZOOM_IN:
                         return std::make_unique<MoveOperation>(
                             std::plus<double>(), std::minus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 Q_UNUSED(maxRange)
                                 return range.m_TEnd - (range.m_TStart + range.m_TEnd) / 2.;
                             },
                             QStringLiteral("Zoom in operation"));
                     case FuzzingOperationType::ZOOM_OUT:
                         return std::make_unique<MoveOperation>(
                             std::minus<double>(), std::plus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return std::min(range.m_TStart - maxRange.m_TStart,
                                                 maxRange.m_TEnd - range.m_TEnd);
                             },
                             QStringLiteral("Zoom out operation"));
                     case FuzzingOperationType::SYNCHRONIZE:
                         return std::make_unique<SynchronizeOperation>();
                     case FuzzingOperationType::DESYNCHRONIZE:
                         return std::make_unique<DesynchronizeOperation>();
                     default:
                         // Default case returns unknown operation
                         break;
                 }
                 return std::make_unique<UnknownOperation>();
             }

plugins/amda/tests/FuzzingValidators.cpp +1 -1

             #include "FuzzingValidators.h"
             #include "FuzzingDefs.h"
             #include <Data/DataSeries.h>
             #include <Variable/Variable.h>
             #include <QTest>
             #include <functional>
             Q_LOGGING_CATEGORY(LOG_FuzzingValidators, "FuzzingValidators")
             namespace {
             // ////////////// //
             // DATA VALIDATOR //
             // ////////////// //
             /// Singleton used to validate data of a variable
             class DataValidatorHelper {
             public:
                 /// @return the single instance of the helper
                 static DataValidatorHelper &instance();
                 virtual ~DataValidatorHelper() noexcept = default;
                 virtual void validate(const VariableState &variableState) const = 0;
             };
             /**
              * Default implementation of @sa DataValidatorHelper
              */
             class DefaultDataValidatorHelper : public DataValidatorHelper {
             public:
                 void validate(const VariableState &variableState) const override
                 {
                     Q_UNUSED(variableState);
                     qCWarning(LOG_FuzzingValidators()).noquote() << "Checking variable's data... WARN: no data "
                                                                     "verification is available for this server";
                 }
             };
             /// Data resolution in local server's files
             const auto LOCALHOST_SERVER_RESOLUTION = 4;
             /// Reference value used to generate the data on the local server (a value is the number of seconds
             /// between the data date and this reference date)
             const auto LOCALHOST_REFERENCE_VALUE
                 = DateUtils::secondsSinceEpoch(QDateTime{QDate{2000, 1, 1}, QTime{}, Qt::UTC});
             /**
              * Implementation of @sa DataValidatorHelper for the local AMDA server
              */
             class LocalhostServerDataValidatorHelper : public DataValidatorHelper {
             public:
                 void validate(const VariableState &variableState) const override
                 {
                     // Don't check data for null variable
                     if (!variableState.m_Variable || variableState.m_Range == INVALID_RANGE) {
                         return;
                     }
                     auto message = "Checking variable's data...";
                     auto toDateString = [](double value) { return DateUtils::dateTime(value).toString(); };
                     // Checks that data are defined
                     auto variableDataSeries = variableState.m_Variable->dataSeries();
                     if (variableDataSeries == nullptr && variableState.m_Range != INVALID_RANGE) {
                         qCInfo(LOG_FuzzingValidators()).noquote()
                             << message << "FAIL: the variable has no data while a range is defined";
                         QFAIL("");
                     }
                     auto dataIts = variableDataSeries->xAxisRange(variableState.m_Range.m_TStart,
                                                                   variableState.m_Range.m_TEnd);
                     // Checks that the data are well defined in the range:
                     // - there is at least one data
                     // - the data are consistent (no data holes)
                     if (std::distance(dataIts.first, dataIts.second) == 0) {
                         qCInfo(LOG_FuzzingValidators()).noquote() << message
                                                                   << "FAIL: the variable has no data";
                         QFAIL("");
                     }
                     auto firstXAxisData = dataIts.first->x();
                     auto lastXAxisData = (dataIts.second - 1)->x();
                     if (std::abs(firstXAxisData - variableState.m_Range.m_TStart) > LOCALHOST_SERVER_RESOLUTION
                         || std::abs(lastXAxisData - variableState.m_Range.m_TEnd)
                                > LOCALHOST_SERVER_RESOLUTION) {
                         qCInfo(LOG_FuzzingValidators()).noquote()
                             << message << "FAIL: the data in the defined range are inconsistent (data hole "
                                           "found at the beginning or the end)";
                         QFAIL("");
                     }
                     auto dataHoleIt = std::adjacent_find(
                         dataIts.first, dataIts.second, [](const auto &it1, const auto &it2) {
                             /// @todo: validate resolution
-                            return std::abs(it1.x() - it2.x()) > 2 * (LOCALHOST_SERVER_RESOLUTION - 1);
+                            return std::abs(it1.x() - it2.x()) > 2 * LOCALHOST_SERVER_RESOLUTION;
                         });
                     if (dataHoleIt != dataIts.second) {
                         qCInfo(LOG_FuzzingValidators()).noquote()
                             << message << "FAIL: the data in the defined range are inconsistent (data hole "
                                           "found between times "
                             << toDateString(dataHoleIt->x()) << "and " << toDateString((dataHoleIt + 1)->x())
                             << ")";
                         QFAIL("");
                     }
                     // Checks values
                     auto dataIndex = 0;
                     for (auto dataIt = dataIts.first; dataIt != dataIts.second; ++dataIt, ++dataIndex) {
                         auto xAxisData = dataIt->x();
                         auto valuesData = dataIt->values();
                         for (auto valueIndex = 0, valueEnd = valuesData.size(); valueIndex < valueEnd;
                              ++valueIndex) {
                             auto value = valuesData.at(valueIndex);
                             auto expectedValue = xAxisData + valueIndex * LOCALHOST_SERVER_RESOLUTION
                                                  - LOCALHOST_REFERENCE_VALUE;
                             if (value != expectedValue) {
                                 qCInfo(LOG_FuzzingValidators()).noquote()
                                     << message << "FAIL: incorrect value data at time"
                                     << toDateString(xAxisData) << ", index" << valueIndex << "(found:" << value
                                     << ", expected:" << expectedValue << ")";
                                 QFAIL("");
                             }
                         }
                     }
                     // At this step validation is OK
                     qCInfo(LOG_FuzzingValidators()).noquote() << message << "OK";
                 }
             };
             /// Creates the @sa DataValidatorHelper according to the server passed in parameter
             std::unique_ptr<DataValidatorHelper> createDataValidatorInstance(const QString &server)
             {
                 if (server == QString{"localhost"}) {
                     return std::make_unique<LocalhostServerDataValidatorHelper>();
                 }
                 else {
                     return std::make_unique<DefaultDataValidatorHelper>();
                 }
             }
             DataValidatorHelper &DataValidatorHelper::instance()
             {
                 // Creates instance depending on the SCIQLOP_AMDA_SERVER value at compile time
                 static auto instance = createDataValidatorInstance(SCIQLOP_AMDA_SERVER);
                 return *instance;
             }
             // /////////////// //
             // RANGE VALIDATOR //
             // /////////////// //
             /**
              * Checks that a range of a variable matches the expected range passed as a parameter
              * @param variable the variable for which to check the range
              * @param expectedRange the expected range
              * @param getVariableRangeFun the function to retrieve the range from the variable
              * @remarks if the variable is null, checks that the expected range is the invalid range
              */
             void validateRange(std::shared_ptr<Variable> variable, const SqpRange &expectedRange,
                                std::function<SqpRange(const Variable &)> getVariableRangeFun)
             {
                 auto compare = [](const auto &range, const auto &expectedRange, const auto &message) {
                     if (range == expectedRange) {
                         qCInfo(LOG_FuzzingValidators()).noquote() << message << "OK";
                     }
                     else {
                         qCInfo(LOG_FuzzingValidators()).noquote() << message << "FAIL (current range:" << range
                                                                   << ", expected range:" << expectedRange
                                                                   << ")";
                         QFAIL("");
                     }
                 };
                 if (variable) {
                     compare(getVariableRangeFun(*variable), expectedRange, "Checking variable's range...");
                 }
                 else {
                     compare(INVALID_RANGE, expectedRange, "Checking that there is no range set...");
                 }
             }
             /**
              * Default implementation of @sa IFuzzingValidator. This validator takes as parameter of its
              * construction a function of validation which is called in the validate() method
              */
             class FuzzingValidator : public IFuzzingValidator {
             public:
                 /// Signature of a validation function
                 using ValidationFunction = std::function<void(const VariableState &variableState)>;
                 explicit FuzzingValidator(ValidationFunction fun) : m_Fun(std::move(fun)) {}
                 void validate(const VariableState &variableState) const override { m_Fun(variableState); }
             private:
                 ValidationFunction m_Fun;
             };
             } // namespace
             std::unique_ptr<IFuzzingValidator> FuzzingValidatorFactory::create(FuzzingValidatorType type)
             {
                 switch (type) {
                     case FuzzingValidatorType::DATA:
                         return std::make_unique<FuzzingValidator>([](const VariableState &variableState) {
                             DataValidatorHelper::instance().validate(variableState);
                         });
                     case FuzzingValidatorType::RANGE:
                         return std::make_unique<FuzzingValidator>([](const VariableState &variableState) {
                             auto getVariableRange = [](const Variable &variable) { return variable.range(); };
                             validateRange(variableState.m_Variable, variableState.m_Range, getVariableRange);
                         });
                     default:
                         // Default case returns invalid validator
                         break;
                 }
                 // Invalid validator
                 return std::make_unique<FuzzingValidator>(
                     [](const VariableState &) { QFAIL("Invalid validator"); });
             }

plugins/amda/tests/TestAmdaFuzzing.cpp +4 0

             #include "FuzzingDefs.h"
             #include "FuzzingOperations.h"
             #include "FuzzingUtils.h"
             #include "FuzzingValidators.h"
             #include "AmdaProvider.h"
             #include <Common/SignalWaiter.h>
             #include <Network/NetworkController.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             Q_LOGGING_CATEGORY(LOG_TestAmdaFuzzing, "TestAmdaFuzzing")
             /**
              * Macro used to generate a getter for a property in @sa FuzzingTest. The macro generates a static
              * attribute that is initialized by searching in properties the property and use a default value if
              * it's not present. Macro arguments are:
              * - GETTER_NAME : name of the getter
              * - PROPERTY_NAME: used to generate constants for property's name ({PROPERTY_NAME}_PROPERTY) and
              * default value ({PROPERTY_NAME}_DEFAULT_VALUE)
              * - TYPE : return type of the getter
              */
             // clang-format off
             #define DECLARE_PROPERTY_GETTER(GETTER_NAME, PROPERTY_NAME, TYPE)  \
             TYPE GETTER_NAME() const \
             { \
                 static auto result = m_Properties.value(PROPERTY_NAME##_PROPERTY, PROPERTY_NAME##_DEFAULT_VALUE).value<TYPE>(); \
                 return result; \
             } \
             // clang-format on
             namespace {
             // /////// //
             // Aliases //
             // /////// //
             using IntPair = std::pair<int, int>;
             using Weight = double;
             using Weights = std::vector<Weight>;
             struct OperationProperty {
                 Weight m_Weight{1.};
                 bool m_WaitAcquisition{false};
             };
             using VariableOperation = std::pair<VariableId, std::shared_ptr<IFuzzingOperation> >;
             using VariablesOperations = std::vector<VariableOperation>;
             using OperationsTypes = std::map<FuzzingOperationType, OperationProperty>;
             using OperationsPool = std::map<std::shared_ptr<IFuzzingOperation>, OperationProperty>;
             using Validators = std::vector<std::shared_ptr<IFuzzingValidator> >;
             // ///////// //
             // Constants //
             // ///////// //
             // Defaults values used when the associated properties have not been set for the test
             const auto ACQUISITION_TIMEOUT_DEFAULT_VALUE = 30000;
             const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;
             const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 1;
             const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 1;
             const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE = QVariant::fromValue(
                 OperationsTypes{{FuzzingOperationType::CREATE, {1., true}},
                                 {FuzzingOperationType::DELETE, {0.1}}, // Delete operation is less frequent
                                 {FuzzingOperationType::PAN_LEFT, {1.}},
                                 {FuzzingOperationType::PAN_RIGHT, {1.}},
                                 {FuzzingOperationType::ZOOM_IN, {1.}},
                                 {FuzzingOperationType::ZOOM_OUT, {1.}},
                                 {FuzzingOperationType::SYNCHRONIZE, {0.8}},
                                 {FuzzingOperationType::DESYNCHRONIZE, {0.4}}});
             const auto CACHE_TOLERANCE_DEFAULT_VALUE = 0.2;
             /// Min/max delays between each operation (in ms)
             const auto OPERATION_DELAY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(100, 3000));
             /// Validators for the tests (executed in the order in which they're defined)
             const auto VALIDATORS_DEFAULT_VALUE = QVariant::fromValue(
                 ValidatorsTypes{{FuzzingValidatorType::RANGE, FuzzingValidatorType::DATA}});
             /// Min/max number of operations to execute before calling validation
             const auto VALIDATION_FREQUENCY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(1, 10));
             // /////// //
             // Methods //
             // /////// //
             /// Goes through the variables pool and operations pool to determine the set of {variable/operation}
             /// pairs that are valid (i.e. operation that can be executed on variable)
             std::pair<VariablesOperations, Weights> availableOperations(const FuzzingState &fuzzingState,
                                                                         const OperationsPool &operationsPool)
             {
                 VariablesOperations result{};
                 Weights weights{};
                 for (const auto &variablesPoolEntry : fuzzingState.m_VariablesPool) {
                     auto variableId = variablesPoolEntry.first;
                     for (const auto &operationsPoolEntry : operationsPool) {
                         auto operation = operationsPoolEntry.first;
                         auto operationProperty = operationsPoolEntry.second;
                         // A pair is valid if the current operation can be executed on the current variable
                         if (operation->canExecute(variableId, fuzzingState)) {
                             result.push_back({variableId, operation});
                             weights.push_back(operationProperty.m_Weight);
                         }
                     }
                 }
                 return {result, weights};
             }
             OperationsPool createOperationsPool(const OperationsTypes &types)
             {
                 OperationsPool result{};
                 std::transform(
                     types.cbegin(), types.cend(), std::inserter(result, result.end()), [](const auto &type) {
                         return std::make_pair(FuzzingOperationFactory::create(type.first), type.second);
                     });
                 return result;
             }
             Validators createValidators(const ValidatorsTypes &types)
             {
                 Validators result{};
                 std::transform(types.cbegin(), types.cend(), std::inserter(result, result.end()),
                                [](const auto &type) { return FuzzingValidatorFactory::create(type); });
                 return result;
             }
             /**
              * Validates all the variables' states passed in parameter, according to a set of validators
              * @param variablesPool the variables' states
              * @param validators the validators used for validation
              */
             void validate(const VariablesPool &variablesPool, const Validators &validators)
             {
                 for (const auto &variablesPoolEntry : variablesPool) {
                     auto variableId = variablesPoolEntry.first;
                     const auto &variableState = variablesPoolEntry.second;
                     auto variableMessage = variableState.m_Variable ? variableState.m_Variable->name()
                                                                     : QStringLiteral("null variable");
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Validating state of variable at index"
                                                             << variableId << "(" << variableMessage << ")...";
                     for (const auto &validator : validators) {
                         validator->validate(VariableState{variableState});
                     }
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Validation completed.";
                 }
             }
             /**
              * Class to run random tests
              */
             class FuzzingTest {
             public:
                 explicit FuzzingTest(VariableController &variableController, Properties properties)
                         : m_VariableController{variableController},
                           m_Properties{std::move(properties)},
                           m_FuzzingState{}
                 {
                     // Inits variables pool: at init, all variables are null
                     for (auto variableId = 0; variableId < nbMaxVariables(); ++variableId) {
                         m_FuzzingState.m_VariablesPool[variableId] = VariableState{};
                     }
                     // Inits sync groups and registers them into the variable controller
                     for (auto i = 0; i < nbMaxSyncGroups(); ++i) {
                         auto syncGroupId = SyncGroupId::createUuid();
                         variableController.onAddSynchronizationGroupId(syncGroupId);
                         m_FuzzingState.m_SyncGroupsPool[syncGroupId] = SyncGroup{};
                     }
                 }
                 void execute()
                 {
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Running" << nbMaxOperations() << "operations on"
                                                             << nbMaxVariables() << "variable(s)...";
                     // Inits the count of the number of operations before the next validation
                     int nextValidationCounter = 0;
                     auto updateValidationCounter = [this, &nextValidationCounter]() {
                         nextValidationCounter = RandomGenerator::instance().generateInt(
                             validationFrequencies().first, validationFrequencies().second);
                         qCInfo(LOG_TestAmdaFuzzing()).noquote()
                             << "Next validation in " << nextValidationCounter << "operation(s)...";
                     };
                     updateValidationCounter();
                     auto canExecute = true;
                     for (auto i = 0; i < nbMaxOperations() && canExecute; ++i) {
                         // Retrieves all operations that can be executed in the current context
                         VariablesOperations variableOperations{};
                         Weights weights{};
                         std::tie(variableOperations, weights)
                             = availableOperations(m_FuzzingState, operationsPool());
                         canExecute = !variableOperations.empty();
                         if (canExecute) {
                             --nextValidationCounter;
                             // Of the operations available, chooses a random operation and executes it
                             auto variableOperation
                                 = RandomGenerator::instance().randomChoice(variableOperations, weights);
                             auto variableId = variableOperation.first;
                             auto fuzzingOperation = variableOperation.second;
                             auto waitAcquisition = nextValidationCounter == 0
                                                    || operationsPool().at(fuzzingOperation).m_WaitAcquisition;
                             fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
                                                       m_Properties);
                             if (waitAcquisition) {
                                 qCDebug(LOG_TestAmdaFuzzing()) << "Waiting for acquisition to finish...";
                                 SignalWaiter{m_VariableController, SIGNAL(acquisitionFinished())}.wait(
                                     acquisitionTimeout());
                                 // Validates variables
                                 if (nextValidationCounter == 0) {
                                     validate(m_FuzzingState.m_VariablesPool, validators());
                                     updateValidationCounter();
                                 }
                             }
                             else {
                                 // Delays the next operation with a randomly generated time
                                 auto delay = RandomGenerator::instance().generateInt(operationDelays().first,
                                                                                      operationDelays().second);
                                 qCDebug(LOG_TestAmdaFuzzing())
                                     << "Waiting " << delay << "ms before the next operation...";
                                 QTest::qWait(delay);
                             }
                         }
                         else {
                             qCInfo(LOG_TestAmdaFuzzing()).noquote()
                                 << "No more operations are available, the execution of the test will stop...";
                         }
                     }
                     qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Execution of the test completed.";
                 }
             private:
                 OperationsPool operationsPool() const
                 {
                     static auto result = createOperationsPool(
                         m_Properties.value(AVAILABLE_OPERATIONS_PROPERTY, AVAILABLE_OPERATIONS_DEFAULT_VALUE)
                             .value<OperationsTypes>());
                     return result;
                 }
                 Validators validators() const
                 {
                     static auto result
                         = createValidators(m_Properties.value(VALIDATORS_PROPERTY, VALIDATORS_DEFAULT_VALUE)
                                                .value<ValidatorsTypes>());
                     return result;
                 }
                 DECLARE_PROPERTY_GETTER(nbMaxOperations, NB_MAX_OPERATIONS, int)
                 DECLARE_PROPERTY_GETTER(nbMaxSyncGroups, NB_MAX_SYNC_GROUPS, int)
                 DECLARE_PROPERTY_GETTER(nbMaxVariables, NB_MAX_VARIABLES, int)
                 DECLARE_PROPERTY_GETTER(operationDelays, OPERATION_DELAY_BOUNDS, IntPair)
                 DECLARE_PROPERTY_GETTER(validationFrequencies, VALIDATION_FREQUENCY_BOUNDS, IntPair)
                 DECLARE_PROPERTY_GETTER(acquisitionTimeout, ACQUISITION_TIMEOUT, int)
                 VariableController &m_VariableController;
                 Properties m_Properties;
                 FuzzingState m_FuzzingState;
             };
             } // namespace
             Q_DECLARE_METATYPE(OperationsTypes)
             class TestAmdaFuzzing : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input data for @sa testFuzzing()
                 void testFuzzing_data();
                 void testFuzzing();
             };
             void TestAmdaFuzzing::testFuzzing_data()
             {
                 // Note: Comment this line to run fuzzing tests
                 QSKIP("Fuzzing tests are disabled by default");
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 QTest::addColumn<Properties>("properties"); // Properties for random test
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto maxRange = SqpRange::fromDateTime({2017, 1, 1}, {0, 0}, {2017, 1, 5}, {0, 0});
                 MetadataPool metadataPool{{{"dataType", "vector"}, {"xml:id", "imf"}}};
                 // Note: we don't use auto here as we want to pass std::shared_ptr<IDataProvider> as is in the
                 // QVariant
                 std::shared_ptr<IDataProvider> provider = std::make_shared<AmdaProvider>();
                 QTest::newRow("fuzzingTest") << Properties{
                     {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
                     {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
                     {PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
             }
             void TestAmdaFuzzing::testFuzzing()
             {
                 QFETCH(Properties, properties);
                 // Sets cache property
                 QSettings settings{};
                 auto cacheTolerance = properties.value(CACHE_TOLERANCE_PROPERTY, CACHE_TOLERANCE_DEFAULT_VALUE);
                 settings.setValue(GENERAL_TOLERANCE_AT_INIT_KEY, cacheTolerance);
                 settings.setValue(GENERAL_TOLERANCE_AT_UPDATE_KEY, cacheTolerance);
                 auto &variableController = sqpApp->variableController();
                 auto &timeController = sqpApp->timeController();
                 // Generates random initial range (bounded to max range)
                 auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
                                     .value<SqpRange>();
                 QVERIFY(maxRange != INVALID_RANGE);
                 auto initialRangeStart
                     = RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
                 auto initialRangeEnd
                     = RandomGenerator::instance().generateDouble(maxRange.m_TStart, maxRange.m_TEnd);
                 if (initialRangeStart > initialRangeEnd) {
                     std::swap(initialRangeStart, initialRangeEnd);
                 }
                 // Sets initial range on time controller
                 SqpRange initialRange{initialRangeStart, initialRangeEnd};
                 qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Setting initial range to" << initialRange << "...";
                 timeController.onTimeToUpdate(initialRange);
                 properties.insert(INITIAL_RANGE_PROPERTY, QVariant::fromValue(initialRange));
                 FuzzingTest test{variableController, properties};
                 test.execute();
             }
             int main(int argc, char *argv[])
             {
+                // Increases the test function timeout (which is 5 minutes by default) to 12 hours
+                // https://stackoverflow.com/questions/42655932/setting-timeout-to-qt-test
+                qputenv("QTEST_FUNCTION_TIMEOUT", QByteArray::number(12*60*60*1000));
                 QLoggingCategory::setFilterRules(
                     "*.warning=false\n"
                     "*.info=false\n"
                     "*.debug=false\n"
                     "FuzzingOperations.info=true\n"
                     "FuzzingValidators.info=true\n"
                     "TestAmdaFuzzing.info=true\n");
                 SqpApplication app{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop-TestFuzzing");
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestAmdaFuzzing testObject{};
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&testObject, argc, argv);
             }
             #include "TestAmdaFuzzing.moc"

General Comments 0

Write
Preview

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

No TODOs yet

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

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