GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r645:17f44c407bff

Uses std::vector instead of QVector in ArrayData (2)...

Alexandre Leroux -

r645:17f44c407bff

parent child

Context file:

r645:17f44c407bff

Collapse all files

core/tests/Data/TestDataSeries.cpp +77 -79

             namespace {
-            void validateRange(DataSeriesIterator first, DataSeriesIterator last, const QVector<double> &xData,
+            using DataContainer = std::vector<double>;
-                               const QVector<double> &valuesData)
+            void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
+                               const DataContainer &valuesData)
             {
                 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
                                    [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
                     [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
             }
-            void validateRange(DataSeriesIterator first, DataSeriesIterator last, const QVector<double> &xData,
+            void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
-                               const QVector<QVector<double> > &valuesData)
+                               const std::vector<DataContainer> &valuesData)
             {
                 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
                                    [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
                     QTest::addColumn<double>("max");
                     // Expected values after purge
-                    QTest::addColumn<QVector<double> >("expectedXAxisData");
+                    QTest::addColumn<DataContainer>("expectedXAxisData");
-                    QTest::addColumn<QVector<QVector<double> > >("expectedValuesData");
+                    QTest::addColumn<std::vector<DataContainer> >("expectedValuesData");
                 }
                 template <typename T>
                     dataSeries->purge(min, max);
                     // Validates results
-                    QFETCH(QVector<double>, expectedXAxisData);
+                    QFETCH(DataContainer, expectedXAxisData);
-                    QFETCH(QVector<QVector<double> >, expectedValuesData);
+                    QFETCH(std::vector<DataContainer>, expectedValuesData);
                     validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData,
                                   expectedValuesData);
                 // ////////////// //
                 // x-axis data
-                QTest::addColumn<QVector<double> >("xAxisData");
+                QTest::addColumn<DataContainer>("xAxisData");
                 // values data
-                QTest::addColumn<QVector<double> >("valuesData");
+                QTest::addColumn<DataContainer>("valuesData");
                 // expected x-axis data
-                QTest::addColumn<QVector<double> >("expectedXAxisData");
+                QTest::addColumn<DataContainer>("expectedXAxisData");
                 // expected values data
-                QTest::addColumn<QVector<double> >("expectedValuesData");
+                QTest::addColumn<DataContainer>("expectedValuesData");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 QTest::newRow("invalidData (different sizes of vectors)")
-                    << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 200., 300.}
+                    << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << DataContainer{}
-                    << QVector<double>{} << QVector<double>{};
+                    << DataContainer{};
-                QTest::newRow("sortedData") << QVector<double>{1., 2., 3., 4., 5.}
+                QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
-                                            << QVector<double>{100., 200., 300., 400., 500.}
+                                            << DataContainer{100., 200., 300., 400., 500.}
-                                            << QVector<double>{1., 2., 3., 4., 5.}
+                                            << DataContainer{1., 2., 3., 4., 5.}
-                                            << QVector<double>{100., 200., 300., 400., 500.};
+                                            << DataContainer{100., 200., 300., 400., 500.};
-                QTest::newRow("unsortedData") << QVector<double>{5., 4., 3., 2., 1.}
+                QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
-                                              << QVector<double>{100., 200., 300., 400., 500.}
+                                              << DataContainer{100., 200., 300., 400., 500.}
-                                              << QVector<double>{1., 2., 3., 4., 5.}
+                                              << DataContainer{1., 2., 3., 4., 5.}
-                                              << QVector<double>{500., 400., 300., 200., 100.};
+                                              << DataContainer{500., 400., 300., 200., 100.};
                 QTest::newRow("unsortedData2")
-                    << QVector<double>{1., 4., 3., 5., 2.} << QVector<double>{100., 200., 300., 400., 500.}
+                    << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.}
-                    << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 500., 300., 200., 400.};
+                    << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
             }
             void TestDataSeries::testCtor()
             {
                 // Creates series
-                QFETCH(QVector<double>, xAxisData);
+                QFETCH(DataContainer, xAxisData);
-                QFETCH(QVector<double>, valuesData);
+                QFETCH(DataContainer, valuesData);
                 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(QVector<double>, expectedXAxisData);
+                QFETCH(DataContainer, expectedXAxisData);
-                QFETCH(QVector<double>, expectedValuesData);
+                QFETCH(DataContainer, expectedValuesData);
                 validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
             }
             namespace {
-            std::shared_ptr<ScalarSeries> createScalarSeries(QVector<double> xAxisData,
+            std::shared_ptr<ScalarSeries> createScalarSeries(DataContainer xAxisData, DataContainer valuesData)
-                                                             QVector<double> valuesData)
             {
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
                                                       Unit{});
             }
-            std::shared_ptr<VectorSeries> createVectorSeries(QVector<double> xAxisData,
+            std::shared_ptr<VectorSeries> createVectorSeries(DataContainer xAxisData, DataContainer xValuesData,
-                                                             QVector<double> xValuesData,
+                                                             DataContainer yValuesData,
-                                                             QVector<double> yValuesData,
+                                                             DataContainer zValuesData)
-                                                             QVector<double> zValuesData)
             {
                 return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
                                                       std::move(yValuesData), std::move(zValuesData), Unit{},
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
                 // Expected values in the first data series after merge
-                QTest::addColumn<QVector<double> >("expectedXAxisData");
+                QTest::addColumn<DataContainer>("expectedXAxisData");
-                QTest::addColumn<QVector<double> >("expectedValuesData");
+                QTest::addColumn<DataContainer>("expectedValuesData");
                 // ////////// //
                 // Test cases //
                 QTest::newRow("sortedMerge")
                     << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
                     << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
-                    << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
+                    << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
-                    << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
+                    << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge")
                     << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
                     << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
-                    << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
+                    << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
-                    << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
+                    << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
-                QTest::newRow("unsortedMerge2")
+                QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
-                    << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 300., 400., 500.})
+                    << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 800., 900., 1000.})
-                    << createScalarSeries({3., 4., 5., 6., 7.}, {600., 700., 800., 900., 1000.})
+                    << createScalarSeries({3., 4., 5., 6., 7.}, {300., 400., 500., 600., 700.})
-                    << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
+                    << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
-                    << QVector<double>{100., 200., 600., 700., 800., 900., 1000., 300., 400., 500.};
                 QTest::newRow("unsortedMerge3")
-                    << createScalarSeries({3., 5., 8., 7., 2}, {100., 200., 300., 400., 500.})
+                    << createScalarSeries({3., 4., 5., 7., 8}, {300., 400., 500., 700., 800.})
-                    << createScalarSeries({6., 4., 9., 10., 1.}, {600., 700., 800., 900., 1000.})
+                    << createScalarSeries({1., 2., 3., 7., 10.}, {100., 200., 333., 777., 1000.})
-                    << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
+                    << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
-                    << QVector<double>{1000., 500., 100., 700., 200., 600., 400., 300., 800., 900.};
+                    << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
             }
             void TestDataSeries::testMerge()
                 // Validates results : we check that the merge is valid and the data series is sorted on its
                 // x-axis data
-                QFETCH(QVector<double>, expectedXAxisData);
+                QFETCH(DataContainer, expectedXAxisData);
-                QFETCH(QVector<double>, expectedValuesData);
+                QFETCH(DataContainer, expectedValuesData);
                 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
             }
                 QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
-                                             << 2. << 4. << QVector<double>{2., 3., 4.}
+                                             << 2. << 4. << DataContainer{2., 3., 4.}
-                                             << QVector<QVector<double> >{{200., 300., 400.}};
+                                             << std::vector<DataContainer>{{200., 300., 400.}};
                 QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                     {100., 200., 300., 400., 500.})
-                                              << 0. << 2.5 << QVector<double>{1., 2.}
+                                              << 0. << 2.5 << DataContainer{1., 2.}
-                                              << QVector<QVector<double> >{{100., 200.}};
+                                              << std::vector<DataContainer>{{100., 200.}};
                 QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                     {100., 200., 300., 400., 500.})
-                                              << 3.5 << 7. << QVector<double>{4., 5.}
+                                              << 3.5 << 7. << DataContainer{4., 5.}
-                                              << QVector<QVector<double> >{{400., 500.}};
+                                              << std::vector<DataContainer>{{400., 500.}};
                 QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                     {100., 200., 300., 400., 500.})
-                                              << 0. << 7. << QVector<double>{1., 2., 3., 4., 5.}
+                                              << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
-                                              << QVector<QVector<double> >{{100., 200., 300., 400., 500.}};
+                                              << std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
                 QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                     {100., 200., 300., 400., 500.})
-                                              << 5.5 << 7. << QVector<double>{}
+                                              << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
-                                              << QVector<QVector<double> >{{}};
             }
             void TestDataSeries::testPurgeScalar()
                 QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.},
                                                                    {11., 12., 13., 14., 15.},
                                                                    {16., 17., 18., 19., 20.})
-                                             << 2. << 4. << QVector<double>{2., 3., 4.}
+                                             << 2. << 4. << DataContainer{2., 3., 4.}
-                                             << QVector<QVector<double> >{
+                                             << std::vector<DataContainer>{
                                                     {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}};
             }
                 QTest::addColumn<double>("max");
                 // Expected values
-                QTest::addColumn<QVector<double> >("expectedXAxisData");
+                QTest::addColumn<DataContainer>("expectedXAxisData");
-                QTest::addColumn<QVector<double> >("expectedValuesData");
+                QTest::addColumn<DataContainer>("expectedValuesData");
                 // ////////// //
                 // Test cases //
                 QTest::newRow("xAxisRange1") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
-                                             << -1. << 3.2 << QVector<double>{1., 2., 3.}
+                                             << -1. << 3.2 << DataContainer{1., 2., 3.}
-                                             << QVector<double>{100., 200., 300.};
+                                             << DataContainer{100., 200., 300.};
                 QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
-                                             << 1. << 4. << QVector<double>{1., 2., 3., 4.}
+                                             << 1. << 4. << DataContainer{1., 2., 3., 4.}
-                                             << QVector<double>{100., 200., 300., 400.};
+                                             << DataContainer{100., 200., 300., 400.};
                 QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
-                                             << 1. << 3.9 << QVector<double>{1., 2., 3.}
+                                             << 1. << 3.9 << DataContainer{1., 2., 3.}
-                                             << QVector<double>{100., 200., 300.};
+                                             << DataContainer{100., 200., 300.};
                 QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
-                                             << 0. << 0.9 << QVector<double>{} << QVector<double>{};
+                                             << 0. << 0.9 << DataContainer{} << DataContainer{};
                 QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
-                                             << 0. << 1. << QVector<double>{1.} << QVector<double>{100.};
+                                             << 0. << 1. << DataContainer{1.} << DataContainer{100.};
                 QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
-                                             << 2.1 << 6. << QVector<double>{3., 4., 5.}
+                                             << 2.1 << 6. << DataContainer{3., 4., 5.}
-                                             << QVector<double>{300., 400., 500.};
+                                             << DataContainer{300., 400., 500.};
                 QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
-                                             << 6. << 9. << QVector<double>{} << QVector<double>{};
+                                             << 6. << 9. << DataContainer{} << DataContainer{};
                 QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
                                                                    {100., 200., 300., 400., 500.})
-                                             << 5. << 9. << QVector<double>{5.} << QVector<double>{500.};
+                                             << 5. << 9. << DataContainer{5.} << DataContainer{500.};
             }
             void TestDataSeries::testXAxisRange()
                 QFETCH(double, min);
                 QFETCH(double, max);
-                QFETCH(QVector<double>, expectedXAxisData);
+                QFETCH(DataContainer, expectedXAxisData);
-                QFETCH(QVector<double>, expectedValuesData);
+                QFETCH(DataContainer, expectedValuesData);
                 auto bounds = dataSeries->xAxisRange(min, max);
                 validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);

core/tests/Data/TestOneDimArrayData.cpp +42 -42

             namespace {
-            void verifyArrayData(const ArrayData<1> &arrayData, const QVector<double> &expectedData)
+            using DataContainer = std::vector<double>;
+            void verifyArrayData(const ArrayData<1> &arrayData, const DataContainer &expectedData)
             {
                 QVERIFY(std::equal(
                     arrayData.cbegin(), arrayData.cend(), expectedData.cbegin(), expectedData.cend(),
             void TestOneDimArrayData::testData_data()
             {
                 // Test structure
-                QTest::addColumn<QVector<double> >("inputData");    // array's data input
+                QTest::addColumn<DataContainer>("inputData");    // array's data input
-                QTest::addColumn<QVector<double> >("expectedData"); // expected data
+                QTest::addColumn<DataContainer>("expectedData"); // expected data
                 // Test cases
-                QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.}
+                QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.}
-                                       << QVector<double>{1., 2., 3., 4., 5.};
+                                       << DataContainer{1., 2., 3., 4., 5.};
             }
             void TestOneDimArrayData::testData()
             {
-                QFETCH(QVector<double>, inputData);
+                QFETCH(DataContainer, inputData);
-                QFETCH(QVector<double>, expectedData);
+                QFETCH(DataContainer, expectedData);
                 ArrayData<1> arrayData{inputData};
                 verifyArrayData(arrayData, expectedData);
             void TestOneDimArrayData::testAdd_data()
             {
                 // Test structure
-                QTest::addColumn<QVector<double> >("inputData");    // array's data input
+                QTest::addColumn<DataContainer>("inputData");    // array's data input
-                QTest::addColumn<QVector<double> >("otherData");    // array data's input to merge with
+                QTest::addColumn<DataContainer>("otherData");    // array data's input to merge with
-                QTest::addColumn<bool>("prepend");                  // prepend or append merge
+                QTest::addColumn<bool>("prepend");               // prepend or append merge
-                QTest::addColumn<QVector<double> >("expectedData"); // expected data after merge
+                QTest::addColumn<DataContainer>("expectedData"); // expected data after merge
                 // Test cases
-                QTest::newRow("appendMerge") << QVector<double>{1., 2., 3., 4., 5.}
+                QTest::newRow("appendMerge") << DataContainer{1., 2., 3., 4., 5.} << DataContainer{6., 7., 8.}
-                                             << QVector<double>{6., 7., 8.} << false
+                                             << false << DataContainer{1., 2., 3., 4., 5., 6., 7., 8.};
-                                             << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8.};
+                QTest::newRow("prependMerge") << DataContainer{1., 2., 3., 4., 5.} << DataContainer{6., 7., 8.}
-                QTest::newRow("prependMerge") << QVector<double>{1., 2., 3., 4., 5.}
+                                              << true << DataContainer{6., 7., 8., 1., 2., 3., 4., 5.};
-                                              << QVector<double>{6., 7., 8.} << true
-                                              << QVector<double>{6., 7., 8., 1., 2., 3., 4., 5.};
             }
             void TestOneDimArrayData::testAdd()
             {
-                QFETCH(QVector<double>, inputData);
+                QFETCH(DataContainer, inputData);
-                QFETCH(QVector<double>, otherData);
+                QFETCH(DataContainer, otherData);
                 QFETCH(bool, prepend);
-                QFETCH(QVector<double>, expectedData);
+                QFETCH(DataContainer, expectedData);
                 ArrayData<1> arrayData{inputData};
                 ArrayData<1> other{otherData};
             void TestOneDimArrayData::testAt_data()
             {
                 // Test structure
-                QTest::addColumn<QVector<double> >("inputData"); // array data's input
+                QTest::addColumn<DataContainer>("inputData"); // array data's input
-                QTest::addColumn<int>("index");                  // index to retrieve data
+                QTest::addColumn<int>("index");               // index to retrieve data
-                QTest::addColumn<double>("expectedData");        // expected data at index
+                QTest::addColumn<double>("expectedData");     // expected data at index
                 // Test cases
-                QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 0 << 1.;
+                QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.} << 0 << 1.;
-                QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << 3 << 4.;
+                QTest::newRow("data2") << DataContainer{1., 2., 3., 4., 5.} << 3 << 4.;
             }
             void TestOneDimArrayData::testAt()
             {
-                QFETCH(QVector<double>, inputData);
+                QFETCH(DataContainer, inputData);
                 QFETCH(int, index);
                 QFETCH(double, expectedData);
             void TestOneDimArrayData::testClear_data()
             {
                 // Test structure
-                QTest::addColumn<QVector<double> >("inputData"); // array data's input
+                QTest::addColumn<DataContainer>("inputData"); // array data's input
                 // Test cases
-                QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.};
+                QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.};
             }
             void TestOneDimArrayData::testClear()
             {
-                QFETCH(QVector<double>, inputData);
+                QFETCH(DataContainer, inputData);
                 ArrayData<1> arrayData{inputData};
                 arrayData.clear();
-                verifyArrayData(arrayData, QVector<double>{});
+                verifyArrayData(arrayData, DataContainer{});
             }
             void TestOneDimArrayData::testSize_data()
             {
                 // Test structure
-                QTest::addColumn<QVector<double> >("inputData"); // array data's input
+                QTest::addColumn<DataContainer>("inputData"); // array data's input
-                QTest::addColumn<int>("expectedSize");           // expected array data size
+                QTest::addColumn<int>("expectedSize");        // expected array data size
                 // Test cases
-                QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 5;
+                QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.} << 5;
             }
             void TestOneDimArrayData::testSize()
             {
-                QFETCH(QVector<double>, inputData);
+                QFETCH(DataContainer, inputData);
                 QFETCH(int, expectedSize);
                 ArrayData<1> arrayData{inputData};
             void TestOneDimArrayData::testSort_data()
             {
                 // Test structure
-                QTest::addColumn<QVector<double> >("inputData");        // array data's input
+                QTest::addColumn<DataContainer>("inputData");           // array data's input
                 QTest::addColumn<std::vector<int> >("sortPermutation"); // permutation used to sort data
-                QTest::addColumn<QVector<double> >("expectedData");     // expected data after sorting
+                QTest::addColumn<DataContainer>("expectedData");        // expected data after sorting
                 // Test cases
-                QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{0, 2, 3, 1, 4}
+                QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.} << std::vector<int>{0, 2, 3, 1, 4}
-                                       << QVector<double>{1., 3., 4., 2., 5.};
+                                       << DataContainer{1., 3., 4., 2., 5.};
-                QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{4, 1, 2, 3, 0}
+                QTest::newRow("data2") << DataContainer{1., 2., 3., 4., 5.} << std::vector<int>{4, 1, 2, 3, 0}
-                                       << QVector<double>{5., 2., 3., 4., 1.};
+                                       << DataContainer{5., 2., 3., 4., 1.};
             }
             void TestOneDimArrayData::testSort()
             {
-                QFETCH(QVector<double>, inputData);
+                QFETCH(DataContainer, inputData);
                 QFETCH(std::vector<int>, sortPermutation);
-                QFETCH(QVector<double>, expectedData);
+                QFETCH(DataContainer, expectedData);
                 ArrayData<1> arrayData{inputData};
                 auto sortedArrayData = arrayData.sort(sortPermutation);

core/tests/Data/TestTwoDimArrayData.cpp +9 -8

             #include <QObject>
             #include <QtTest>
-            using Container = QVector<QVector<double> >;
+            using DataContainer = std::vector<double>;
-            using InputData = QPair<QVector<double>, int>;
+            using Container = std::vector<DataContainer>;
+            using InputData = QPair<DataContainer, int>;
             namespace {
             InputData flatten(const Container &container)
             {
-                if (container.isEmpty()) {
+                if (container.empty()) {
                     return {};
                 }
                 // We assume here that each component of the container have the same size
                 auto containerSize = container.size();
-                auto componentSize = container.first().size();
+                auto componentSize = container.front().size();
-                auto result = QVector<double>{};
+                auto result = DataContainer{};
                 result.reserve(componentSize * containerSize);
                 for (auto i = 0; i < componentSize; ++i) {
                     for (auto j = 0; j < containerSize; ++j) {
-                        result.append(container.at(j).at(i));
+                        result.push_back(container.at(j).at(i));
                     }
                 }
-                return {result, containerSize};
+                return {result, static_cast<int>(containerSize)};
             }
             void verifyArrayData(const ArrayData<2> &arrayData, const Container &expectedData)
                 ArrayData<2> arrayData{inputData.first, inputData.second};
                 arrayData.clear();
-                auto emptyData = Container(inputData.second, QVector<double>{});
+                auto emptyData = Container(inputData.second, DataContainer{});
                 verifyArrayData(arrayData, emptyData);
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages