|
|
/**
|
|
|
* The DataSeriesTestsUtils file contains a set of utility methods that can be used to test the operations on a DataSeries.
|
|
|
*
|
|
|
* Most of these methods are template methods to adapt to any series (scalars, vectors, spectrograms...)
|
|
|
*
|
|
|
* @sa DataSeries
|
|
|
*/
|
|
|
#ifndef SCIQLOP_DATASERIESTESTSUTILS_H
|
|
|
#define SCIQLOP_DATASERIESTESTSUTILS_H
|
|
|
|
|
|
#include <Data/DataSeriesIterator.h>
|
|
|
#include <Data/ScalarSeries.h>
|
|
|
#include <Data/SpectrogramSeries.h>
|
|
|
#include <Data/VectorSeries.h>
|
|
|
|
|
|
#include <memory>
|
|
|
#include <QtTest>
|
|
|
|
|
|
/// Underlying data in ArrayData
|
|
|
using DataContainer = std::vector<double>;
|
|
|
|
|
|
Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
|
|
|
Q_DECLARE_METATYPE(std::shared_ptr<SpectrogramSeries>)
|
|
|
Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
|
|
|
|
|
|
/**
|
|
|
* Checks that the range of a 1-dim data series contains the expected x-axis data and values data
|
|
|
* @param first the iterator on the beginning of the range to check
|
|
|
* @param last the iterator on the end of the range to check
|
|
|
* @param xData expected x-axis data for the range
|
|
|
* @param valuesData expected values data for the range
|
|
|
*/
|
|
|
void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
|
|
|
const DataContainer &valuesData);
|
|
|
|
|
|
/**
|
|
|
* Checks that the range of a 2-dim data series contains the expected x-axis data and values data
|
|
|
* @param first the iterator on the beginning of the range to check
|
|
|
* @param last the iterator on the end of the range to check
|
|
|
* @param xData expected x-axis data for the range
|
|
|
* @param valuesData expected values data for the range
|
|
|
*/
|
|
|
void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
|
|
|
const std::vector<DataContainer> &valuesData);
|
|
|
|
|
|
/**
|
|
|
* Sets the structure of unit tests concerning merge of two data series
|
|
|
* @tparam DataSeriesType the type of data series to merge
|
|
|
* @tparam ExpectedValuesType the type of values expected after merge
|
|
|
* @sa testMerge_t()
|
|
|
*/
|
|
|
template <typename DataSeriesType, typename ExpectedValuesType>
|
|
|
void testMerge_struct() {
|
|
|
// Data series to merge
|
|
|
QTest::addColumn<std::shared_ptr<DataSeriesType> >("dataSeries");
|
|
|
QTest::addColumn<std::shared_ptr<DataSeriesType> >("dataSeries2");
|
|
|
|
|
|
// Expected values in the first data series after merge
|
|
|
QTest::addColumn<DataContainer>("expectedXAxisData");
|
|
|
QTest::addColumn<ExpectedValuesType>("expectedValuesData");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Unit test concerning merge of two data series
|
|
|
* @sa testMerge_struct()
|
|
|
*/
|
|
|
template <typename DataSeriesType, typename ExpectedValuesType>
|
|
|
void testMerge_t(){
|
|
|
// Merges series
|
|
|
QFETCH(std::shared_ptr<DataSeriesType>, dataSeries);
|
|
|
QFETCH(std::shared_ptr<DataSeriesType>, dataSeries2);
|
|
|
|
|
|
dataSeries->merge(dataSeries2.get());
|
|
|
|
|
|
// Validates results : we check that the merge is valid
|
|
|
QFETCH(DataContainer, expectedXAxisData);
|
|
|
QFETCH(ExpectedValuesType, expectedValuesData);
|
|
|
|
|
|
validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Sets the structure of unit tests concerning merge of two data series that are of a different type
|
|
|
* @tparam SourceType the type of data series with which to make the merge
|
|
|
* @tparam DestType the type of data series in which to make the merge
|
|
|
* @sa testMergeDifferentTypes_t()
|
|
|
*/
|
|
|
template <typename SourceType, typename DestType>
|
|
|
void testMergeDifferentTypes_struct()
|
|
|
{
|
|
|
// Data series to merge
|
|
|
QTest::addColumn<std::shared_ptr<DestType> >("dest");
|
|
|
QTest::addColumn<std::shared_ptr<SourceType> >("source");
|
|
|
|
|
|
// Expected values in the dest data series after merge
|
|
|
QTest::addColumn<DataContainer>("expectedXAxisData");
|
|
|
QTest::addColumn<DataContainer>("expectedValuesData");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Unit test concerning merge of two data series that are of a different type
|
|
|
* @sa testMergeDifferentTypes_struct()
|
|
|
*/
|
|
|
template <typename SourceType, typename DestType>
|
|
|
void testMergeDifferentTypes_t()
|
|
|
{
|
|
|
// Merges series
|
|
|
QFETCH(std::shared_ptr<SourceType>, source);
|
|
|
QFETCH(std::shared_ptr<DestType>, dest);
|
|
|
|
|
|
dest->merge(source.get());
|
|
|
|
|
|
// Validates results : we check that the merge is valid and the data series is sorted on its
|
|
|
// x-axis data
|
|
|
QFETCH(DataContainer, expectedXAxisData);
|
|
|
QFETCH(DataContainer, expectedValuesData);
|
|
|
|
|
|
validateRange(dest->cbegin(), dest->cend(), expectedXAxisData, expectedValuesData);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Sets the structure of unit tests concerning getting the min x-axis data of a data series
|
|
|
* @tparam T the type of data series on which to make the operation
|
|
|
* @sa testMinXAxisData_t()
|
|
|
*/
|
|
|
template <typename T>
|
|
|
void testMinXAxisData_struct(){
|
|
|
// Data series to get min data
|
|
|
QTest::addColumn<std::shared_ptr<T> >("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
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Unit test concerning getting the min x-axis data of a data series
|
|
|
* @sa testMinXAxisData_struct()
|
|
|
*/
|
|
|
template <typename T>
|
|
|
void testMinXAxisData_t()
|
|
|
{
|
|
|
QFETCH(std::shared_ptr<T>, dataSeries);
|
|
|
QFETCH(double, min);
|
|
|
|
|
|
QFETCH(bool, expectedOK);
|
|
|
QFETCH(double, expectedMin);
|
|
|
|
|
|
auto it = dataSeries->minXAxisData(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());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Sets the structure of unit tests concerning getting the max x-axis data of a data series
|
|
|
* @tparam T the type of data series on which to make the operation
|
|
|
* @sa testMaxXAxisData_t()
|
|
|
*/
|
|
|
template <typename T>
|
|
|
void testMaxXAxisData_struct(){
|
|
|
// Data series to get max data
|
|
|
QTest::addColumn<std::shared_ptr<T> >("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
|
|
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Unit test concerning getting the max x-axis data of a data series
|
|
|
* @sa testMaxXAxisData_struct()
|
|
|
*/
|
|
|
template <typename T>
|
|
|
void testMaxXAxisData_t()
|
|
|
{
|
|
|
QFETCH(std::shared_ptr<T>, dataSeries);
|
|
|
QFETCH(double, max);
|
|
|
|
|
|
QFETCH(bool, expectedOK);
|
|
|
QFETCH(double, expectedMax);
|
|
|
|
|
|
auto it = dataSeries->maxXAxisData(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());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Sets the structure of unit tests concerning getting the purge of a data series
|
|
|
* @tparam T the type of data series on which to make the operation
|
|
|
* @sa testMinXAxisData_t()
|
|
|
*/
|
|
|
template <typename T>
|
|
|
void testPurge_struct()
|
|
|
{
|
|
|
// Data series to purge
|
|
|
QTest::addColumn<std::shared_ptr<T> >("dataSeries");
|
|
|
QTest::addColumn<double>("min");
|
|
|
QTest::addColumn<double>("max");
|
|
|
|
|
|
// Expected values after purge
|
|
|
QTest::addColumn<DataContainer>("expectedXAxisData");
|
|
|
QTest::addColumn<std::vector<DataContainer> >("expectedValuesData");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Unit test concerning getting the purge of a data series
|
|
|
* @sa testPurge_struct()
|
|
|
*/
|
|
|
template <typename T>
|
|
|
void testPurge_t(){
|
|
|
QFETCH(std::shared_ptr<T>, dataSeries);
|
|
|
QFETCH(double, min);
|
|
|
QFETCH(double, max);
|
|
|
|
|
|
dataSeries->purge(min, max);
|
|
|
|
|
|
// Validates results
|
|
|
QFETCH(DataContainer, expectedXAxisData);
|
|
|
QFETCH(std::vector<DataContainer>, expectedValuesData);
|
|
|
|
|
|
validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData,
|
|
|
expectedValuesData);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Sets the structure of unit tests concerning getting subdata of a data series
|
|
|
* @tparam DataSeriesType the type of data series on which to make the operation
|
|
|
* @tparam ExpectedValuesType the type of values expected after the operation
|
|
|
* @sa testSubDataSeries_t()
|
|
|
*/
|
|
|
template <typename DataSeriesType, typename ExpectedValuesType>
|
|
|
void testSubDataSeries_struct() {
|
|
|
// Data series from which extract the subdata series
|
|
|
QTest::addColumn<std::shared_ptr<DataSeriesType> >("dataSeries");
|
|
|
// Range to extract
|
|
|
QTest::addColumn<SqpRange>("range");
|
|
|
|
|
|
// Expected values for the subdata series
|
|
|
QTest::addColumn<DataContainer>("expectedXAxisData");
|
|
|
QTest::addColumn<ExpectedValuesType>("expectedValuesData");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Unit test concerning getting subdata of a data series
|
|
|
* @sa testSubDataSeries_struct()
|
|
|
*/
|
|
|
template <typename DataSeriesType, typename ExpectedValuesType>
|
|
|
void testSubDataSeries_t(){
|
|
|
QFETCH(std::shared_ptr<DataSeriesType>, dataSeries);
|
|
|
QFETCH(SqpRange, range);
|
|
|
|
|
|
// Makes the operation
|
|
|
auto subDataSeries = std::dynamic_pointer_cast<DataSeriesType>(dataSeries->subDataSeries(range));
|
|
|
QVERIFY(subDataSeries != nullptr);
|
|
|
|
|
|
// Validates results
|
|
|
QFETCH(DataContainer, expectedXAxisData);
|
|
|
QFETCH(ExpectedValuesType, expectedValuesData);
|
|
|
|
|
|
validateRange(subDataSeries->cbegin(), subDataSeries->cend(), expectedXAxisData, expectedValuesData);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Sets the structure of unit tests concerning getting the range of a data series
|
|
|
* @tparam T the type of data series on which to make the operation
|
|
|
* @sa testXAxisRange_t()
|
|
|
*/
|
|
|
template <typename T>
|
|
|
void testXAxisRange_struct(){
|
|
|
// Data series to get x-axis range
|
|
|
QTest::addColumn<std::shared_ptr<T> >("dataSeries");
|
|
|
|
|
|
// Min/max values
|
|
|
QTest::addColumn<double>("min");
|
|
|
QTest::addColumn<double>("max");
|
|
|
|
|
|
// Expected values
|
|
|
QTest::addColumn<DataContainer>("expectedXAxisData");
|
|
|
QTest::addColumn<DataContainer>("expectedValuesData");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Unit test concerning getting the range of a data series
|
|
|
* @sa testXAxisRange_struct()
|
|
|
*/
|
|
|
template <typename T>
|
|
|
void testXAxisRange_t(){
|
|
|
QFETCH(std::shared_ptr<T>, dataSeries);
|
|
|
QFETCH(double, min);
|
|
|
QFETCH(double, max);
|
|
|
|
|
|
QFETCH(DataContainer, expectedXAxisData);
|
|
|
QFETCH(DataContainer, expectedValuesData);
|
|
|
|
|
|
auto bounds = dataSeries->xAxisRange(min, max);
|
|
|
validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Sets the structure of unit tests concerning getting values bounds of a data series
|
|
|
* @tparam T the type of data series on which to make the operation
|
|
|
* @sa testValuesBounds_t()
|
|
|
*/
|
|
|
template <typename T>
|
|
|
void testValuesBounds_struct()
|
|
|
{
|
|
|
// Data series to get values bounds
|
|
|
QTest::addColumn<std::shared_ptr<T> >("dataSeries");
|
|
|
|
|
|
// x-axis range
|
|
|
QTest::addColumn<double>("minXAxis");
|
|
|
QTest::addColumn<double>("maxXAxis");
|
|
|
|
|
|
// Expected results
|
|
|
QTest::addColumn<bool>(
|
|
|
"expectedOK"); // Test is expected to be ok (i.e. method doesn't return end iterators)
|
|
|
QTest::addColumn<double>("expectedMinValue");
|
|
|
QTest::addColumn<double>("expectedMaxValue");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Unit test concerning getting values bounds of a data series
|
|
|
* @sa testValuesBounds_struct()
|
|
|
*/
|
|
|
template <typename T>
|
|
|
void testValuesBounds_t()
|
|
|
{
|
|
|
QFETCH(std::shared_ptr<T>, dataSeries);
|
|
|
QFETCH(double, minXAxis);
|
|
|
QFETCH(double, maxXAxis);
|
|
|
|
|
|
QFETCH(bool, expectedOK);
|
|
|
QFETCH(double, expectedMinValue);
|
|
|
QFETCH(double, expectedMaxValue);
|
|
|
|
|
|
auto minMaxIts = dataSeries->valuesBounds(minXAxis, maxXAxis);
|
|
|
auto end = dataSeries->cend();
|
|
|
|
|
|
// Checks iterators with expected result
|
|
|
QCOMPARE(expectedOK, minMaxIts.first != end && minMaxIts.second != end);
|
|
|
|
|
|
if (expectedOK) {
|
|
|
auto compare = [](const auto &v1, const auto &v2) {
|
|
|
return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
|
|
|
};
|
|
|
|
|
|
QVERIFY(compare(expectedMinValue, minMaxIts.first->minValue()));
|
|
|
QVERIFY(compare(expectedMaxValue, minMaxIts.second->maxValue()));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#endif // SCIQLOP_DATASERIESTESTSUTILS_H
|
|
|
|
