HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r30:02d2d8643fcb

Fixed tests due to async var creation, plus minor stuff...

jeandet -

r30:02d2d8643fcb

parent child

Context file:

r30:02d2d8643fcb

include/Data/DataProviderParameters.h +1 -1

             #ifndef SCIQLOP_DATAPROVIDERPARAMETERS_H
             #define SCIQLOP_DATAPROVIDERPARAMETERS_H
             #include "DateTimeRange.h"
             /**
              * @brief The DataProviderParameters struct holds the information needed to retrieve data from a
              * data provider
              * @sa IDataProvider
              */
             struct DataProviderParameters {
                 /// Times for which retrieve data
-                QVector<DateTimeRange> m_Times;
+                DateTimeRange m_Range;
                 /// Extra data that can be used by the provider to retrieve data
                 QVariantHash m_Data;
             };
             #endif // SCIQLOP_DATAPROVIDERPARAMETERS_H

include/Variable/VariableController2.h +2 -3

             #ifndef VARIABLECONTROLLER2_H
             #define VARIABLECONTROLLER2_H
             #include <memory>
             #include <vector>
             #include <set>
             #include <QHash>
             #include <QObject>
             #include <QMutexLocker>
             #include <QUuid>
             #include <QByteArray>
             #include <QItemSelectionModel>
             #include <Common/spimpl.h>
             #include <Variable/Variable.h>
             #include <Data/IDataProvider.h>
             #include "Data/DateTimeRange.h"
             class VariableController2: public QObject
             {
                 class VariableController2Private;
                 Q_OBJECT
                 spimpl::unique_impl_ptr<VariableController2Private> impl;
             public:
                 explicit VariableController2();
                 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata,
                                                          const std::shared_ptr<IDataProvider>& provider,
                                                          const DateTimeRange &range);
                 std::shared_ptr<Variable> cloneVariable(const std::shared_ptr<Variable>& variable);
                 void deleteVariable(const std::shared_ptr<Variable>& variable);
                 void changeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
                 void asyncChangeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
                 const std::vector<std::shared_ptr<Variable>> variables();
                 bool isReady(const std::shared_ptr<Variable>& variable);
+                bool isReady();
                 void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with);
                 const std::vector<std::shared_ptr<Variable>> variables(const std::vector<QUuid>& ids);
-                const std::shared_ptr<Variable>& operator[] (int index) const;
-                std::shared_ptr<Variable> operator[] (int index);
             signals:
                 void variableAdded(const std::shared_ptr<Variable>&);
                 void variableDeleted(const std::shared_ptr<Variable>&);
             };
             #endif //VARIABLECONTROLLER2_H

include/Variable/VariableModel2.h +2 0

             #ifndef SCIQLOP_VARIABLEMODEL2_H
             #define SCIQLOP_VARIABLEMODEL2_H
             #include "CoreGlobal.h"
             #include <Data/DateTimeRange.h>
             #include <QAbstractTableModel>
             #include <QLoggingCategory>
             #include <Common/MetaTypes.h>
             #include <Common/spimpl.h>
             class IDataSeries;
             class Variable;
             class VariableController2;
             enum VariableRoles { ProgressRole = Qt::UserRole };
             /**
              * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
              */
             class SCIQLOP_CORE_EXPORT VariableModel2 : public QAbstractTableModel {
                 Q_OBJECT
                 // read only mirror of VariableController2 content
                 std::vector<std::shared_ptr<Variable>> _variables;
             public:
                 explicit VariableModel2(QObject *parent = nullptr);
                 // /////////////////////////// //
                 // QAbstractTableModel methods //
                 // /////////////////////////// //
                 virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
                 virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
                 virtual QVariant headerData(int section, Qt::Orientation orientation,
                                             int role = Qt::DisplayRole) const override;
                 virtual Qt::ItemFlags flags(const QModelIndex &index) const override;
                 // ///////////////// //
                 // Drag&Drop methods //
                 // ///////////////// //
                 virtual Qt::DropActions supportedDropActions() const override;
                 virtual Qt::DropActions supportedDragActions() const override;
                 virtual QStringList mimeTypes() const override;
                 virtual QMimeData *mimeData(const QModelIndexList &indexes) const override;
                 virtual bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                              const QModelIndex &parent) const override;
                 virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                           const QModelIndex &parent) override;
+                const std::vector<std::shared_ptr<Variable>>& variables() const
+                {return _variables;}
             signals:
                 void createVariable(const QVariantHash &productData);
                 void asyncChangeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
             public slots:
                 /// Slot called when data of a variable has been updated
                 void variableUpdated() noexcept;
                 void variableAdded(const std::shared_ptr<Variable>&);
                 void variableDeleted(const std::shared_ptr<Variable>&);
             };
             #endif // SCIQLOP_VARIABLEMODEL2_H

src/Variable/VariableController2.cpp +17 -11

             #include <QQueue>
             #include <QThreadPool>
             #include <QRunnable>
             #include <QObject>
             #include <QDataStream>
             #include "Variable/VariableController2.h"
             #include "Variable/VariableSynchronizationGroup2.h"
             #include <Common/containers.h>
             #include <Common/debug.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRangeHelper.h>
             #include <Data/DateTimeRange.h>
             #include <Variable/VariableCacheStrategyFactory.h>
             #include <Variable/private/VCTransaction.h>
             #include <QCoreApplication>
             class VariableController2::VariableController2Private
             {
                 struct threadSafeVaraiblesMaps
                 {
                     inline void addVariable(const std::shared_ptr<Variable>& variable, const std::shared_ptr<IDataProvider>& provider, const std::shared_ptr<VariableSynchronizationGroup2>& synchronizationGroup)
                     {
                         QWriteLocker lock{&_lock};
                         _variables[*variable] = variable;
                         _providers[*variable] = provider;
                         _synchronizationGroups[*variable] = synchronizationGroup;
                     }
                     inline void removeVariable(const std::shared_ptr<Variable>& variable)
                     {
                         QWriteLocker lock{&_lock};
                         _variables.erase(*variable);
                         _providers.remove(*variable);
                         _synchronizationGroups.remove(*variable);
                     }
                     inline void synchronize(const std::shared_ptr<Variable>& variable, const std::optional<std::shared_ptr<Variable>>& with)
                     {
                         QWriteLocker lock{&_lock};
                         if(with.has_value())
                         {
                             auto newGroup = _synchronizationGroups[*with.value()];
                             newGroup->addVariable(*variable);
                             _synchronizationGroups[*variable] = newGroup;
                         }
                         else
                         {
                             _synchronizationGroups[*variable] = std::make_shared<VariableSynchronizationGroup2>(*variable);
                         }
                     }
                     inline std::shared_ptr<Variable> variable(QUuid variable)
                     {
                         QReadLocker lock{&_lock};
                         auto it = _variables.find(variable);
                         [[unlikely]]
                         if(it==_variables.end())
                             SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
                         return (*it).second;
                     }
                     inline std::shared_ptr<Variable> variable(int index)
                     {
                         QReadLocker lock{&_lock};
                         [[unlikely]]
                         if(!_variables.size() > index)
                             SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Index is out of bounds");
                         auto it = _variables.cbegin();
                         while (index!=0) {
                             index-=1;
                             it++;
                         }
                         return (*it).second;
                     }
                     inline const std::vector<std::shared_ptr<Variable>> variables()
                     {
                         std::vector<std::shared_ptr<Variable>> vars;
                         QReadLocker lock{&_lock};
                         for(const auto&[id, var]:_variables)
                         {
                             vars.push_back(var);
                         }
                         return  vars;
                     }
                     inline std::shared_ptr<IDataProvider> provider(QUuid variable)
                     {
                         QReadLocker lock{&_lock};
                         [[unlikely]]
                         if(!_providers.contains(variable))
                             SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
                         return _providers[variable];
                     }
                     inline std::shared_ptr<VariableSynchronizationGroup2> group(QUuid variable)
                     {
                         QReadLocker lock{&_lock};
                         [[unlikely]]
                         if(!_synchronizationGroups.contains(variable))
                             SCIQLOP_ERROR(threadSafeVaraiblesMaps,"Unknown Variable");
                         return _synchronizationGroups[variable];
                     }
                     inline bool has(const std::shared_ptr<Variable>& variable)
                     {
                         QReadLocker lock{&_lock};
                         return _variables.find(*variable)==_variables.end();
                     }
                 private:
                     std::map<QUuid,std::shared_ptr<Variable>> _variables;
                     QMap<QUuid,std::shared_ptr<IDataProvider>> _providers;
                     QMap<QUuid,std::shared_ptr<VariableSynchronizationGroup2>> _synchronizationGroups;
                     QReadWriteLock _lock{QReadWriteLock::Recursive};
                 }_maps;
                 QThreadPool* _ThreadPool;
                 VCTransactionsQueues _transactions;
                 std::unique_ptr<VariableCacheStrategy> _cacheStrategy;
                 void _transactionComplete(QUuid group, std::shared_ptr<VCTransaction> transaction)
                 {
                     if(transaction->done())
                     {
                         _transactions.complete(group);
                     }
                     this->_processTransactions();
                 }
                 void _processTransactions()
                 {
                     auto nextTransactions = _transactions.nextTransactions();
                     auto pendingTransactions = _transactions.pendingTransactions();
                     for( auto [groupID, newTransaction] : nextTransactions)
                     {
                         if(newTransaction.has_value() && !pendingTransactions[groupID].has_value())
                         {
                             _transactions.start(groupID);
                             auto refVar = _maps.variable(newTransaction.value()->refVar);
                             auto ranges = _computeAllRangesInGroup(refVar,newTransaction.value()->range);
                             for( auto const& [ID, range] : ranges)
                             {
                                 auto provider = _maps.provider(ID);
                                 auto variable = _maps.variable(ID);
                                 auto [missingRanges, newCacheRange] = _computeMissingRanges(variable,range);
                                 auto exe = new TransactionExe(variable, provider, missingRanges, range, newCacheRange);
                                 QObject::connect(exe,
                                         &TransactionExe::transactionComplete,
                                         [groupID=groupID,transaction=newTransaction.value(),this]()
                                         {
                                             this->_transactionComplete(groupID, transaction);
                                         }
                                 );
                                 _ThreadPool->start(exe);
                             }
                         }
                     }
                 }
                 std::map<QUuid,DateTimeRange> _computeAllRangesInGroup(const std::shared_ptr<Variable>& refVar, DateTimeRange r)
                 {
                     std::map<QUuid,DateTimeRange> ranges;
                     if(!DateTimeRangeHelper::hasnan(r))
                     {
                         auto group = _maps.group(*refVar);
                         if(auto transformation = DateTimeRangeHelper::computeTransformation(refVar->range(),r);
                                 transformation.has_value())
                         {
                             for(auto varId:group->variables())
                             {
                                 auto var = _maps.variable(varId);
                                 auto newRange = var->range().transform(transformation.value());
                                 ranges[varId] = newRange;
                             }
                         }
                         else // force new range to all variables -> may be weird if more than one var in the group
                             // @TODO ensure that there is no side effects
                         {
                             for(auto varId:group->variables())
                             {
                                 auto var = _maps.variable(varId);
                                 ranges[varId] = r;
                             }
                         }
                     }
                     else
                     {
                         SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
                     }
                     return ranges;
                 }
                 std::pair<std::vector<DateTimeRange>,DateTimeRange> _computeMissingRanges(const std::shared_ptr<Variable>& var, DateTimeRange r)
                 {
                     DateTimeRange newCacheRange;
                     std::vector<DateTimeRange> missingRanges;
                     if(DateTimeRangeHelper::hasnan(var->cacheRange()))
                     {
                         newCacheRange = _cacheStrategy->computeRange(r,r);
                         missingRanges = {newCacheRange};
                     }
                     else
                     {
                         newCacheRange = _cacheStrategy->computeRange(var->cacheRange(),r);
                         missingRanges = newCacheRange - var->cacheRange();
                     }
                     return {missingRanges,newCacheRange};
                 }
                 void _changeRange(QUuid id, DateTimeRange r)
                 {
                     _changeRange(_maps.variable(id) ,r);
                 }
                 void _changeRange(const std::shared_ptr<Variable>& var, DateTimeRange r)
                 {
                     auto provider = _maps.provider(*var);
                     auto [missingRanges, newCacheRange] = _computeMissingRanges(var,r);
                     std::vector<IDataSeries*> data;
                     for(auto range:missingRanges)
                     {
                         data.push_back(provider->getData(DataProviderParameters{{range}, var->metadata()}));
                     }
                     var->updateData(data, r, newCacheRange, true);
                 }
             public:
                 VariableController2Private(QObject* parent=Q_NULLPTR)
                     :_cacheStrategy(VariableCacheStrategyFactory::createCacheStrategy(CacheStrategy::SingleThreshold))
                 {
                     Q_UNUSED(parent);
                     this->_ThreadPool = new QThreadPool();
                     this->_ThreadPool->setMaxThreadCount(32);
                 }
                 /*
                  * This dtor has to like this even if this is ugly, because default dtor would rely on
                  * declaration order to destruct members and that would always lead to regressions when
                  * modifying class members
                 */
                 ~VariableController2Private()
                 {
                     delete this->_ThreadPool;
                 }
                 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider)
                 {
                     auto newVar = std::make_shared<Variable>(name,metadata);
                     auto group = std::make_shared<VariableSynchronizationGroup2>(newVar->ID());
                     _maps.addVariable(newVar,std::move(provider),group);
                     this->_transactions.addEntry(*group);
                     return newVar;
                 }
                 std::shared_ptr<Variable> variable(QUuid ID)
                 {
                     return _maps.variable(ID);
                 }
                 std::shared_ptr<Variable> variable(int index)
                 {
                     return _maps.variable(index);
                 }
                 std::shared_ptr<Variable> cloneVariable(const std::shared_ptr<Variable>& variable)
                 {
                     auto newVar = variable->clone();
                     _maps.synchronize(newVar,std::nullopt);
                     _maps.addVariable(newVar,_maps.provider(*variable),_maps.group(*newVar));
                     this->_transactions.addEntry(*_maps.group(*newVar));
                     return newVar;
                 }
                 bool hasPendingTransactions(const std::shared_ptr<Variable>& variable)
                 {
                     return _transactions.active(*_maps.group(*variable));
                 }
+                bool hasPendingTransactions()
+                {
+                    bool has = false;
+                    for(const auto& var:_maps.variables())
+                    {
+                        has |= _transactions.active(*_maps.group(*var));
+                    }
+                    return has;
+                }
                 void deleteVariable(const std::shared_ptr<Variable>& variable)
                 {
                     _maps.removeVariable(variable);
                 }
                 void asyncChangeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r)
                 {
                     if(!DateTimeRangeHelper::hasnan(r))
                     {
                         auto group = _maps.group(*variable);
                         // Just overwrite next transaction
                         {
                             _transactions.enqueue(*group,std::make_shared<VCTransaction>(variable->ID(), r, static_cast<int>(group->variables().size())));
                         }
                         _processTransactions();
                     }
                     else
                     {
                         SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
                     }
                 }
                 void changeRange(const std::shared_ptr<Variable>& variable, DateTimeRange r)
                 {
                     asyncChangeRange(variable,r);
                     while (hasPendingTransactions(variable))
                     {
                         QCoreApplication::processEvents();
                     }
                 }
                 inline void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with)
                 {
                     _maps.synchronize(var, with);
                 }
                 inline const std::vector<std::shared_ptr<Variable>> variables()
                 {
                     return _maps.variables();
                 }
             };
             VariableController2::VariableController2()
                 :impl{spimpl::make_unique_impl<VariableController2Private>()}
             {}
             std::shared_ptr<Variable> VariableController2::createVariable(const QString &name, const QVariantHash &metadata, const std::shared_ptr<IDataProvider>& provider, const DateTimeRange &range)
             {
                 auto var =  impl->createVariable(name, metadata, provider);
+                var->setRange(range); // even with no data this is it's range
                 emit variableAdded(var);
                 if(!DateTimeRangeHelper::hasnan(range))
                     impl->asyncChangeRange(var,range);
                 else
                     SCIQLOP_ERROR(VariableController2, "Creating a variable with default constructed DateTimeRange is an error");
                 return var;
             }
             std::shared_ptr<Variable> VariableController2::cloneVariable(const std::shared_ptr<Variable> &variable)
             {
                 return impl->cloneVariable(variable);
             }
             void VariableController2::deleteVariable(const std::shared_ptr<Variable>& variable)
             {
                 impl->deleteVariable(variable);
                 emit variableDeleted(variable);
             }
             void VariableController2::changeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r)
             {
                 impl->changeRange(variable, r);
             }
             void VariableController2::asyncChangeRange(const std::shared_ptr<Variable> &variable, const DateTimeRange &r)
             {
                 impl->asyncChangeRange(variable, r);
             }
             const std::vector<std::shared_ptr<Variable> > VariableController2::variables()
             {
                 return impl->variables();
             }
             bool VariableController2::isReady(const std::shared_ptr<Variable> &variable)
             {
-                return impl->hasPendingTransactions(variable);
+                return !impl->hasPendingTransactions(variable);
+            }
+            bool VariableController2::isReady()
+            {
+                return !impl->hasPendingTransactions();
             }
             void VariableController2::synchronize(const std::shared_ptr<Variable> &var, const std::shared_ptr<Variable> &with)
             {
                 impl->synchronize(var, with);
             }
             const std::vector<std::shared_ptr<Variable>> VariableController2::variables(const std::vector<QUuid> &ids)
             {
                 std::vector<std::shared_ptr<Variable>> variables;
                 for (const auto& id : ids) {
                     variables.push_back(impl->variable(id));
                 }
                 return variables;
             }
-            const std::shared_ptr<Variable> &VariableController2::operator[](int index) const
-                return impl->variable (index);
-            std::shared_ptr<Variable> VariableController2::operator[](int index)
-                return impl->variable (index);

tests/TestUtils/TestProviders.h +2 -2

             #ifndef TESTPROVIDER_H
             #define TESTPROVIDER_H
             #include <memory>
             #include <cmath>
             #include <algorithm>
             #include <numeric>
             #include <QUuid>
             #include <QtGlobal>
             #include <QtTest>
             #include <Data/IDataProvider.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/DataSeries.h>
             #include <Data/ScalarSeries.h>
             #include <Variable/Variable.h>
             template<int slope>
             class SimpleRange: public IDataProvider
             {
             public:
                 SimpleRange() = default;
                 int callCounter = 0;
                 std::shared_ptr<IDataProvider> clone() const override{ return std::make_shared<SimpleRange>(); }
                 IDataSeries* getData(const DataProviderParameters &parameters) override
                 {
                     callCounter+=1;
-                    auto tstart = parameters.m_Times[0].m_TStart;
+                    auto tstart = parameters.m_Range.m_TStart;
-                    auto tend = parameters.m_Times[0].m_TEnd;
+                    auto tend = parameters.m_Range.m_TEnd;
                     std::vector<double> x;
                     std::vector<double> y;
                     for(double i = ceil(tstart);i<=floor(tend);i+=1.) //1 seconde data resolution
                     {
                         x.push_back(i);
                         y.push_back(i*slope);
                     }
                     auto serie = new ScalarSeries(std::move(x),std::move(y),Unit("Secondes",true),Unit("Volts",false));
                     return serie;
                 }
             };
             template <class T>
             auto sumdiff(T begin, T end)
             {
                 std::vector<double> diff_vect(end-begin-1);
                 auto diff = [](auto next,auto item)
                 {
                     return  next.value() - item.value();
                 };
                 std::transform (begin+1, end, begin, diff_vect.begin(),diff);
                 return  std::accumulate(diff_vect.cbegin(), diff_vect.cend(), 0);
             }
             template <int slope=1>
             struct RangeType
             {
                 static void check_properties(std::shared_ptr<Variable> v, DateTimeRange r)
                 {
                     auto bounds = v->dataSeries()->valuesBounds(r.m_TStart, r.m_TEnd);
                     auto s = sumdiff(bounds.first, bounds.second) / slope;
                     auto nbpoints = bounds.second - bounds.first+1.;
                     QCOMPARE(nbpoints, int(s)+2);//<- @TODO weird has to be investigated why +2?
                     QCOMPARE(bounds.first->x(), bounds.first->value()/slope);
                 }
             };
             template <class T>
             void check_variable_state(std::shared_ptr<Variable> v, DateTimeRange r)
             {
                 auto bounds = v->dataSeries()->valuesBounds(r.m_TStart, r.m_TEnd);
                 //generated data has to be inside range
                 QVERIFY(bounds.first->x() >= r.m_TStart);
                 QVERIFY(bounds.second->x() <= r.m_TEnd);
                 T::check_properties(v,r);
             }
             #endif

tests/Variable/TestVariableController2.cpp +2 0

             #include <cmath>
             #include <algorithm>
             #include <numeric>
             #include <QtTest>
             #include <QObject>
             #include <Variable/VariableController2.h>
             #include <Data/DateTimeRange.h>
             #include <Data/IDataProvider.h>
             #include <Data/ScalarSeries.h>
             #include <Data/DataProviderParameters.h>
             #include <Common/containers.h>
             #include <TestUtils/TestProviders.h>
             #define TEST_VC2_FIXTURE(slope) \
                 VariableController2 vc; \
                 auto provider = std::make_shared<SimpleRange<slope>>();\
             #define TEST_VC2_CREATE_DEFAULT_VAR(name)\
                 auto range = DateTimeRange::fromDateTime(QDate(2018,8,7),QTime(14,00),\
                                                       QDate(2018,8,7),QTime(16,00));\
                 auto name = vc.createVariable("name", {}, provider, range);\
+                while(!vc.isReady(name))QCoreApplication::processEvents();\
             Q_DECLARE_METATYPE(DateTimeRangeTransformation);
             class TestVariableController2 : public QObject
             {
                 Q_OBJECT
             public:
                 explicit TestVariableController2(QObject *parent = nullptr) : QObject(parent){}
             signals:
             private slots:
                 void initTestCase(){}
                 void cleanupTestCase(){}
                 void testCreateVariable()
                 {
                     TEST_VC2_FIXTURE(2);
                     auto range = DateTimeRange::fromDateTime(QDate(2018,8,7),QTime(14,00),
                                                              QDate(2018,8,7),QTime(16,00));
                     bool callbackCalled = false;
                     connect(&vc,&VariableController2::variableAdded, [&callbackCalled](std::shared_ptr<Variable>){callbackCalled=true;});
                     QVERIFY(!callbackCalled);
                     auto var1 = vc.createVariable("var1", {}, provider, range);
                     QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
                     QVERIFY(callbackCalled);
                 }
                 void testDeleteVariable()
                 {
                     TEST_VC2_FIXTURE(1);
                     auto range = DateTimeRange::fromDateTime(QDate(2018,8,7),QTime(14,00),
                                                              QDate(2018,8,7),QTime(16,00));
                     bool callbackCalled = false;
                     connect(&vc,&VariableController2::variableDeleted, [&callbackCalled](std::shared_ptr<Variable>){callbackCalled=true;});
                     auto var1 = vc.createVariable("var1", {}, provider, range);
+                    while(!vc.isReady(var1))QCoreApplication::processEvents();
                     QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
                     QVERIFY(!callbackCalled);
                     vc.deleteVariable(var1);
                     QVERIFY(!SciQLop::containers::contains(vc.variables(), var1));
                     QVERIFY(callbackCalled);
                 }
                 void testGetData()
                 {
                     TEST_VC2_FIXTURE(10);
                     TEST_VC2_CREATE_DEFAULT_VAR(var1);
                     check_variable_state<RangeType<10>>(var1, range);
                 }
                 void testZoom_data()
                 {
                     QTest::addColumn<double>("zoom");
                     QTest::newRow("Zoom IN 10x") << .1;
                     QTest::newRow("Zoom OUT 10x")  << 10.;
                     QTest::newRow("Zoom IN 1x")  << 1.;
                 }
                 void testZoom()
                 {
                     TEST_VC2_FIXTURE(100);
                     TEST_VC2_CREATE_DEFAULT_VAR(var1);
                     check_variable_state<RangeType<100>>(var1, range);
                     QFETCH(double, zoom);
                     range *=zoom;
                     vc.changeRange(var1, range);
                     check_variable_state<RangeType<100>>(var1, range);
                 }
                 void testPan_data()
                 {
                     QTest::addColumn<double>("pan");
                     QTest::newRow("Right 1000 seconds") << 1000.;
                     QTest::newRow("Left 1000 seconds")  << -1000.;
                     QTest::newRow("Right 0.1 seconds") << .1;
                     QTest::newRow("Left 0.1 seconds")  << -.1;
                 }
                 void testPan()
                 {
                     TEST_VC2_FIXTURE(10);
                     TEST_VC2_CREATE_DEFAULT_VAR(var1);
                     check_variable_state<RangeType<10>>(var1, range);
                     QFETCH(double, pan);
                     range += Seconds<double>{pan};
                     vc.changeRange(var1, range);
                     check_variable_state<RangeType<10>>(var1, range);
                 }
                 void testCache_data()
                 {
                     QTest::addColumn<DateTimeRangeTransformation>("transformation");
                     QTest::addColumn<int>("expectedIncrement");
                     QTest::newRow("zoom in") << DateTimeRangeTransformation{0.8,Seconds<double>(0.)} << 0;
                     QTest::newRow("tiny zoom out")  << DateTimeRangeTransformation{1.01,Seconds<double>(0.)} << 0;
                     QTest::newRow("just under cache zoom out")  << DateTimeRangeTransformation{2.0/1.1,Seconds<double>(0.)} << 0;
                     QTest::newRow("just over cache zoom out")  << DateTimeRangeTransformation{2.001/1.1, Seconds<double>(0.)} << 2;
                     QTest::newRow("tiny pan left") << DateTimeRangeTransformation{1.,Seconds<double>(-100.)} << 0;
                     QTest::newRow("tiny pan right")  << DateTimeRangeTransformation{1.,Seconds<double>(100.)} << 0;
                 }
                 void testCache()
                 {
                     TEST_VC2_FIXTURE(10);
                     TEST_VC2_CREATE_DEFAULT_VAR(var1);
                     check_variable_state<RangeType<10>>(var1, range);
                     QFETCH(DateTimeRangeTransformation, transformation);
                     QFETCH(int, expectedIncrement);
                     auto initialCount = provider->callCounter;
                     range = range.transform(transformation);
                     vc.changeRange(var1, range);
                     check_variable_state<RangeType<10>>(var1, range);
                     QCOMPARE(provider->callCounter-initialCount, expectedIncrement);
                 }
             };
             QTEST_MAIN(TestVariableController2)
             #include "TestVariableController2.moc"

tests/Variable/TestVariableController2WithSync.cpp +2 0

             #include <cmath>
             #include <algorithm>
             #include <numeric>
             #include <QtTest>
             #include <QObject>
             #include <Variable/VariableController2.h>
             #include <Data/DateTimeRange.h>
             #include <Data/IDataProvider.h>
             #include <Data/ScalarSeries.h>
             #include <Data/DataProviderParameters.h>
             #include <Common/containers.h>
             #include <TestUtils/TestProviders.h>
             #define TEST_VC2_FIXTURE(slope) \
                 VariableController2 vc; \
                 auto provider = std::make_shared<SimpleRange<slope>>();\
             #define TEST_VC2_CREATE_DEFAULT_VARS(name1, name2, name3)\
                 auto range = DateTimeRange::fromDateTime(QDate(2018,8,7),QTime(14,00),\
                                                       QDate(2018,8,7),QTime(16,00));\
                 auto name1 = vc.createVariable("name1", {}, provider, range);\
+                while(!vc.isReady(name1))QCoreApplication::processEvents();\
                 auto name2 = vc.cloneVariable(name1);\
                 auto name3 = vc.cloneVariable(name2);\
                 vc.synchronize(name1,name2);\
+                while(!vc.isReady(name1))QCoreApplication::processEvents();\
             class TestVariableController2WithSync : public QObject
             {
                 Q_OBJECT
             public:
                 explicit TestVariableController2WithSync(QObject *parent = nullptr) : QObject(parent){}
             signals:
             private slots:
                 void initTestCase(){}
                 void cleanupTestCase(){}
                 void testCreateVariable()
                 {
                     TEST_VC2_FIXTURE(2);
                     auto range = DateTimeRange::fromDateTime(QDate(2018,8,7),QTime(14,00),
                                                              QDate(2018,8,7),QTime(16,00));
                     bool callbackCalled = false;
                     connect(&vc,&VariableController2::variableAdded, [&callbackCalled](std::shared_ptr<Variable>){callbackCalled=true;});
                     QVERIFY(!callbackCalled);
                     auto var1 = vc.createVariable("var1", {}, provider, range);
                     QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
                     QVERIFY(callbackCalled);
                 }
                 void testDeleteVariable()
                 {
                     TEST_VC2_FIXTURE(1);
                     auto range = DateTimeRange::fromDateTime(QDate(2018,8,7),QTime(14,00),
                                                              QDate(2018,8,7),QTime(16,00));
                     bool callbackCalled = false;
                     connect(&vc,&VariableController2::variableDeleted, [&callbackCalled](std::shared_ptr<Variable>){callbackCalled=true;});
                     auto var1 = vc.createVariable("var1", {}, provider, range);
                     QVERIFY(SciQLop::containers::contains(vc.variables(), var1));
                     QVERIFY(!callbackCalled);
                     vc.deleteVariable(var1);
                     QVERIFY(!SciQLop::containers::contains(vc.variables(), var1));
                     QVERIFY(callbackCalled);
                 }
                 void testGetData()
                 {
                     TEST_VC2_FIXTURE(10);
                     TEST_VC2_CREATE_DEFAULT_VARS(var1,var2,var3);
                     check_variable_state<RangeType<10>>(var1, range);
                     auto newRange = var2->range()*1.5 + Seconds<double>{1000.};
                     vc.changeRange(var2, newRange);
                     check_variable_state<RangeType<10>>(var1, newRange);
                     check_variable_state<RangeType<10>>(var2, newRange);
                     check_variable_state<RangeType<10>>(var3, range);
                 }
                 void testZoom_data()
                 {
                     QTest::addColumn<double>("zoom");
                     QTest::newRow("Zoom IN 10x") << .1;
                     QTest::newRow("Zoom OUT 10x")  << 10.;
                     QTest::newRow("Zoom IN 1x")  << 1.;
                 }
                 void testZoom()
                 {
                     TEST_VC2_FIXTURE(100);
                     TEST_VC2_CREATE_DEFAULT_VARS(var1,var2,var3);
                     check_variable_state<RangeType<100>>(var1, range);
                     QFETCH(double, zoom);
                     range *=zoom;
                     vc.changeRange(var1, range);
                     check_variable_state<RangeType<100>>(var1, range);
                     check_variable_state<RangeType<100>>(var2, range);
                 }
                 void testPan_data()
                 {
                     QTest::addColumn<double>("pan");
                     QTest::newRow("Right 1000 seconds") << 1000.;
                     QTest::newRow("Left 1000 seconds")  << -1000.;
                     QTest::newRow("Right 0.1 seconds") << .1;
                     QTest::newRow("Left 0.1 seconds")  << -.1;
                 }
                 void testPan()
                 {
                     TEST_VC2_FIXTURE(10);
                     TEST_VC2_CREATE_DEFAULT_VARS(var1,var2,var3);
                     check_variable_state<RangeType<10>>(var1, range);
                     QFETCH(double, pan);
                     range += Seconds<double>{pan};
                     vc.changeRange(var1, range);
                     check_variable_state<RangeType<10>>(var1, range);
                     check_variable_state<RangeType<10>>(var2, range);
                 }
             };
             QTEST_MAIN(TestVariableController2WithSync)
             #include "TestVariableController2WithSync.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