TestDataSeries.cpp
702 lines
| 25.9 KiB
| text/x-c
|
CppLexer
|
r455 | #include "Data/DataSeries.h" | ||
#include "Data/ScalarSeries.h" | ||||
|
r611 | #include "Data/VectorSeries.h" | ||
|
r455 | |||
|
r617 | #include <cmath> | ||
|
r455 | #include <QObject> | ||
#include <QtTest> | ||||
Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>) | ||||
|
r611 | Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>) | ||
|
r455 | |||
|
r647 | namespace { | ||
|
r695 | using DataContainer = std::vector<double>; | ||
void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData, | ||||
const DataContainer &valuesData) | ||||
|
r647 | { | ||
QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(), | ||||
[](const auto &it, const auto &expectedX) { return it.x() == expectedX; })); | ||||
QVERIFY(std::equal( | ||||
first, last, valuesData.cbegin(), valuesData.cend(), | ||||
[](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; })); | ||||
} | ||||
|
r695 | void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData, | ||
const std::vector<DataContainer> &valuesData) | ||||
|
r678 | { | ||
QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(), | ||||
[](const auto &it, const auto &expectedX) { return it.x() == expectedX; })); | ||||
for (auto i = 0; i < valuesData.size(); ++i) { | ||||
auto componentData = valuesData.at(i); | ||||
QVERIFY(std::equal( | ||||
first, last, componentData.cbegin(), componentData.cend(), | ||||
[i](const auto &it, const auto &expectedVal) { return it.value(i) == expectedVal; })); | ||||
} | ||||
} | ||||
|
r647 | } // namespace | ||
|
r455 | class TestDataSeries : public QObject { | ||
Q_OBJECT | ||||
|
r611 | private: | ||
template <typename T> | ||||
void testValuesBoundsStructure() | ||||
{ | ||||
// ////////////// // | ||||
// Test structure // | ||||
// ////////////// // | ||||
// 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"); | ||||
} | ||||
template <typename T> | ||||
void testValuesBounds() | ||||
{ | ||||
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())); | ||||
} | ||||
} | ||||
|
r678 | template <typename T> | ||
void testPurgeStructure() | ||||
{ | ||||
// ////////////// // | ||||
// Test structure // | ||||
// ////////////// // | ||||
// Data series to purge | ||||
QTest::addColumn<std::shared_ptr<T> >("dataSeries"); | ||||
QTest::addColumn<double>("min"); | ||||
QTest::addColumn<double>("max"); | ||||
// Expected values after purge | ||||
|
r695 | QTest::addColumn<DataContainer>("expectedXAxisData"); | ||
QTest::addColumn<std::vector<DataContainer> >("expectedValuesData"); | ||||
|
r678 | } | ||
template <typename T> | ||||
void testPurge() | ||||
{ | ||||
QFETCH(std::shared_ptr<T>, dataSeries); | ||||
QFETCH(double, min); | ||||
QFETCH(double, max); | ||||
dataSeries->purge(min, max); | ||||
// Validates results | ||||
|
r695 | QFETCH(DataContainer, expectedXAxisData); | ||
QFETCH(std::vector<DataContainer>, expectedValuesData); | ||||
|
r678 | |||
validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, | ||||
expectedValuesData); | ||||
} | ||||
|
r798 | template <typename SourceType, typename DestType> | ||
void testMergeDifferentTypesStructure() | ||||
{ | ||||
// ////////////// // | ||||
// Test structure // | ||||
// ////////////// // | ||||
// 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"); | ||||
} | ||||
template <typename SourceType, typename DestType> | ||||
void testMergeDifferentTypes() | ||||
{ | ||||
// 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); | ||||
} | ||||
|
r455 | private slots: | ||
|
r678 | |||
|
r455 | /// Input test data | ||
/// @sa testCtor() | ||||
void testCtor_data(); | ||||
/// Tests construction of a data series | ||||
void testCtor(); | ||||
/// Input test data | ||||
/// @sa testMerge() | ||||
void testMerge_data(); | ||||
/// Tests merge of two data series | ||||
void testMerge(); | ||||
|
r586 | |||
|
r798 | /// Input test data | ||
/// @sa testMergeVectorInScalar() | ||||
void testMergeVectorInScalar_data(); | ||||
/// Tests merge of vector series in scalar series | ||||
void testMergeVectorInScalar(); | ||||
|
r678 | /// Input test data | ||
/// @sa testPurgeScalar() | ||||
void testPurgeScalar_data(); | ||||
/// Tests purge of a scalar series | ||||
void testPurgeScalar(); | ||||
/// Input test data | ||||
/// @sa testPurgeVector() | ||||
void testPurgeVector_data(); | ||||
/// Tests purge of a vector series | ||||
void testPurgeVector(); | ||||
|
r586 | /// Input test data | ||
|
r604 | /// @sa testMinXAxisData() | ||
void testMinXAxisData_data(); | ||||
|
r599 | |||
|
r604 | /// Tests get min x-axis data of a data series | ||
void testMinXAxisData(); | ||||
|
r599 | |||
|
r600 | /// Input test data | ||
|
r604 | /// @sa testMaxXAxisData() | ||
void testMaxXAxisData_data(); | ||||
|
r600 | |||
|
r604 | /// Tests get max x-axis data of a data series | ||
void testMaxXAxisData(); | ||||
|
r600 | |||
/// Input test data | ||||
|
r605 | /// @sa testXAxisRange() | ||
void testXAxisRange_data(); | ||||
|
r586 | |||
|
r605 | /// Tests get x-axis range of a data series | ||
void testXAxisRange(); | ||||
|
r610 | |||
/// Input test data | ||||
|
r611 | /// @sa testValuesBoundsScalar() | ||
void testValuesBoundsScalar_data(); | ||||
|
r610 | |||
|
r611 | /// Tests get values bounds of a scalar series | ||
void testValuesBoundsScalar(); | ||||
|
r612 | |||
/// Input test data | ||||
/// @sa testValuesBoundsVector() | ||||
void testValuesBoundsVector_data(); | ||||
/// Tests get values bounds of a vector series | ||||
void testValuesBoundsVector(); | ||||
|
r455 | }; | ||
void TestDataSeries::testCtor_data() | ||||
{ | ||||
// ////////////// // | ||||
// Test structure // | ||||
// ////////////// // | ||||
// x-axis data | ||||
|
r695 | QTest::addColumn<DataContainer>("xAxisData"); | ||
|
r455 | // values data | ||
|
r695 | QTest::addColumn<DataContainer>("valuesData"); | ||
|
r455 | |||
// expected x-axis data | ||||
|
r695 | QTest::addColumn<DataContainer>("expectedXAxisData"); | ||
|
r455 | // expected values data | ||
|
r695 | QTest::addColumn<DataContainer>("expectedValuesData"); | ||
|
r455 | |||
// ////////// // | ||||
// Test cases // | ||||
// ////////// // | ||||
QTest::newRow("invalidData (different sizes of vectors)") | ||||
|
r695 | << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << DataContainer{} | ||
<< DataContainer{}; | ||||
|
r455 | |||
|
r695 | QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.} | ||
<< DataContainer{100., 200., 300., 400., 500.} | ||||
<< DataContainer{1., 2., 3., 4., 5.} | ||||
<< DataContainer{100., 200., 300., 400., 500.}; | ||||
|
r455 | |||
|
r695 | QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.} | ||
<< DataContainer{100., 200., 300., 400., 500.} | ||||
<< DataContainer{1., 2., 3., 4., 5.} | ||||
<< DataContainer{500., 400., 300., 200., 100.}; | ||||
|
r455 | |||
QTest::newRow("unsortedData2") | ||||
|
r695 | << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.} | ||
<< DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.}; | ||||
|
r455 | } | ||
void TestDataSeries::testCtor() | ||||
{ | ||||
// Creates series | ||||
|
r695 | QFETCH(DataContainer, xAxisData); | ||
QFETCH(DataContainer, valuesData); | ||||
|
r455 | |||
auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), | ||||
Unit{}, Unit{}); | ||||
// Validates results : we check that the data series is sorted on its x-axis data | ||||
|
r695 | QFETCH(DataContainer, expectedXAxisData); | ||
QFETCH(DataContainer, expectedValuesData); | ||||
|
r455 | |||
|
r647 | validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData); | ||
|
r455 | } | ||
namespace { | ||||
|
r695 | std::shared_ptr<ScalarSeries> createScalarSeries(DataContainer xAxisData, DataContainer valuesData) | ||
|
r455 | { | ||
return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{}, | ||||
Unit{}); | ||||
} | ||||
|
r695 | std::shared_ptr<VectorSeries> createVectorSeries(DataContainer xAxisData, DataContainer xValuesData, | ||
DataContainer yValuesData, | ||||
DataContainer zValuesData) | ||||
|
r612 | { | ||
return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData), | ||||
std::move(yValuesData), std::move(zValuesData), Unit{}, | ||||
Unit{}); | ||||
} | ||||
|
r455 | } // namespace | ||
void TestDataSeries::testMerge_data() | ||||
{ | ||||
// ////////////// // | ||||
// Test structure // | ||||
// ////////////// // | ||||
// Data series to merge | ||||
QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries"); | ||||
QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2"); | ||||
// Expected values in the first data series after merge | ||||
|
r695 | QTest::addColumn<DataContainer>("expectedXAxisData"); | ||
QTest::addColumn<DataContainer>("expectedValuesData"); | ||||
|
r455 | |||
// ////////// // | ||||
// Test cases // | ||||
// ////////// // | ||||
QTest::newRow("sortedMerge") | ||||
|
r613 | << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) | ||
<< createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.}) | ||||
|
r695 | << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.} | ||
<< DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.}; | ||||
|
r455 | |||
QTest::newRow("unsortedMerge") | ||||
|
r613 | << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.}) | ||
<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) | ||||
|
r695 | << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.} | ||
<< DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.}; | ||||
|
r455 | |||
|
r695 | QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)") | ||
<< createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 800., 900., 1000.}) | ||||
<< createScalarSeries({3., 4., 5., 6., 7.}, {300., 400., 500., 600., 700.}) | ||||
<< DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.}; | ||||
|
r455 | |||
QTest::newRow("unsortedMerge3") | ||||
|
r695 | << createScalarSeries({3., 4., 5., 7., 8}, {300., 400., 500., 700., 800.}) | ||
<< createScalarSeries({1., 2., 3., 7., 10.}, {100., 200., 333., 777., 1000.}) | ||||
<< DataContainer{1., 2., 3., 4., 5., 7., 8., 10.} | ||||
<< DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.}; | ||||
|
r455 | } | ||
void TestDataSeries::testMerge() | ||||
{ | ||||
// Merges series | ||||
QFETCH(std::shared_ptr<ScalarSeries>, dataSeries); | ||||
QFETCH(std::shared_ptr<ScalarSeries>, dataSeries2); | ||||
dataSeries->merge(dataSeries2.get()); | ||||
// Validates results : we check that the merge is valid and the data series is sorted on its | ||||
// x-axis data | ||||
|
r695 | QFETCH(DataContainer, expectedXAxisData); | ||
QFETCH(DataContainer, expectedValuesData); | ||||
|
r455 | |||
|
r647 | validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData); | ||
|
r455 | } | ||
|
r798 | void TestDataSeries::testMergeVectorInScalar_data() | ||
{ | ||||
testMergeDifferentTypesStructure<VectorSeries, ScalarSeries>(); | ||||
// ////////// // | ||||
// Test cases // | ||||
// ////////// // | ||||
QTest::newRow("purgeVectorInScalar") | ||||
<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) | ||||
<< createVectorSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.}, | ||||
{610., 710., 810., 910., 1010.}, {620., 720., 820., 920., 1020.}) | ||||
<< DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300., 400., 500.}; | ||||
} | ||||
void TestDataSeries::testMergeVectorInScalar() | ||||
{ | ||||
testMergeDifferentTypes<VectorSeries, ScalarSeries>(); | ||||
} | ||||
|
r678 | void TestDataSeries::testPurgeScalar_data() | ||
{ | ||||
testPurgeStructure<ScalarSeries>(); | ||||
// ////////// // | ||||
// Test cases // | ||||
// ////////// // | ||||
QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.}, | ||||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 2. << 4. << DataContainer{2., 3., 4.} | ||
<< std::vector<DataContainer>{{200., 300., 400.}}; | ||||
|
r797 | QTest::newRow("purgeScalar1 (min/max swap)") | ||
<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 4. << 2. | ||||
<< DataContainer{2., 3., 4.} << std::vector<DataContainer>{{200., 300., 400.}}; | ||||
|
r678 | QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 0. << 2.5 << DataContainer{1., 2.} | ||
<< std::vector<DataContainer>{{100., 200.}}; | ||||
|
r678 | QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 3.5 << 7. << DataContainer{4., 5.} | ||
<< std::vector<DataContainer>{{400., 500.}}; | ||||
|
r678 | QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 0. << 7. << DataContainer{1., 2., 3., 4., 5.} | ||
<< std::vector<DataContainer>{{100., 200., 300., 400., 500.}}; | ||||
|
r678 | QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}}; | ||
|
r678 | } | ||
void TestDataSeries::testPurgeScalar() | ||||
{ | ||||
testPurge<ScalarSeries>(); | ||||
} | ||||
void TestDataSeries::testPurgeVector_data() | ||||
{ | ||||
testPurgeStructure<VectorSeries>(); | ||||
// ////////// // | ||||
// Test cases // | ||||
// ////////// // | ||||
QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.}, | ||||
{11., 12., 13., 14., 15.}, | ||||
{16., 17., 18., 19., 20.}) | ||||
|
r695 | << 2. << 4. << DataContainer{2., 3., 4.} | ||
<< std::vector<DataContainer>{ | ||||
|
r678 | {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}}; | ||
} | ||||
void TestDataSeries::testPurgeVector() | ||||
{ | ||||
testPurge<VectorSeries>(); | ||||
} | ||||
|
r604 | void TestDataSeries::testMinXAxisData_data() | ||
|
r599 | { | ||
// ////////////// // | ||||
// 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 // | ||||
// ////////// // | ||||
|
r613 | QTest::newRow("minData1") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r599 | << 0. << true << 1.; | ||
|
r613 | QTest::newRow("minData2") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r599 | << 1. << true << 1.; | ||
|
r613 | QTest::newRow("minData3") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r599 | << 1.1 << true << 2.; | ||
|
r613 | QTest::newRow("minData4") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r599 | << 5. << true << 5.; | ||
|
r613 | QTest::newRow("minData5") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r599 | << 5.1 << false << std::numeric_limits<double>::quiet_NaN(); | ||
|
r613 | QTest::newRow("minData6") << createScalarSeries({}, {}) << 1.1 << false | ||
|
r599 | << std::numeric_limits<double>::quiet_NaN(); | ||
} | ||||
|
r604 | void TestDataSeries::testMinXAxisData() | ||
|
r599 | { | ||
QFETCH(std::shared_ptr<ScalarSeries>, dataSeries); | ||||
QFETCH(double, min); | ||||
QFETCH(bool, expectedOK); | ||||
QFETCH(double, expectedMin); | ||||
|
r604 | auto it = dataSeries->minXAxisData(min); | ||
|
r599 | |||
QCOMPARE(expectedOK, it != dataSeries->cend()); | ||||
// If the method doesn't return a end iterator, checks with expected value | ||||
if (expectedOK) { | ||||
QCOMPARE(expectedMin, it->x()); | ||||
} | ||||
} | ||||
|
r600 | |||
|
r604 | void TestDataSeries::testMaxXAxisData_data() | ||
|
r600 | { | ||
// ////////////// // | ||||
// 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 // | ||||
// ////////// // | ||||
|
r613 | QTest::newRow("maxData1") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r600 | << 6. << true << 5.; | ||
|
r613 | QTest::newRow("maxData2") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r600 | << 5. << true << 5.; | ||
|
r613 | QTest::newRow("maxData3") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r600 | << 4.9 << true << 4.; | ||
|
r613 | QTest::newRow("maxData4") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r600 | << 1.1 << true << 1.; | ||
|
r613 | QTest::newRow("maxData5") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r600 | << 1. << true << 1.; | ||
|
r613 | QTest::newRow("maxData6") << createScalarSeries({}, {}) << 1.1 << false | ||
|
r600 | << std::numeric_limits<double>::quiet_NaN(); | ||
} | ||||
|
r604 | void TestDataSeries::testMaxXAxisData() | ||
|
r600 | { | ||
QFETCH(std::shared_ptr<ScalarSeries>, dataSeries); | ||||
QFETCH(double, max); | ||||
QFETCH(bool, expectedOK); | ||||
QFETCH(double, expectedMax); | ||||
|
r604 | auto it = dataSeries->maxXAxisData(max); | ||
|
r600 | |||
QCOMPARE(expectedOK, it != dataSeries->cend()); | ||||
// If the method doesn't return a end iterator, checks with expected value | ||||
if (expectedOK) { | ||||
QCOMPARE(expectedMax, it->x()); | ||||
} | ||||
} | ||||
|
r605 | void TestDataSeries::testXAxisRange_data() | ||
|
r586 | { | ||
// ////////////// // | ||||
// Test structure // | ||||
// ////////////// // | ||||
|
r605 | // Data series to get x-axis range | ||
|
r586 | QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries"); | ||
// Min/max values | ||||
QTest::addColumn<double>("min"); | ||||
QTest::addColumn<double>("max"); | ||||
|
r605 | // Expected values | ||
|
r695 | QTest::addColumn<DataContainer>("expectedXAxisData"); | ||
QTest::addColumn<DataContainer>("expectedValuesData"); | ||||
|
r586 | |||
// ////////// // | ||||
// Test cases // | ||||
// ////////// // | ||||
|
r797 | QTest::newRow("xAxisRange") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
<< -1. << 3.2 << DataContainer{1., 2., 3.} | ||||
<< DataContainer{100., 200., 300.}; | ||||
QTest::newRow("xAxisRange1 (min/max swap)") | ||||
<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 3.2 << -1. | ||||
<< DataContainer{1., 2., 3.} << DataContainer{100., 200., 300.}; | ||||
|
r613 | QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 1. << 4. << DataContainer{1., 2., 3., 4.} | ||
<< DataContainer{100., 200., 300., 400.}; | ||||
|
r613 | QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 1. << 3.9 << DataContainer{1., 2., 3.} | ||
<< DataContainer{100., 200., 300.}; | ||||
|
r613 | QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 0. << 0.9 << DataContainer{} << DataContainer{}; | ||
|
r613 | QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 0. << 1. << DataContainer{1.} << DataContainer{100.}; | ||
|
r613 | QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 2.1 << 6. << DataContainer{3., 4., 5.} | ||
<< DataContainer{300., 400., 500.}; | ||||
|
r613 | QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 6. << 9. << DataContainer{} << DataContainer{}; | ||
|
r613 | QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.}, | ||
{100., 200., 300., 400., 500.}) | ||||
|
r695 | << 5. << 9. << DataContainer{5.} << DataContainer{500.}; | ||
|
r586 | } | ||
|
r605 | void TestDataSeries::testXAxisRange() | ||
|
r586 | { | ||
QFETCH(std::shared_ptr<ScalarSeries>, dataSeries); | ||||
QFETCH(double, min); | ||||
QFETCH(double, max); | ||||
|
r695 | QFETCH(DataContainer, expectedXAxisData); | ||
QFETCH(DataContainer, expectedValuesData); | ||||
|
r586 | |||
|
r605 | auto bounds = dataSeries->xAxisRange(min, max); | ||
|
r647 | validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData); | ||
|
r586 | } | ||
|
r611 | void TestDataSeries::testValuesBoundsScalar_data() | ||
|
r610 | { | ||
|
r611 | testValuesBoundsStructure<ScalarSeries>(); | ||
|
r610 | |||
// ////////// // | ||||
// Test cases // | ||||
// ////////// // | ||||
|
r613 | auto nan = std::numeric_limits<double>::quiet_NaN(); | ||
QTest::newRow("scalarBounds1") | ||||
<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 6. | ||||
<< true << 100. << 500.; | ||||
QTest::newRow("scalarBounds2") | ||||
<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 2. << 4. | ||||
<< true << 200. << 400.; | ||||
QTest::newRow("scalarBounds3") | ||||
<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 0.5 | ||||
<< false << nan << nan; | ||||
QTest::newRow("scalarBounds4") | ||||
<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6. | ||||
<< false << nan << nan; | ||||
|
r797 | QTest::newRow("scalarBounds5") | ||
<< createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100. << 100.; | ||||
|
r613 | QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan; | ||
|
r610 | |||
// Tests with NaN values: NaN values are not included in min/max search | ||||
|
r613 | QTest::newRow("scalarBounds7") | ||
<< createScalarSeries({1., 2., 3., 4., 5.}, {nan, 200., 300., 400., nan}) << 0. << 6. | ||||
<< true << 200. << 400.; | ||||
QTest::newRow("scalarBounds8") | ||||
<< createScalarSeries({1., 2., 3., 4., 5.}, {nan, nan, nan, nan, nan}) << 0. << 6. << true | ||||
<< std::numeric_limits<double>::quiet_NaN() << std::numeric_limits<double>::quiet_NaN(); | ||||
|
r610 | } | ||
|
r611 | void TestDataSeries::testValuesBoundsScalar() | ||
|
r610 | { | ||
|
r611 | testValuesBounds<ScalarSeries>(); | ||
|
r610 | } | ||
|
r612 | void TestDataSeries::testValuesBoundsVector_data() | ||
{ | ||||
testValuesBoundsStructure<VectorSeries>(); | ||||
// ////////// // | ||||
// Test cases // | ||||
// ////////// // | ||||
|
r613 | auto nan = std::numeric_limits<double>::quiet_NaN(); | ||
|
r612 | |||
QTest::newRow("vectorBounds1") | ||||
<< createVectorSeries({1., 2., 3., 4., 5.}, {10., 15., 20., 13., 12.}, | ||||
{35., 24., 10., 9., 0.3}, {13., 14., 12., 9., 24.}) | ||||
<< 0. << 6. << true << 0.3 << 35.; // min/max in same component | ||||
QTest::newRow("vectorBounds2") | ||||
<< createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.}, | ||||
{35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.}) | ||||
<< 0. << 6. << true << 2.3 << 35.; // min/max in same entry | ||||
QTest::newRow("vectorBounds3") | ||||
<< createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.}, | ||||
{35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.}) | ||||
<< 2. << 3. << true << 10. << 24.; | ||||
// Tests with NaN values: NaN values are not included in min/max search | ||||
QTest::newRow("vectorBounds4") | ||||
|
r613 | << createVectorSeries({1., 2.}, {nan, nan}, {nan, nan}, {nan, nan}) << 0. << 6. << true | ||
<< nan << nan; | ||||
|
r612 | } | ||
void TestDataSeries::testValuesBoundsVector() | ||||
{ | ||||
testValuesBounds<VectorSeries>(); | ||||
} | ||||
|
r455 | QTEST_MAIN(TestDataSeries) | ||
#include "TestDataSeries.moc" | ||||