HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r808:5353ec1e417b

Improve cosinus tests with:...

perrinel -

r808:5353ec1e417b

parent child

Context file:

r808:5353ec1e417b

plugins/mockplugin/include/CosinusProvider.h +5 0

             #ifndef SCIQLOP_COSINUSPROVIDER_H
             #define SCIQLOP_COSINUSPROVIDER_H
             #include "MockPluginGlobal.h"
             #include <Data/IDataProvider.h>
             #include <QLoggingCategory>
             #include <QUuid>
             #include <QHash>
             Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
             /**
              * @brief The CosinusProvider class is an example of how a data provider can generate data
              */
             class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
             public:
                 std::shared_ptr<IDataProvider> clone() const override;
                 /// @sa IDataProvider::requestDataLoading(). The current impl isn't thread safe.
                 void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override;
                 /// @sa IDataProvider::requestDataAborting(). The current impl isn't thread safe.
                 void requestDataAborting(QUuid acqIdentifier) override;
+                /// Provide data
+                std::shared_ptr<IDataSeries> provideDataSeries(const SqpRange &dataRangeRequested,
+                                                               const QVariantHash &data);
             private:
                 std::shared_ptr<IDataSeries>
                 retrieveData(QUuid acqIdentifier, const SqpRange &dataRangeRequested, const QVariantHash &data);
                 QHash<QUuid, bool> m_VariableToEnableProvider;
             };
             #endif // SCIQLOP_COSINUSPROVIDER_H

plugins/mockplugin/src/CosinusProvider.cpp +14 -2

             #include "CosinusProvider.h"
             #include "MockDefs.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <Data/VectorSeries.h>
             #include <cmath>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             namespace {
             /// Abstract cosinus type
             struct ICosinusType {
                 virtual ~ICosinusType() = default;
                 /// @return the number of components generated for the type
                 virtual int componentCount() const = 0;
                 /// @return the data series created for the type
                 virtual std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
                                                                       std::vector<double> valuesData,
                                                                       Unit xAxisUnit,
                                                                       Unit valuesUnit) const = 0;
             };
             struct ScalarCosinus : public ICosinusType {
                 int componentCount() const override { return 1; }
                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData, Unit xAxisUnit,
                                                               Unit valuesUnit) const override
                 {
                     return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                           xAxisUnit, valuesUnit);
                 }
             };
             struct VectorCosinus : public ICosinusType {
                 int componentCount() const override { return 3; }
                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData, Unit xAxisUnit,
                                                               Unit valuesUnit) const override
                 {
                     return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(valuesData),
                                                           xAxisUnit, valuesUnit);
                 }
             };
             /// Converts string to cosinus type
             /// @return the cosinus type if the string could be converted, nullptr otherwise
             std::unique_ptr<ICosinusType> cosinusType(const QString &type) noexcept
             {
                 if (type.compare(QStringLiteral("scalar"), Qt::CaseInsensitive) == 0) {
                     return std::make_unique<ScalarCosinus>();
                 }
                 else if (type.compare(QStringLiteral("vector"), Qt::CaseInsensitive) == 0) {
                     return std::make_unique<VectorCosinus>();
                 }
                 else {
                     return nullptr;
                 }
             }
             } // namespace
             std::shared_ptr<IDataProvider> CosinusProvider::clone() const
             {
                 // No copy is made in clone
                 return std::make_shared<CosinusProvider>();
             }
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
                                                                        const SqpRange &dataRangeRequested,
                                                                        const QVariantHash &data)
             {
                 // TODO: Add Mutex
                 auto dataIndex = 0;
                 // Retrieves cosinus type
                 auto typeVariant = data.value(COSINUS_TYPE_KEY, COSINUS_TYPE_DEFAULT_VALUE);
                 if (!typeVariant.canConvert<QString>()) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: invalid type");
                     return nullptr;
                 }
                 auto type = cosinusType(typeVariant.toString());
                 if (!type) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: unknown type");
                     return nullptr;
                 }
                 // Retrieves frequency
                 auto freqVariant = data.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);
                 if (!freqVariant.canConvert<double>()) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: invalid frequency");
                     return nullptr;
                 }
                 // Gets the timerange from the parameters
                 double freq = freqVariant.toDouble();
                 double start = std::ceil(dataRangeRequested.m_TStart * freq);
                 double end = std::floor(dataRangeRequested.m_TEnd * freq);
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second, end value is
                 // included)
                 auto dataCount = end - start + 1;
                 // Number of components (depending on the cosinus type)
                 auto componentCount = type->componentCount();
                 auto xAxisData = std::vector<double>{};
                 xAxisData.resize(dataCount);
                 auto valuesData = std::vector<double>{};
                 valuesData.resize(dataCount * componentCount);
                 int progress = 0;
                 auto progressEnd = dataCount;
                 for (auto time = start; time <= end; ++time, ++dataIndex) {
                     auto it = m_VariableToEnableProvider.find(acqIdentifier);
                     if (it != m_VariableToEnableProvider.end() && it.value()) {
                         const auto timeOnFreq = time / freq;
                         xAxisData[dataIndex] = timeOnFreq;
                         // Generates all components' values
                         // Example: for a vector, values will be : cos(x), cos(x)/2, cos(x)/3
                         auto value = std::cos(timeOnFreq);
                         for (auto i = 0; i < componentCount; ++i) {
                             valuesData[componentCount * dataIndex + i] = value / (i + 1);
                         }
                         // progression
                         int currentProgress = (time - start) * 100.0 / progressEnd;
                         if (currentProgress != progress) {
                             progress = currentProgress;
                             emit dataProvidedProgress(acqIdentifier, progress);
-                            qCInfo(LOG_CosinusProvider()) << "TORM: CosinusProvider::retrieveData"
+                            qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::retrieveData"
-                                                          << QThread::currentThread()->objectName() << progress;
+                                                           << QThread::currentThread()->objectName()
+                                                           << progress;
                             // NOTE: Try to use multithread if possible
                         }
                     }
                     else {
                         if (!it.value()) {
                             qCDebug(LOG_CosinusProvider())
                                 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
                                 << end - time;
                         }
                     }
                 }
                 if (progress != 100) {
                     // We can close progression beacause all data has been retrieved
                     emit dataProvidedProgress(acqIdentifier, 100);
                 }
                 return type->createDataSeries(std::move(xAxisData), std::move(valuesData),
                                               Unit{QStringLiteral("t"), true}, Unit{});
             }
             void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
                                                      const DataProviderParameters &parameters)
             {
                 // TODO: Add Mutex
                 m_VariableToEnableProvider[acqIdentifier] = true;
                 qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::requestDataLoading"
                                                << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 for (const auto &dateTime : qAsConst(times)) {
                     if (m_VariableToEnableProvider[acqIdentifier]) {
                         auto scalarSeries = this->retrieveData(acqIdentifier, dateTime, parameters.m_Data);
                         qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::dataProvided";
                         emit dataProvided(acqIdentifier, scalarSeries, dateTime);
                     }
                 }
             }
             void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 // TODO: Add Mutex
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
                                                << QThread::currentThread()->objectName();
                 auto it = m_VariableToEnableProvider.find(acqIdentifier);
                 if (it != m_VariableToEnableProvider.end()) {
                     it.value() = false;
                 }
                 else {
                     qCWarning(LOG_CosinusProvider())
                         << tr("Aborting progression of inexistant identifier detected !!!");
                 }
             }
+            std::shared_ptr<IDataSeries> CosinusProvider::provideDataSeries(const SqpRange &dataRangeRequested,
+                                                                            const QVariantHash &data)
+            {
+                auto uid = QUuid::createUuid();
+                m_VariableToEnableProvider[uid] = true;
+                auto dataSeries = this->retrieveData(uid, dataRangeRequested, data);
+                m_VariableToEnableProvider.remove(uid);
+                return dataSeries;
+            }

plugins/mockplugin/tests/TestCosinusAcquisition.cpp +48 -47

             #include "CosinusProvider.h"
             #include "MockDefs.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QObject>
             #include <QtTest>
             #include <cmath>
             #include <memory>
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH = QFileInfo{
                 QString{MOCKPLUGIN_TESTS_RESOURCES_DIR},
                 "TestCosinusAcquisition"}.absoluteFilePath();
             /// Format of dates in data files
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
-            /// Delay after each operation on the variable before validating it (in ms)
-            const auto OPERATION_DELAY = 250;
             /**
              * Verifies that the data in the candidate series are identical to the data in the reference series
              * in a specific range
              * @param candidate the candidate data series
              * @param range the range to check
              * @param reference the reference data series
              * @return true if the data of the candidate series and the reference series are identical in the
              * range, false otherwise
              */
             bool checkDataSeries(std::shared_ptr<IDataSeries> candidate, const SqpRange &range,
                                  std::shared_ptr<IDataSeries> reference)
             {
                 if (candidate == nullptr || reference == nullptr) {
                     return candidate == reference;
                 }
                 auto referenceIt = reference->xAxisRange(range.m_TStart, range.m_TEnd);
+                qInfo() << "candidateSize" << std::distance(candidate->cbegin(), candidate->cend());
+                qInfo() << "refSize" << std::distance(referenceIt.first, referenceIt.second);
                 return std::equal(candidate->cbegin(), candidate->cend(), referenceIt.first, referenceIt.second,
                                   [](const auto &it1, const auto &it2) {
                                       // - milliseconds precision for time
                                       // - 1e-6 precision for value
                                       return std::abs(it1.x() - it2.x()) < 1e-3
                                              && std::abs(it1.value() - it2.value()) < 1e-6;
                                   });
             }
-            /// Generates the data series from the reading of a data stream
-            std::shared_ptr<IDataSeries> readDataStream(QTextStream &stream)
-                std::vector<double> xAxisData, valuesData;
-                QString line{};
-                while (stream.readLineInto(&line)) {
-                    // Separates date (x-axis data) to value data
-                    auto splitLine = line.split('\t');
-                    if (splitLine.size() == 2) {
-                        // Converts datetime to double
-                        auto dateTime = QDateTime::fromString(splitLine[0], DATETIME_FORMAT);
-                        dateTime.setTimeSpec(Qt::UTC);
-                        xAxisData.push_back(DateUtils::secondsSinceEpoch(dateTime));
-                        valuesData.push_back(splitLine[1].toDouble());
-                return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
-                                                      Unit{{}, true}, Unit{});
             } // namespace
             /**
              * @brief The TestCosinusAcquisition class tests acquisition in SciQlop (operations like zooms in,
              * zooms out, pans) of data from CosinusProvider
              * @sa CosinusProvider
              */
             class TestCosinusAcquisition : public QObject {
                 Q_OBJECT
             private slots:
                 /// Input data for @sa testAcquisition()
                 void testAcquisition_data();
                 void testAcquisition();
             };
             void TestCosinusAcquisition::testAcquisition_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
-                QTest::addColumn<QString>("dataFilename");  // File containing expected data of acquisitions
+                QTest::addColumn<SqpRange>("referenceRange");           // Range for generating reference series
                 QTest::addColumn<SqpRange>("initialRange");             // First acquisition
+                QTest::addColumn<int>("operationDelay");                // Acquisitions to make
                 QTest::addColumn<std::vector<SqpRange> >("operations"); // Acquisitions to make
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 auto dateTime = [](int year, int month, int day, int hours, int minutes, int seconds) {
                     return DateUtils::secondsSinceEpoch(
                         QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC});
                 };
                 QTest::newRow("cosinus")
-                    << "Cosinus_100Hz_20170101_1200_20170101_1300.txt"
+                    << SqpRange{dateTime(2017, 1, 1, 12, 0, 0), dateTime(2017, 1, 1, 13, 0, 0)}
-                    << SqpRange{dateTime(2017, 1, 1, 12, 30, 0), dateTime(2017, 1, 1, 12, 35, 1)}
+                    << SqpRange{dateTime(2017, 1, 1, 12, 30, 0), dateTime(2017, 1, 1, 12, 35, 1)} << 250
                     << std::vector<SqpRange>{
                            // Pan (jump) left
                            SqpRange{dateTime(2017, 1, 1, 12, 45, 0), dateTime(2017, 1, 1, 12, 50, 0)},
                            // Pan (jump) right
                            SqpRange{dateTime(2017, 1, 1, 12, 15, 0), dateTime(2017, 1, 1, 12, 20, 0)},
                            // Pan (overlay) right
                            SqpRange{dateTime(2017, 1, 1, 12, 14, 0), dateTime(2017, 1, 1, 12, 19, 0)},
                            // Pan (overlay) left
                            SqpRange{dateTime(2017, 1, 1, 12, 15, 0), dateTime(2017, 1, 1, 12, 20, 0)},
                            // Pan (overlay) left
                            SqpRange{dateTime(2017, 1, 1, 12, 16, 0), dateTime(2017, 1, 1, 12, 21, 0)},
                            // Zoom in
                            SqpRange{dateTime(2017, 1, 1, 12, 17, 30), dateTime(2017, 1, 1, 12, 19, 30)},
                            // Zoom out
                            SqpRange{dateTime(2017, 1, 1, 12, 12, 30), dateTime(2017, 1, 1, 12, 24, 30)}};
+                QTest::newRow("cosinus_big")
+                    << SqpRange{dateTime(2017, 1, 1, 1, 0, 0), dateTime(2017, 1, 5, 13, 0, 0)}
+                    << SqpRange{dateTime(2017, 1, 2, 6, 30, 0), dateTime(2017, 1, 2, 18, 30, 0)} << 5000
+                    << std::vector<SqpRange>{
+                           // Pan (jump) left
+                           SqpRange{dateTime(2017, 1, 1, 13, 30, 0), dateTime(2017, 1, 1, 18, 30, 0)},
+                           // Pan (jump) right
+                           SqpRange{dateTime(2017, 1, 3, 4, 30, 0), dateTime(2017, 1, 3, 10, 30, 0)},
+                           // Pan (overlay) right
+                           SqpRange{dateTime(2017, 1, 3, 8, 30, 0), dateTime(2017, 1, 3, 12, 30, 0)},
+                           // Pan (overlay) left
+                           SqpRange{dateTime(2017, 1, 2, 8, 30, 0), dateTime(2017, 1, 3, 10, 30, 0)},
+                           // Pan (overlay) left
+                           SqpRange{dateTime(2017, 1, 1, 12, 30, 0), dateTime(2017, 1, 3, 5, 30, 0)},
+                           // Zoom in
+                           SqpRange{dateTime(2017, 1, 2, 2, 30, 0), dateTime(2017, 1, 2, 8, 30, 0)},
+                           // Zoom out
+                           SqpRange{dateTime(2017, 1, 1, 14, 30, 0), dateTime(2017, 1, 3, 12, 30, 0)}};
             }
             void TestCosinusAcquisition::testAcquisition()
             {
-                // Retrieves data file
+                // Retrieves reference range
-                QFETCH(QString, dataFilename);
+                QFETCH(SqpRange, referenceRange);
+                CosinusProvider referenceProvider{};
-                auto dataFilePath = QFileInfo{TESTS_RESOURCES_PATH, dataFilename}.absoluteFilePath();
+                auto dataSeries = referenceProvider.provideDataSeries(
-                QFile dataFile{dataFilePath};
+                    referenceRange, {{COSINUS_TYPE_KEY, "scalar"}, {COSINUS_FREQUENCY_KEY, 100.}});
-                if (dataFile.open(QFile::ReadOnly)) {
+                auto end = dataSeries->cend() - 1;
-                    // Generates data series to compare with
+                qInfo() << dataSeries->nbPoints() << dataSeries->cbegin()->x() << end->x();
-                    QTextStream dataStream{&dataFile};
-                    auto dataSeries = readDataStream(dataStream);
                 /// Lambda used to validate a variable at each step
-                    auto validateVariable = [dataSeries](std::shared_ptr<Variable> variable,
+                auto validateVariable
-                                                         const SqpRange &range) {
+                    = [dataSeries](std::shared_ptr<Variable> variable, const SqpRange &range) {
                           // Checks that the variable's range has changed
                           QCOMPARE(variable->range(), range);
                           // Checks the variable's data series
                           QVERIFY(checkDataSeries(variable->dataSeries(), variable->cacheRange(), dataSeries));
                       };
                 // Creates variable
                 QFETCH(SqpRange, initialRange);
                 sqpApp->timeController().onTimeToUpdate(initialRange);
                 auto provider = std::make_shared<CosinusProvider>();
                 auto variable = sqpApp->variableController().createVariable(
                     "MMS", {{COSINUS_TYPE_KEY, "scalar"}, {COSINUS_FREQUENCY_KEY, 100.}}, provider);
-                    QTest::qWait(OPERATION_DELAY);
+                QFETCH(int, operationDelay);
+                QTest::qWait(operationDelay);
                 validateVariable(variable, initialRange);
                 // Makes operations on the variable
                 QFETCH(std::vector<SqpRange>, operations);
                 for (const auto &operation : operations) {
                     // Asks request on the variable and waits during its execution
-                        sqpApp->variableController().onRequestDataLoading({variable}, operation,
+                    sqpApp->variableController().onRequestDataLoading({variable}, operation, variable->range(),
-                                                                          variable->range(), true);
+                                                                      true);
-                        QTest::qWait(OPERATION_DELAY);
+                    QTest::qWait(operationDelay);
                     validateVariable(variable, operation);
                 }
+                for (const auto &operation : operations) {
+                    // Asks request on the variable and waits during its execution
+                    sqpApp->variableController().onRequestDataLoading({variable}, operation, variable->range(),
+                                                                      true);
                 }
-                else {
+                QTest::qWait(operationDelay);
-                    QFAIL("Can't read input data file");
+                validateVariable(variable, operations.back());
             }
             int main(int argc, char *argv[])
             {
                 SqpApplication app{argc, argv};
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestCosinusAcquisition testObject{};
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&testObject, argc, argv);
             }
             #include "TestCosinusAcquisition.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