diff --git a/core/include/Data/ArrayData.h b/core/include/Data/ArrayData.h
index 5cd885b..f33f0a5 100644
--- a/core/include/Data/ArrayData.h
+++ b/core/include/Data/ArrayData.h
@@ -77,6 +77,13 @@ public:
             }
         }
 
+        void prev()
+        {
+            for (auto &it : m_Its) {
+                --it;
+            }
+        }
+
         bool operator==(const IteratorValue &other) const { return m_Its == other.m_Its; }
 
     private:
@@ -105,6 +112,12 @@ public:
             return *this;
         }
 
+        Iterator &operator--()
+        {
+            m_CurrentValue.prev();
+            return *this;
+        }
+
         pointer operator->() const { return &m_CurrentValue; }
         reference operator*() const { return m_CurrentValue; }
 
diff --git a/core/include/Data/DataSeries.h b/core/include/Data/DataSeries.h
index f2fcd2a..da79366 100644
--- a/core/include/Data/DataSeries.h
+++ b/core/include/Data/DataSeries.h
@@ -21,6 +21,57 @@ inline const QLoggingCategory &LOG_DataSeries()
     return category;
 }
 
+template <int Dim>
+class DataSeries;
+
+namespace dataseries_detail {
+
+template <int Dim>
+class IteratorValue : public DataSeriesIteratorValue::Impl {
+public:
+    explicit IteratorValue(const DataSeries<Dim> &dataSeries, bool begin)
+            : m_XIt(begin ? dataSeries.xAxisData()->cbegin() : dataSeries.xAxisData()->cend()),
+              m_ValuesIt(begin ? dataSeries.valuesData()->cbegin()
+                               : dataSeries.valuesData()->cend())
+    {
+    }
+    IteratorValue(const IteratorValue &other) = default;
+
+    std::unique_ptr<DataSeriesIteratorValue::Impl> clone() const override
+    {
+        return std::make_unique<IteratorValue<Dim> >(*this);
+    }
+
+    bool equals(const DataSeriesIteratorValue::Impl &other) const override try {
+        const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
+        return std::tie(m_XIt, m_ValuesIt) == std::tie(otherImpl.m_XIt, otherImpl.m_ValuesIt);
+    }
+    catch (const std::bad_cast &) {
+        return false;
+    }
+
+    void next() override
+    {
+        ++m_XIt;
+        ++m_ValuesIt;
+    }
+
+    void prev() override
+    {
+        --m_XIt;
+        --m_ValuesIt;
+    }
+
+    double x() const override { return m_XIt->at(0); }
+    double value() const override { return m_ValuesIt->at(0); }
+    double value(int componentIndex) const override { return m_ValuesIt->at(componentIndex); }
+
+private:
+    ArrayData<1>::Iterator m_XIt;
+    typename ArrayData<Dim>::Iterator m_ValuesIt;
+};
+} // namespace dataseries_detail
+
 /**
  * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
  *
@@ -34,71 +85,6 @@ inline const QLoggingCategory &LOG_DataSeries()
 template <int Dim>
 class SCIQLOP_CORE_EXPORT DataSeries : public IDataSeries {
 public:
-    class IteratorValue {
-    public:
-        explicit IteratorValue(const DataSeries &dataSeries, bool begin)
-                : m_XIt(begin ? dataSeries.xAxisData()->cbegin() : dataSeries.xAxisData()->cend()),
-                  m_ValuesIt(begin ? dataSeries.valuesData()->cbegin()
-                                   : dataSeries.valuesData()->cend())
-        {
-        }
-
-        double x() const { return m_XIt->at(0); }
-        double value() const { return m_ValuesIt->at(0); }
-        double value(int componentIndex) const { return m_ValuesIt->at(componentIndex); }
-
-        void next()
-        {
-            ++m_XIt;
-            ++m_ValuesIt;
-        }
-
-        bool operator==(const IteratorValue &other) const
-        {
-            return std::tie(m_XIt, m_ValuesIt) == std::tie(other.m_XIt, other.m_ValuesIt);
-        }
-
-    private:
-        ArrayData<1>::Iterator m_XIt;
-        typename ArrayData<Dim>::Iterator m_ValuesIt;
-    };
-
-    class Iterator {
-    public:
-        using iterator_category = std::forward_iterator_tag;
-        using value_type = const IteratorValue;
-        using difference_type = std::ptrdiff_t;
-        using pointer = value_type *;
-        using reference = value_type &;
-
-        Iterator(const DataSeries &dataSeries, bool begin) : m_CurrentValue{dataSeries, begin} {}
-        virtual ~Iterator() noexcept = default;
-        Iterator(const Iterator &) = default;
-        Iterator(Iterator &&) = default;
-        Iterator &operator=(const Iterator &) = default;
-        Iterator &operator=(Iterator &&) = default;
-
-        Iterator &operator++()
-        {
-            m_CurrentValue.next();
-            return *this;
-        }
-
-        pointer operator->() const { return &m_CurrentValue; }
-
-        reference operator*() const { return m_CurrentValue; }
-
-        bool operator==(const Iterator &other) const
-        {
-            return m_CurrentValue == other.m_CurrentValue;
-        }
-
-        bool operator!=(const Iterator &other) const { return !(*this == other); }
-
-    private:
-        IteratorValue m_CurrentValue;
-    };
-
     /// @sa IDataSeries::xAxisData()
     std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
     const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
@@ -193,11 +179,38 @@ public:
     // Iterators //
     // ///////// //
 
-    Iterator cbegin() const { return Iterator{*this, true}; }
+    DataSeriesIterator cbegin() const override
+    {
+        return DataSeriesIterator{DataSeriesIteratorValue{
+            std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, true)}};
+    }
+
+    DataSeriesIterator cend() const override
+    {
+        return DataSeriesIterator{DataSeriesIteratorValue{
+            std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, false)}};
+    }
+
+    /// @sa IDataSeries::minData()
+    DataSeriesIterator minData(double minXAxisData) const override
+    {
+        return std::lower_bound(
+            cbegin(), cend(), minXAxisData,
+            [](const auto &itValue, const auto &value) { return itValue.x() < value; });
+    }
+
+    /// @sa IDataSeries::maxData()
+    DataSeriesIterator maxData(double maxXAxisData) const override
+    {
+        // Gets the first element that greater than max value
+        auto it = std::upper_bound(
+            cbegin(), cend(), maxXAxisData,
+            [](const auto &value, const auto &itValue) { return value < itValue.x(); });
 
-    Iterator cend() const { return Iterator{*this, false}; }
+        return it == cbegin() ? cend() : --it;
+    }
 
-    std::pair<Iterator, Iterator> subData(double min, double max) const
+    std::pair<DataSeriesIterator, DataSeriesIterator> subData(double min, double max) const override
     {
         if (min > max) {
             std::swap(min, max);
diff --git a/core/include/Data/DataSeriesIterator.h b/core/include/Data/DataSeriesIterator.h
new file mode 100644
index 0000000..ada5796
--- /dev/null
+++ b/core/include/Data/DataSeriesIterator.h
@@ -0,0 +1,82 @@
+#ifndef SCIQLOP_DATASERIESITERATOR_H
+#define SCIQLOP_DATASERIESITERATOR_H
+
+#include "CoreGlobal.h"
+
+#include <memory>
+
+/**
+ * @brief The DataSeriesIteratorValue class represents the current value of a data series iterator.
+ * It offers standard access methods for the data in the series (x-axis, values), but it is up to
+ * each series to define its own implementation of how to retrieve this data, by implementing the
+ * DataSeriesIteratorValue::Impl interface
+ *
+ * @sa DataSeriesIterator
+ */
+class SCIQLOP_CORE_EXPORT DataSeriesIteratorValue {
+public:
+    struct Impl {
+        virtual ~Impl() noexcept = default;
+        virtual std::unique_ptr<Impl> clone() const = 0;
+        virtual bool equals(const Impl &other) const = 0;
+        virtual void next() = 0;
+        virtual void prev() = 0;
+        virtual double x() const = 0;
+        virtual double value() const = 0;
+        virtual double value(int componentIndex) const = 0;
+    };
+
+    explicit DataSeriesIteratorValue(std::unique_ptr<Impl> impl);
+    DataSeriesIteratorValue(const DataSeriesIteratorValue &other);
+    DataSeriesIteratorValue(DataSeriesIteratorValue &&other) = default;
+    DataSeriesIteratorValue &operator=(DataSeriesIteratorValue other);
+
+    bool equals(const DataSeriesIteratorValue &other) const;
+
+    /// Advances to the next value
+    void next();
+    /// Moves back to the previous value
+    void prev();
+    /// Gets x-axis data
+    double x() const;
+    /// Gets value data
+    double value() const;
+    /// Gets value data depending on an index
+    double value(int componentIndex) const;
+
+private:
+    std::unique_ptr<Impl> m_Impl;
+};
+
+/**
+ * @brief The DataSeriesIterator class represents an iterator used for data series. It defines all
+ * operators needed for a standard forward iterator
+ * @sa http://www.cplusplus.com/reference/iterator/
+ */
+class SCIQLOP_CORE_EXPORT DataSeriesIterator {
+public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = const DataSeriesIteratorValue;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type *;
+    using reference = value_type &;
+
+    explicit DataSeriesIterator(DataSeriesIteratorValue value);
+    virtual ~DataSeriesIterator() noexcept = default;
+    DataSeriesIterator(const DataSeriesIterator &) = default;
+    DataSeriesIterator(DataSeriesIterator &&) = default;
+    DataSeriesIterator &operator=(const DataSeriesIterator &) = default;
+    DataSeriesIterator &operator=(DataSeriesIterator &&) = default;
+
+    DataSeriesIterator &operator++();
+    DataSeriesIterator &operator--();
+    pointer operator->() const { return &m_CurrentValue; }
+    reference operator*() const { return m_CurrentValue; }
+    bool operator==(const DataSeriesIterator &other) const;
+    bool operator!=(const DataSeriesIterator &other) const;
+
+private:
+    DataSeriesIteratorValue m_CurrentValue;
+};
+
+#endif // SCIQLOP_DATASERIESITERATOR_H
diff --git a/core/include/Data/IDataSeries.h b/core/include/Data/IDataSeries.h
index 7435fa3..a9059c4 100644
--- a/core/include/Data/IDataSeries.h
+++ b/core/include/Data/IDataSeries.h
@@ -2,6 +2,7 @@
 #define SCIQLOP_IDATASERIES_H
 
 #include <Common/MetaTypes.h>
+#include <Data/DataSeriesIterator.h>
 #include <Data/SqpRange.h>
 
 #include <memory>
@@ -62,6 +63,28 @@ public:
     virtual std::unique_ptr<IDataSeries> clone() const = 0;
     virtual SqpRange range() const = 0;
 
+    // ///////// //
+    // Iterators //
+    // ///////// //
+
+    virtual DataSeriesIterator cbegin() const = 0;
+    virtual DataSeriesIterator cend() const = 0;
+
+    /// @return the iterator to the first entry of the data series whose x-axis data is greater than
+    /// or equal to the value passed in parameter, or the end iterator if there is no matching value
+    virtual DataSeriesIterator minData(double minXAxisData) const = 0;
+
+    /// @return the iterator to the last entry of the data series whose x-axis data is less than or
+    /// equal to the value passed in parameter, or the end iterator if there is no matching value
+    virtual DataSeriesIterator maxData(double maxXAxisData) const = 0;
+
+    virtual std::pair<DataSeriesIterator, DataSeriesIterator> subData(double min,
+                                                                      double max) const = 0;
+
+    // /////// //
+    // Mutexes //
+    // /////// //
+
     virtual void lockRead() = 0;
     virtual void lockWrite() = 0;
     virtual void unlock() = 0;
diff --git a/core/src/Data/DataSeriesIterator.cpp b/core/src/Data/DataSeriesIterator.cpp
new file mode 100644
index 0000000..ce39a3d
--- /dev/null
+++ b/core/src/Data/DataSeriesIterator.cpp
@@ -0,0 +1,75 @@
+#include "Data/DataSeriesIterator.h"
+
+DataSeriesIteratorValue::DataSeriesIteratorValue(
+    std::unique_ptr<DataSeriesIteratorValue::Impl> impl)
+        : m_Impl{std::move(impl)}
+{
+}
+
+DataSeriesIteratorValue::DataSeriesIteratorValue(const DataSeriesIteratorValue &other)
+        : m_Impl{other.m_Impl->clone()}
+{
+}
+
+DataSeriesIteratorValue &DataSeriesIteratorValue::operator=(DataSeriesIteratorValue other)
+{
+    std::swap(m_Impl, other.m_Impl);
+    return *this;
+}
+
+bool DataSeriesIteratorValue::equals(const DataSeriesIteratorValue &other) const
+{
+    return m_Impl->equals(*other.m_Impl);
+}
+
+void DataSeriesIteratorValue::next()
+{
+    m_Impl->next();
+}
+
+void DataSeriesIteratorValue::prev()
+{
+    m_Impl->prev();
+}
+
+double DataSeriesIteratorValue::x() const
+{
+    return m_Impl->x();
+}
+
+double DataSeriesIteratorValue::value() const
+{
+    return m_Impl->value();
+}
+
+double DataSeriesIteratorValue::value(int componentIndex) const
+{
+    return m_Impl->value(componentIndex);
+}
+
+DataSeriesIterator::DataSeriesIterator(DataSeriesIteratorValue value)
+        : m_CurrentValue{std::move(value)}
+{
+}
+
+DataSeriesIterator &DataSeriesIterator::operator++()
+{
+    m_CurrentValue.next();
+    return *this;
+}
+
+DataSeriesIterator &DataSeriesIterator::operator--()
+{
+    m_CurrentValue.prev();
+    return *this;
+}
+
+bool DataSeriesIterator::operator==(const DataSeriesIterator &other) const
+{
+    return m_CurrentValue.equals(other.m_CurrentValue);
+}
+
+bool DataSeriesIterator::operator!=(const DataSeriesIterator &other) const
+{
+    return !(*this == other);
+}
diff --git a/core/src/Variable/VariableModel.cpp b/core/src/Variable/VariableModel.cpp
index a3065ba..2bce556 100644
--- a/core/src/Variable/VariableModel.cpp
+++ b/core/src/Variable/VariableModel.cpp
@@ -154,18 +154,31 @@ QVariant VariableModel::data(const QModelIndex &index, int role) const
     if (role == Qt::DisplayRole) {
         if (auto variable = impl->m_Variables.at(index.row()).get()) {
             /// Lambda function that builds the variant to return for a time value
-            auto dateTimeVariant = [](double secs) {
-                auto dateTime = DateUtils::dateTime(secs);
-                return dateTime.toString(DATETIME_FORMAT);
+            /// @param getValueFun function used to get for a data series the iterator on the entry
+            /// that contains the time value to display
+            auto dateTimeVariant = [variable](const auto &getValueFun) {
+                if (auto dataSeries = variable->dataSeries()) {
+                    auto it = getValueFun(*dataSeries);
+                    return (it != dataSeries->cend())
+                               ? DateUtils::dateTime(it->x()).toString(DATETIME_FORMAT)
+                               : QVariant{};
+                }
+                else {
+                    return QVariant{};
+                }
             };
 
             switch (index.column()) {
                 case NAME_COLUMN:
                     return variable->name();
                 case TSTART_COLUMN:
-                    return dateTimeVariant(variable->range().m_TStart);
+                    // Shows the min value of the data series above the range tstart
+                    return dateTimeVariant([min = variable->range().m_TStart](
+                        const auto &dataSeries) { return dataSeries.minData(min); });
                 case TEND_COLUMN:
-                    return dateTimeVariant(variable->range().m_TEnd);
+                    // Shows the max value of the data series under the range tend
+                    return dateTimeVariant([max = variable->range().m_TEnd](
+                        const auto &dataSeries) { return dataSeries.maxData(max); });
                 case UNIT_COLUMN:
                     return variable->metadata().value(QStringLiteral("units"));
                 case MISSION_COLUMN:
diff --git a/core/tests/Data/TestDataSeries.cpp b/core/tests/Data/TestDataSeries.cpp
index a8f6525..d6c75b8 100644
--- a/core/tests/Data/TestDataSeries.cpp
+++ b/core/tests/Data/TestDataSeries.cpp
@@ -24,6 +24,20 @@ private slots:
     void testMerge();
 
     /// Input test data
+    /// @sa testMinData()
+    void testMinData_data();
+
+    /// Tests get min data of a data series
+    void testMinData();
+
+    /// Input test data
+    /// @sa testMaxData()
+    void testMaxData_data();
+
+    /// Tests get max data of a data series
+    void testMaxData();
+
+    /// Input test data
     /// @sa testSubdata()
     void testSubdata_data();
 
@@ -167,6 +181,114 @@ void TestDataSeries::testMerge()
                        seriesValuesData.cbegin()));
 }
 
+void TestDataSeries::testMinData_data()
+{
+    // ////////////// //
+    // Test structure //
+    // ////////////// //
+
+    // Data series to get min data
+    QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
+
+    // Min data
+    QTest::addColumn<double>("min");
+
+    // Expected results
+    QTest::addColumn<bool>(
+        "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
+    QTest::addColumn<double>(
+        "expectedMin"); // Expected value when method doesn't return end iterator
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+
+    QTest::newRow("minData1") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                              << 0. << true << 1.;
+    QTest::newRow("minData2") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                              << 1. << true << 1.;
+    QTest::newRow("minData3") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                              << 1.1 << true << 2.;
+    QTest::newRow("minData4") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                              << 5. << true << 5.;
+    QTest::newRow("minData5") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                              << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
+    QTest::newRow("minData6") << createSeries({}, {}) << 1.1 << false
+                              << std::numeric_limits<double>::quiet_NaN();
+}
+
+void TestDataSeries::testMinData()
+{
+    QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
+    QFETCH(double, min);
+
+    QFETCH(bool, expectedOK);
+    QFETCH(double, expectedMin);
+
+    auto it = dataSeries->minData(min);
+
+    QCOMPARE(expectedOK, it != dataSeries->cend());
+
+    // If the method doesn't return a end iterator, checks with expected value
+    if (expectedOK) {
+        QCOMPARE(expectedMin, it->x());
+    }
+}
+
+void TestDataSeries::testMaxData_data()
+{
+    // ////////////// //
+    // Test structure //
+    // ////////////// //
+
+    // Data series to get max data
+    QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
+
+    // Max data
+    QTest::addColumn<double>("max");
+
+    // Expected results
+    QTest::addColumn<bool>(
+        "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
+    QTest::addColumn<double>(
+        "expectedMax"); // Expected value when method doesn't return end iterator
+
+    // ////////// //
+    // Test cases //
+    // ////////// //
+
+    QTest::newRow("maxData1") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                              << 6. << true << 5.;
+    QTest::newRow("maxData2") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                              << 5. << true << 5.;
+    QTest::newRow("maxData3") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                              << 4.9 << true << 4.;
+    QTest::newRow("maxData4") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                              << 1.1 << true << 1.;
+    QTest::newRow("maxData5") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                              << 1. << true << 1.;
+    QTest::newRow("maxData6") << createSeries({}, {}) << 1.1 << false
+                              << std::numeric_limits<double>::quiet_NaN();
+}
+
+void TestDataSeries::testMaxData()
+{
+    QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
+    QFETCH(double, max);
+
+    QFETCH(bool, expectedOK);
+    QFETCH(double, expectedMax);
+
+    auto it = dataSeries->maxData(max);
+
+    QCOMPARE(expectedOK, it != dataSeries->cend());
+
+    // If the method doesn't return a end iterator, checks with expected value
+    if (expectedOK) {
+        QCOMPARE(expectedMax, it->x());
+    }
+}
+
 void TestDataSeries::testSubdata_data()
 {
     // ////////////// //
diff --git a/core/tests/Variable/TestVariable.cpp b/core/tests/Variable/TestVariable.cpp
index 1228ddc..3fb2623 100644
--- a/core/tests/Variable/TestVariable.cpp
+++ b/core/tests/Variable/TestVariable.cpp
@@ -20,13 +20,12 @@ void TestVariable::testNotInCacheRangeList()
     auto varRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
     auto varRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 40, 0}};
 
-    auto sqpR = SqpRange{static_cast<double>(varRS.toMSecsSinceEpoch()),
-                         static_cast<double>(varRE.toMSecsSinceEpoch())};
+    auto sqpR = SqpRange{DateUtils::secondsSinceEpoch(varRS), DateUtils::secondsSinceEpoch(varRE)};
 
     auto varCRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
     auto varCRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
-    auto sqpCR = SqpRange{static_cast<double>(varCRS.toMSecsSinceEpoch()),
-                          static_cast<double>(varCRE.toMSecsSinceEpoch())};
+    auto sqpCR
+        = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
 
     Variable var{"Var test", sqpR};
     var.setCacheRange(sqpCR);
@@ -34,8 +33,7 @@ void TestVariable::testNotInCacheRangeList()
     // 1: [ts,te] < varTS
     auto ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
     auto te = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
-    auto sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                        static_cast<double>(te.toMSecsSinceEpoch())};
+    auto sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
     auto notInCach = var.provideNotInCacheRangeList(sqp);
 
@@ -43,25 +41,23 @@ void TestVariable::testNotInCacheRangeList()
 
     auto notInCachRange = notInCach.first();
 
-    QCOMPARE(notInCachRange.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCachRange.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 2: ts < varTS < te < varTE
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
     notInCach = var.provideNotInCacheRangeList(sqp);
     QCOMPARE(notInCach.size(), 1);
     notInCachRange = notInCach.first();
-    QCOMPARE(notInCachRange.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCachRange.m_TEnd, static_cast<double>(varCRS.toMSecsSinceEpoch()));
+    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(varCRS));
 
     // 3: varTS < ts < te < varTE
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
     notInCach = var.provideNotInCacheRangeList(sqp);
     QCOMPARE(notInCach.size(), 0);
 
@@ -69,38 +65,35 @@ void TestVariable::testNotInCacheRangeList()
     // 4: varTS < ts < varTE < te
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
     notInCach = var.provideNotInCacheRangeList(sqp);
     QCOMPARE(notInCach.size(), 1);
     notInCachRange = notInCach.first();
-    QCOMPARE(notInCachRange.m_TStart, static_cast<double>(varCRE.toMSecsSinceEpoch()));
-    QCOMPARE(notInCachRange.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(varCRE));
+    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 5: varTS < varTE < ts < te
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 20, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
     notInCach = var.provideNotInCacheRangeList(sqp);
     QCOMPARE(notInCach.size(), 1);
     notInCachRange = notInCach.first();
-    QCOMPARE(notInCachRange.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCachRange.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 6: ts <varTS < varTE < te
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
     notInCach = var.provideNotInCacheRangeList(sqp);
     QCOMPARE(notInCach.size(), 2);
     notInCachRange = notInCach.first();
-    QCOMPARE(notInCachRange.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCachRange.m_TEnd, static_cast<double>(varCRS.toMSecsSinceEpoch()));
+    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(varCRS));
     notInCachRange = notInCach[1];
-    QCOMPARE(notInCachRange.m_TStart, static_cast<double>(varCRE.toMSecsSinceEpoch()));
-    QCOMPARE(notInCachRange.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(varCRE));
+    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));
 }
 
 
@@ -109,13 +102,12 @@ void TestVariable::testInCacheRangeList()
     auto varRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
     auto varRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 40, 0}};
 
-    auto sqpR = SqpRange{static_cast<double>(varRS.toMSecsSinceEpoch()),
-                         static_cast<double>(varRE.toMSecsSinceEpoch())};
+    auto sqpR = SqpRange{DateUtils::secondsSinceEpoch(varRS), DateUtils::secondsSinceEpoch(varRE)};
 
     auto varCRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
     auto varCRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
-    auto sqpCR = SqpRange{static_cast<double>(varCRS.toMSecsSinceEpoch()),
-                          static_cast<double>(varCRE.toMSecsSinceEpoch())};
+    auto sqpCR
+        = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
 
     Variable var{"Var test", sqpR};
     var.setCacheRange(sqpCR);
@@ -123,8 +115,7 @@ void TestVariable::testInCacheRangeList()
     // 1: [ts,te] < varTS
     auto ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
     auto te = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
-    auto sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                        static_cast<double>(te.toMSecsSinceEpoch())};
+    auto sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
     auto notInCach = var.provideInCacheRangeList(sqp);
 
@@ -133,54 +124,49 @@ void TestVariable::testInCacheRangeList()
     // 2: ts < varTS < te < varTE
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
     notInCach = var.provideInCacheRangeList(sqp);
     QCOMPARE(notInCach.size(), 1);
     auto notInCachRange = notInCach.first();
-    QCOMPARE(notInCachRange.m_TStart, static_cast<double>(varCRS.toMSecsSinceEpoch()));
-    QCOMPARE(notInCachRange.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(varCRS));
+    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 3: varTS < ts < te < varTE
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
     notInCach = var.provideInCacheRangeList(sqp);
     QCOMPARE(notInCach.size(), 1);
     notInCachRange = notInCach.first();
-    QCOMPARE(notInCachRange.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCachRange.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 4: varTS < ts < varTE < te
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
     notInCach = var.provideInCacheRangeList(sqp);
     QCOMPARE(notInCach.size(), 1);
     notInCachRange = notInCach.first();
-    QCOMPARE(notInCachRange.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCachRange.m_TEnd, static_cast<double>(varCRE.toMSecsSinceEpoch()));
+    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(varCRE));
 
     // 5: varTS < varTE < ts < te
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 20, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
     notInCach = var.provideInCacheRangeList(sqp);
     QCOMPARE(notInCach.size(), 0);
 
     // 6: ts <varTS < varTE < te
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
     notInCach = var.provideInCacheRangeList(sqp);
     QCOMPARE(notInCach.size(), 1);
     notInCachRange = notInCach.first();
-    QCOMPARE(notInCachRange.m_TStart, static_cast<double>(varCRS.toMSecsSinceEpoch()));
-    QCOMPARE(notInCachRange.m_TEnd, static_cast<double>(varCRE.toMSecsSinceEpoch()));
+    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(varCRS));
+    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(varCRE));
 }
 
 
diff --git a/core/tests/Variable/TestVariableCacheController.cpp b/core/tests/Variable/TestVariableCacheController.cpp
index a46dd04..326410b 100644
--- a/core/tests/Variable/TestVariableCacheController.cpp
+++ b/core/tests/Variable/TestVariableCacheController.cpp
@@ -22,18 +22,15 @@ void TestVariableCacheController::testProvideNotInCacheDateTimeList()
 
     auto ts0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
     auto te0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
-    auto sqp0 = SqpRange{static_cast<double>(ts0.toMSecsSinceEpoch()),
-                         static_cast<double>(te0.toMSecsSinceEpoch())};
+    auto sqp0 = SqpRange{DateUtils::secondsSinceEpoch(ts0), DateUtils::secondsSinceEpoch(te0)};
 
     auto ts1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 6, 0, 0}};
     auto te1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 8, 0, 0}};
-    auto sqp1 = SqpRange{static_cast<double>(ts1.toMSecsSinceEpoch()),
-                         static_cast<double>(te1.toMSecsSinceEpoch())};
+    auto sqp1 = SqpRange{DateUtils::secondsSinceEpoch(ts1), DateUtils::secondsSinceEpoch(te1)};
 
     auto ts2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 18, 0, 0}};
     auto te2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 20, 0, 0}};
-    auto sqp2 = SqpRange{static_cast<double>(ts2.toMSecsSinceEpoch()),
-                         static_cast<double>(te2.toMSecsSinceEpoch())};
+    auto sqp2 = SqpRange{DateUtils::secondsSinceEpoch(ts2), DateUtils::secondsSinceEpoch(te2)};
 
     auto var0 = std::make_shared<Variable>("", sqp0);
 
@@ -44,210 +41,197 @@ void TestVariableCacheController::testProvideNotInCacheDateTimeList()
     // first case [ts,te] < ts0
     auto ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
     auto te = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
-    auto sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                        static_cast<double>(te.toMSecsSinceEpoch())};
+    auto sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     auto notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 1);
     auto notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
 
     // second case ts < ts0 &&  ts0 < te <= te0
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 1);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts0));
 
     // 3th case ts < ts0 &&  te0 < te <= ts1
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 2);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts0));
 
     notInCacheSqp = notInCach.at(1);
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te0));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 4th case ts < ts0 &&  ts1 < te <= te1
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 7, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 2);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts0));
 
     notInCacheSqp = notInCach.at(1);
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te0));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts1));
 
     // 5th case ts < ts0 &&  te3 < te
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 22, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 4);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts0.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts0));
 
     notInCacheSqp = notInCach.at(1);
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te0));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts1));
 
     notInCacheSqp = notInCach.at(2);
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te1));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts2));
 
     notInCacheSqp = notInCach.at(3);
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te2));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
 
     // 6th case ts2 < ts
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 45, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 47, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 1);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 7th case ts = te0 && te < ts1
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 1);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te0));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 8th case ts0 < ts < te0 && te < ts1
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 1);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te0));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 9th case ts0 < ts < te0 &&  ts1 < te < te1
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 7, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 1);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te0.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te0));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts1));
 
     // 10th case te1 < ts < te < ts2
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 9, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 10, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 1);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 11th case te0 < ts < ts1 &&  te3 < te
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 47, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 3);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts1));
 
     notInCacheSqp = notInCach.at(1);
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts2.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te1));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts2));
 
     notInCacheSqp = notInCach.at(2);
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te2.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te2));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
     // 12th case te0 < ts < ts1 &&  te3 < te
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 10, 0, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
 
     QCOMPARE(notInCach.size(), 2);
     notInCacheSqp = notInCach.first();
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(ts.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(ts1.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(ts));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(ts1));
 
     notInCacheSqp = notInCach.at(1);
-    QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch()));
-    QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch()));
+    QCOMPARE(notInCacheSqp.m_TStart, DateUtils::secondsSinceEpoch(te1));
+    QCOMPARE(notInCacheSqp.m_TEnd, DateUtils::secondsSinceEpoch(te));
 
 
     // 12th case ts0 < ts < te0
     ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 10, 0}};
     te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 50, 0}};
-    sqp = SqpRange{static_cast<double>(ts.toMSecsSinceEpoch()),
-                   static_cast<double>(te.toMSecsSinceEpoch())};
+    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
 
     notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp);
     QCOMPARE(notInCach.size(), 0);
@@ -260,33 +244,27 @@ void TestVariableCacheController::testAddDateTime()
 
     auto ts0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
     auto te0 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
-    auto sqp0 = SqpRange{static_cast<double>(ts0.toMSecsSinceEpoch()),
-                         static_cast<double>(te0.toMSecsSinceEpoch())};
+    auto sqp0 = SqpRange{DateUtils::secondsSinceEpoch(ts0), DateUtils::secondsSinceEpoch(te0)};
 
     auto ts1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 6, 0, 0}};
     auto te1 = QDateTime{QDate{2017, 01, 01}, QTime{2, 8, 0, 0}};
-    auto sqp1 = SqpRange{static_cast<double>(ts1.toMSecsSinceEpoch()),
-                         static_cast<double>(te1.toMSecsSinceEpoch())};
+    auto sqp1 = SqpRange{DateUtils::secondsSinceEpoch(ts1), DateUtils::secondsSinceEpoch(te1)};
 
     auto ts2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 18, 0, 0}};
     auto te2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 20, 0, 0}};
-    auto sqp2 = SqpRange{static_cast<double>(ts2.toMSecsSinceEpoch()),
-                         static_cast<double>(te2.toMSecsSinceEpoch())};
+    auto sqp2 = SqpRange{DateUtils::secondsSinceEpoch(ts2), DateUtils::secondsSinceEpoch(te2)};
 
     auto ts01 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
     auto te01 = QDateTime{QDate{2017, 01, 01}, QTime{2, 6, 0, 0}};
-    auto sqp01 = SqpRange{static_cast<double>(ts01.toMSecsSinceEpoch()),
-                          static_cast<double>(te01.toMSecsSinceEpoch())};
+    auto sqp01 = SqpRange{DateUtils::secondsSinceEpoch(ts01), DateUtils::secondsSinceEpoch(te01)};
 
     auto ts3 = QDateTime{QDate{2017, 01, 01}, QTime{2, 14, 0, 0}};
     auto te3 = QDateTime{QDate{2017, 01, 01}, QTime{2, 16, 0, 0}};
-    auto sqp3 = SqpRange{static_cast<double>(ts3.toMSecsSinceEpoch()),
-                         static_cast<double>(te3.toMSecsSinceEpoch())};
+    auto sqp3 = SqpRange{DateUtils::secondsSinceEpoch(ts3), DateUtils::secondsSinceEpoch(te3)};
 
     auto ts03 = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
     auto te03 = QDateTime{QDate{2017, 01, 01}, QTime{2, 22, 0, 0}};
-    auto sqp03 = SqpRange{static_cast<double>(ts03.toMSecsSinceEpoch()),
-                          static_cast<double>(te03.toMSecsSinceEpoch())};
+    auto sqp03 = SqpRange{DateUtils::secondsSinceEpoch(ts03), DateUtils::secondsSinceEpoch(te03)};
 
 
     auto var0 = std::make_shared<Variable>("", sqp0);
@@ -297,28 +275,28 @@ void TestVariableCacheController::testAddDateTime()
     auto dateCacheList = variableCacheController.dateCacheList(var0);
     QCOMPARE(dateCacheList.count(), 1);
     auto dateCache = dateCacheList.at(0);
-    QCOMPARE(dateCache.m_TStart, static_cast<double>(ts0.toMSecsSinceEpoch()));
-    QCOMPARE(dateCache.m_TEnd, static_cast<double>(te0.toMSecsSinceEpoch()));
+    QCOMPARE(dateCache.m_TStart, DateUtils::secondsSinceEpoch(ts0));
+    QCOMPARE(dateCache.m_TEnd, DateUtils::secondsSinceEpoch(te0));
 
     // 2nd case: add a second interval : sqp1 > sqp0
     variableCacheController.addDateTime(var0, sqp1);
     dateCacheList = variableCacheController.dateCacheList(var0);
     QCOMPARE(dateCacheList.count(), 2);
     dateCache = dateCacheList.at(0);
-    QCOMPARE(dateCache.m_TStart, static_cast<double>(ts0.toMSecsSinceEpoch()));
-    QCOMPARE(dateCache.m_TEnd, static_cast<double>(te0.toMSecsSinceEpoch()));
+    QCOMPARE(dateCache.m_TStart, DateUtils::secondsSinceEpoch(ts0));
+    QCOMPARE(dateCache.m_TEnd, DateUtils::secondsSinceEpoch(te0));
 
     dateCache = dateCacheList.at(1);
-    QCOMPARE(dateCache.m_TStart, static_cast<double>(ts1.toMSecsSinceEpoch()));
-    QCOMPARE(dateCache.m_TEnd, static_cast<double>(te1.toMSecsSinceEpoch()));
+    QCOMPARE(dateCache.m_TStart, DateUtils::secondsSinceEpoch(ts1));
+    QCOMPARE(dateCache.m_TEnd, DateUtils::secondsSinceEpoch(te1));
 
     // 3th case: merge sqp0 & sqp1 with sqp01
     variableCacheController.addDateTime(var0, sqp01);
     dateCacheList = variableCacheController.dateCacheList(var0);
     QCOMPARE(dateCacheList.count(), 1);
     dateCache = dateCacheList.at(0);
-    QCOMPARE(dateCache.m_TStart, static_cast<double>(ts0.toMSecsSinceEpoch()));
-    QCOMPARE(dateCache.m_TEnd, static_cast<double>(te1.toMSecsSinceEpoch()));
+    QCOMPARE(dateCache.m_TStart, DateUtils::secondsSinceEpoch(ts0));
+    QCOMPARE(dateCache.m_TEnd, DateUtils::secondsSinceEpoch(te1));
 
 
     // 4th case: add a second interval : sqp1 > sqp0
@@ -327,16 +305,16 @@ void TestVariableCacheController::testAddDateTime()
     dateCacheList = variableCacheController.dateCacheList(var0);
     QCOMPARE(dateCacheList.count(), 3);
     dateCache = dateCacheList.at(0);
-    QCOMPARE(dateCache.m_TStart, static_cast<double>(ts0.toMSecsSinceEpoch()));
-    QCOMPARE(dateCache.m_TEnd, static_cast<double>(te1.toMSecsSinceEpoch()));
+    QCOMPARE(dateCache.m_TStart, DateUtils::secondsSinceEpoch(ts0));
+    QCOMPARE(dateCache.m_TEnd, DateUtils::secondsSinceEpoch(te1));
 
     dateCache = dateCacheList.at(1);
-    QCOMPARE(dateCache.m_TStart, static_cast<double>(ts3.toMSecsSinceEpoch()));
-    QCOMPARE(dateCache.m_TEnd, static_cast<double>(te3.toMSecsSinceEpoch()));
+    QCOMPARE(dateCache.m_TStart, DateUtils::secondsSinceEpoch(ts3));
+    QCOMPARE(dateCache.m_TEnd, DateUtils::secondsSinceEpoch(te3));
 
     dateCache = dateCacheList.at(2);
-    QCOMPARE(dateCache.m_TStart, static_cast<double>(ts2.toMSecsSinceEpoch()));
-    QCOMPARE(dateCache.m_TEnd, static_cast<double>(te2.toMSecsSinceEpoch()));
+    QCOMPARE(dateCache.m_TStart, DateUtils::secondsSinceEpoch(ts2));
+    QCOMPARE(dateCache.m_TEnd, DateUtils::secondsSinceEpoch(te2));
 
 
     // 5th case: merge all interval
@@ -344,8 +322,8 @@ void TestVariableCacheController::testAddDateTime()
     dateCacheList = variableCacheController.dateCacheList(var0);
     QCOMPARE(dateCacheList.count(), 1);
     dateCache = dateCacheList.at(0);
-    QCOMPARE(dateCache.m_TStart, static_cast<double>(ts0.toMSecsSinceEpoch()));
-    QCOMPARE(dateCache.m_TEnd, static_cast<double>(te03.toMSecsSinceEpoch()));
+    QCOMPARE(dateCache.m_TStart, DateUtils::secondsSinceEpoch(ts0));
+    QCOMPARE(dateCache.m_TEnd, DateUtils::secondsSinceEpoch(te03));
 }
 
 
diff --git a/core/vera-exclusions/exclusions.txt b/core/vera-exclusions/exclusions.txt
index d8f594e..f1bd7ef 100644
--- a/core/vera-exclusions/exclusions.txt
+++ b/core/vera-exclusions/exclusions.txt
@@ -3,6 +3,8 @@ Common/spimpl\.h:\d+:.*
 
 # Ignore false positive relative to two class definitions in a same file
 DataSourceItem\.h:\d+:.*IPSIS_S01.*
+DataSeries\.h:\d+:.*IPSIS_S01.*
+DataSeriesIterator\.h:\d+:.*IPSIS_S01.*
 
 # Ignore false positive relative to a template class
 ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (D)
@@ -11,6 +13,7 @@ ArrayData\.h:\d+:.*IPSIS_S06.*found: (D)
 ArrayData\.h:\d+:.*IPSIS_S06.*found: (Dim)
 DataSeries\.h:\d+:.*IPSIS_S04_METHOD.*found: LOG_DataSeries
 DataSeries\.h:\d+:.*IPSIS_S04_VARIABLE.*
+DataSeries\.h:\d+:.*IPSIS_S04_NAMESPACE.*found: (dataseries_detail)
 
 # Ignore false positive relative to iterators
 ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (forward_iterator_tag)
@@ -27,16 +30,20 @@ ArrayData\.h:\d+:.*IPSIS_S06.*found: (ptrdiff_t)
 ArrayData\.h:\d+:.*IPSIS_S06.*found: (pointer)
 ArrayData\.h:\d+:.*IPSIS_S06.*found: (reference)
 ArrayData\.h:\d+:.*IPSIS_S06.*found: (value_type)
-DataSeries\.h:\d+:.*IPSIS_S05.*
-DataSeries\.h:\d+:.*IPSIS_S06.*found: (iterator_category)
-DataSeries\.h:\d+:.*IPSIS_S06.*found: (forward_iterator_tag)
-DataSeries\.h:\d+:.*IPSIS_S06.*found: (value_type)
-DataSeries\.h:\d+:.*IPSIS_S06.*found: (IteratorValue)
-DataSeries\.h:\d+:.*IPSIS_S06.*found: (difference_type)
-DataSeries\.h:\d+:.*IPSIS_S06.*found: (ptrdiff_t)
-DataSeries\.h:\d+:.*IPSIS_S06.*found: (pointer)
-DataSeries\.h:\d+:.*IPSIS_S06.*found: (reference)
-DataSeries\.h:\d+:.*IPSIS_S06.*found: (value_type)
+DataSeriesIterator\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (forward_iterator_tag)
+DataSeriesIterator\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (DataSeriesIteratorValue)
+DataSeriesIterator\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (ptrdiff_t)
+DataSeriesIterator\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (value_type)
+DataSeriesIterator\.h:\d+:.*IPSIS_S05.*
+DataSeriesIterator\.h:\d+:.*IPSIS_S06.*found: (iterator_category)
+DataSeriesIterator\.h:\d+:.*IPSIS_S06.*found: (forward_iterator_tag)
+DataSeriesIterator\.h:\d+:.*IPSIS_S06.*found: (value_type)
+DataSeriesIterator\.h:\d+:.*IPSIS_S06.*found: (DataSeriesIteratorValue)
+DataSeriesIterator\.h:\d+:.*IPSIS_S06.*found: (difference_type)
+DataSeriesIterator\.h:\d+:.*IPSIS_S06.*found: (ptrdiff_t)
+DataSeriesIterator\.h:\d+:.*IPSIS_S06.*found: (pointer)
+DataSeriesIterator\.h:\d+:.*IPSIS_S06.*found: (reference)
+DataSeriesIterator\.h:\d+:.*IPSIS_S06.*found: (value_type)
 
 # Ignore false positive relative to an alias
 DataSourceItemAction\.h:\d+:.*IPSIS_S06.*found: (ExecuteFunction)