|
|
#include "Data/ScalarSeries.h"
|
|
|
|
|
|
#include "DataSeriesBuilders.h"
|
|
|
#include "DataSeriesUtils.h"
|
|
|
|
|
|
#include <QObject>
|
|
|
#include <QtTest>
|
|
|
|
|
|
/**
|
|
|
* @brief The TestScalarSeries class defines unit tests on scalar series.
|
|
|
*
|
|
|
* Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesUtils)
|
|
|
*/
|
|
|
class TestScalarSeries : public QObject {
|
|
|
Q_OBJECT
|
|
|
private slots:
|
|
|
/// Tests construction of a scalar series
|
|
|
void testCtor_data();
|
|
|
void testCtor();
|
|
|
|
|
|
/// Tests merge of two scalar series
|
|
|
void testMerge_data();
|
|
|
void testMerge();
|
|
|
|
|
|
/// Tests merge of a vector series in a scalar series
|
|
|
void testMergeWithVector_data();
|
|
|
void testMergeWithVector();
|
|
|
|
|
|
/// Tests get min x-axis data of a scalar series
|
|
|
void testMinXAxisData_data();
|
|
|
void testMinXAxisData();
|
|
|
|
|
|
/// Tests get max x-axis data of a scalar series
|
|
|
void testMaxXAxisData_data();
|
|
|
void testMaxXAxisData();
|
|
|
|
|
|
/// Tests purge of a scalar series
|
|
|
void testPurge_data();
|
|
|
void testPurge();
|
|
|
|
|
|
/// Tests get x-axis range of a scalar series
|
|
|
void testXAxisRange_data();
|
|
|
void testXAxisRange();
|
|
|
|
|
|
/// Tests get values bounds of a scalar series
|
|
|
void testValuesBounds_data();
|
|
|
void testValuesBounds();
|
|
|
};
|
|
|
|
|
|
void TestScalarSeries::testCtor_data()
|
|
|
{
|
|
|
// x-axis data
|
|
|
QTest::addColumn<DataContainer>("xAxisData");
|
|
|
// values data
|
|
|
QTest::addColumn<DataContainer>("valuesData");
|
|
|
|
|
|
// construction expected to be valid
|
|
|
QTest::addColumn<bool>("expectOK");
|
|
|
// expected x-axis data (when construction is valid)
|
|
|
QTest::addColumn<DataContainer>("expectedXAxisData");
|
|
|
// expected values data (when construction is valid)
|
|
|
QTest::addColumn<DataContainer>("expectedValuesData");
|
|
|
|
|
|
QTest::newRow("invalidData (different sizes of vectors)")
|
|
|
<< DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << false
|
|
|
<< DataContainer{} << DataContainer{};
|
|
|
|
|
|
QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
|
|
|
<< DataContainer{100., 200., 300., 400., 500.} << true
|
|
|
<< DataContainer{1., 2., 3., 4., 5.}
|
|
|
<< DataContainer{100., 200., 300., 400., 500.};
|
|
|
|
|
|
QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
|
|
|
<< DataContainer{100., 200., 300., 400., 500.} << true
|
|
|
<< DataContainer{1., 2., 3., 4., 5.}
|
|
|
<< DataContainer{500., 400., 300., 200., 100.};
|
|
|
|
|
|
QTest::newRow("unsortedData2")
|
|
|
<< DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.} << true
|
|
|
<< DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testCtor()
|
|
|
{
|
|
|
// Creates series
|
|
|
QFETCH(DataContainer, xAxisData);
|
|
|
QFETCH(DataContainer, valuesData);
|
|
|
QFETCH(bool, expectOK);
|
|
|
|
|
|
if (expectOK) {
|
|
|
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
|
|
|
QFETCH(DataContainer, expectedXAxisData);
|
|
|
QFETCH(DataContainer, expectedValuesData);
|
|
|
|
|
|
validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
|
|
|
}
|
|
|
else {
|
|
|
QVERIFY_EXCEPTION_THROWN(std::make_shared<ScalarSeries>(
|
|
|
std::move(xAxisData), std::move(valuesData), Unit{}, Unit{}),
|
|
|
std::invalid_argument);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testMerge_data()
|
|
|
{
|
|
|
testMerge_struct<ScalarSeries, DataContainer>();
|
|
|
|
|
|
QTest::newRow("sortedMerge") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< ScalarBuilder{}
|
|
|
.setX({6., 7., 8., 9., 10.})
|
|
|
.setValues({600., 700., 800., 900., 1000.})
|
|
|
.build()
|
|
|
<< DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
|
|
|
<< DataContainer{100., 200., 300., 400., 500.,
|
|
|
600., 700., 800., 900., 1000.};
|
|
|
|
|
|
QTest::newRow("unsortedMerge")
|
|
|
<< ScalarBuilder{}
|
|
|
.setX({6., 7., 8., 9., 10.})
|
|
|
.setValues({600., 700., 800., 900., 1000.})
|
|
|
.build()
|
|
|
<< ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
|
|
|
<< DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
|
|
|
|
|
|
QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
|
|
|
<< ScalarBuilder{}
|
|
|
.setX({1., 2., 8., 9., 10})
|
|
|
.setValues({100., 200., 800., 900., 1000.})
|
|
|
.build()
|
|
|
<< ScalarBuilder{}
|
|
|
.setX({3., 4., 5., 6., 7.})
|
|
|
.setValues({300., 400., 500., 600., 700.})
|
|
|
.build()
|
|
|
<< DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
|
|
|
|
|
|
QTest::newRow("unsortedMerge3")
|
|
|
<< ScalarBuilder{}
|
|
|
.setX({3., 4., 5., 7., 8})
|
|
|
.setValues({300., 400., 500., 700., 800.})
|
|
|
.build()
|
|
|
<< ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 7., 10.})
|
|
|
.setValues({100., 200., 333., 777., 1000.})
|
|
|
.build()
|
|
|
<< DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
|
|
|
<< DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
|
|
|
|
|
|
QTest::newRow("emptySource") << ScalarBuilder{}
|
|
|
.setX({3., 4., 5., 7., 8})
|
|
|
.setValues({300., 400., 500., 700., 800.})
|
|
|
.build()
|
|
|
<< ScalarBuilder{}.setX({}).setValues({}).build()
|
|
|
<< DataContainer{3., 4., 5., 7., 8.}
|
|
|
<< DataContainer{300., 400., 500., 700., 800.};
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testMerge()
|
|
|
{
|
|
|
testMerge_t<ScalarSeries, DataContainer>();
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testMergeWithVector_data()
|
|
|
{
|
|
|
testMergeDifferentTypes_struct<VectorSeries, ScalarSeries>();
|
|
|
|
|
|
QTest::newRow("mergeVectorInScalar") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< VectorBuilder{}
|
|
|
.setX({6., 7., 8., 9., 10.})
|
|
|
.setXValues({600., 700., 800., 900., 1000.})
|
|
|
.setYValues({610., 710., 810., 910., 1010.})
|
|
|
.setZValues({620., 720., 820., 920., 1020.})
|
|
|
.build()
|
|
|
<< DataContainer{1., 2., 3., 4., 5.}
|
|
|
<< DataContainer{100., 200., 300., 400., 500.};
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testMergeWithVector()
|
|
|
{
|
|
|
testMergeDifferentTypes_t<VectorSeries, ScalarSeries>();
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testMinXAxisData_data()
|
|
|
{
|
|
|
testMinXAxisData_struct<ScalarSeries>();
|
|
|
|
|
|
QTest::newRow("minData1") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 0. << true << 1.;
|
|
|
QTest::newRow("minData2") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 1. << true << 1.;
|
|
|
QTest::newRow("minData3") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 1.1 << true << 2.;
|
|
|
QTest::newRow("minData4") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 5. << true << 5.;
|
|
|
QTest::newRow("minData5") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 5.1 << false << std::numeric_limits<double>::quiet_NaN();
|
|
|
QTest::newRow("minData6") << ScalarBuilder{}.setX({}).setValues({}).build() << 1.1 << false
|
|
|
<< std::numeric_limits<double>::quiet_NaN();
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testMinXAxisData()
|
|
|
{
|
|
|
testMinXAxisData_t<ScalarSeries>();
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testMaxXAxisData_data()
|
|
|
{
|
|
|
testMaxXAxisData_struct<ScalarSeries>();
|
|
|
|
|
|
QTest::newRow("maxData1") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 6. << true << 5.;
|
|
|
QTest::newRow("maxData2") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 5. << true << 5.;
|
|
|
QTest::newRow("maxData3") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 4.9 << true << 4.;
|
|
|
QTest::newRow("maxData4") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 1.1 << true << 1.;
|
|
|
QTest::newRow("maxData5") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 1. << true << 1.;
|
|
|
QTest::newRow("maxData6") << ScalarBuilder{}.setX({}).setValues({}).build() << 1.1 << false
|
|
|
<< std::numeric_limits<double>::quiet_NaN();
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testMaxXAxisData()
|
|
|
{
|
|
|
testMaxXAxisData_t<ScalarSeries>();
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testPurge_data()
|
|
|
{
|
|
|
testPurge_struct<ScalarSeries>();
|
|
|
|
|
|
QTest::newRow("purgeScalar") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 2. << 4. << DataContainer{2., 3., 4.}
|
|
|
<< std::vector<DataContainer>{{200., 300., 400.}};
|
|
|
QTest::newRow("purgeScalar1 (min/max swap)") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 4. << 2. << DataContainer{2., 3., 4.}
|
|
|
<< std::vector<DataContainer>{{200., 300., 400.}};
|
|
|
QTest::newRow("purgeScalar2") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 0. << 2.5 << DataContainer{1., 2.}
|
|
|
<< std::vector<DataContainer>{{100., 200.}};
|
|
|
QTest::newRow("purgeScalar3") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 3.5 << 7. << DataContainer{4., 5.}
|
|
|
<< std::vector<DataContainer>{{400., 500.}};
|
|
|
QTest::newRow("purgeScalar4") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
|
|
|
<< std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
|
|
|
QTest::newRow("purgeScalar5") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testPurge()
|
|
|
{
|
|
|
testPurge_t<ScalarSeries>();
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testXAxisRange_data()
|
|
|
{
|
|
|
testXAxisRange_struct<ScalarSeries>();
|
|
|
|
|
|
QTest::newRow("xAxisRange") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< -1. << 3.2 << DataContainer{1., 2., 3.}
|
|
|
<< DataContainer{100., 200., 300.};
|
|
|
QTest::newRow("xAxisRange1 (min/max swap)") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 3.2 << -1. << DataContainer{1., 2., 3.}
|
|
|
<< DataContainer{100., 200., 300.};
|
|
|
QTest::newRow("xAxisRange2") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 1. << 4. << DataContainer{1., 2., 3., 4.}
|
|
|
<< DataContainer{100., 200., 300., 400.};
|
|
|
QTest::newRow("xAxisRange3") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 1. << 3.9 << DataContainer{1., 2., 3.}
|
|
|
<< DataContainer{100., 200., 300.};
|
|
|
QTest::newRow("xAxisRange4") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 0. << 0.9 << DataContainer{} << DataContainer{};
|
|
|
QTest::newRow("xAxisRange5") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 0. << 1. << DataContainer{1.} << DataContainer{100.};
|
|
|
QTest::newRow("xAxisRange6") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 2.1 << 6. << DataContainer{3., 4., 5.}
|
|
|
<< DataContainer{300., 400., 500.};
|
|
|
QTest::newRow("xAxisRange7") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 6. << 9. << DataContainer{} << DataContainer{};
|
|
|
QTest::newRow("xAxisRange8") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 5. << 9. << DataContainer{5.} << DataContainer{500.};
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testXAxisRange()
|
|
|
{
|
|
|
testXAxisRange_t<ScalarSeries>();
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testValuesBounds_data()
|
|
|
{
|
|
|
testValuesBounds_struct<ScalarSeries>();
|
|
|
|
|
|
auto nan = std::numeric_limits<double>::quiet_NaN();
|
|
|
|
|
|
QTest::newRow("scalarBounds1") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 0. << 6. << true << 100. << 500.;
|
|
|
QTest::newRow("scalarBounds2") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 2. << 4. << true << 200. << 400.;
|
|
|
QTest::newRow("scalarBounds3") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 0. << 0.5 << false << nan << nan;
|
|
|
QTest::newRow("scalarBounds4") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({100., 200., 300., 400., 500.})
|
|
|
.build()
|
|
|
<< 5.1 << 6. << false << nan << nan;
|
|
|
QTest::newRow("scalarBounds5") << ScalarBuilder{}.setX({1.}).setValues({100.}).build() << 0.
|
|
|
<< 2. << true << 100. << 100.;
|
|
|
QTest::newRow("scalarBounds6") << ScalarBuilder{}.setX({}).setValues({}).build() << 0. << 2.
|
|
|
<< false << nan << nan;
|
|
|
|
|
|
// Tests with NaN values: NaN values are not included in min/max search
|
|
|
QTest::newRow("scalarBounds7") << ScalarBuilder{}
|
|
|
.setX({1., 2., 3., 4., 5.})
|
|
|
.setValues({nan, 200., 300., 400., nan})
|
|
|
.build()
|
|
|
<< 0. << 6. << true << 200. << 400.;
|
|
|
QTest::newRow("scalarBounds8")
|
|
|
<< ScalarBuilder{}.setX({1., 2., 3., 4., 5.}).setValues({nan, nan, nan, nan, nan}).build()
|
|
|
<< 0. << 6. << true << nan << nan;
|
|
|
}
|
|
|
|
|
|
void TestScalarSeries::testValuesBounds()
|
|
|
{
|
|
|
testValuesBounds_t<ScalarSeries>();
|
|
|
}
|
|
|
|
|
|
QTEST_MAIN(TestScalarSeries)
|
|
|
#include "TestScalarSeries.moc"
|
|
|
|
