HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r695:17f44c407bff

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

Alexandre Leroux -

r695:17f44c407bff

parent child

Context file:

r695:17f44c407bff

Collapse all files

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

              namespace {
-             void validateRange(DataSeriesIterator first, DataSeriesIterator last, const QVector<double> &xData,
-                                const QVector<double> &valuesData)
+             using DataContainer = std::vector<double>;
+             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,
-                                const QVector<QVector<double> > &valuesData)
+             void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
+                                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<QVector<QVector<double> > >("expectedValuesData");
+                     QTest::addColumn<DataContainer>("expectedXAxisData");
+                     QTest::addColumn<std::vector<DataContainer> >("expectedValuesData");
                  }
                  template <typename T>
                      dataSeries->purge(min, max);
                      // Validates results
-                     QFETCH(QVector<double>, expectedXAxisData);
-                     QFETCH(QVector<QVector<double> >, expectedValuesData);
+                     QFETCH(DataContainer, expectedXAxisData);
+                     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.}
-                     << QVector<double>{} << QVector<double>{};
+                     << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << DataContainer{}
+                     << DataContainer{};
-                 QTest::newRow("sortedData") << QVector<double>{1., 2., 3., 4., 5.}
-                                             << QVector<double>{100., 200., 300., 400., 500.}
-                                             << QVector<double>{1., 2., 3., 4., 5.}
-                                             << QVector<double>{100., 200., 300., 400., 500.};
+                 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.};
-                 QTest::newRow("unsortedData") << QVector<double>{5., 4., 3., 2., 1.}
-                                               << QVector<double>{100., 200., 300., 400., 500.}
-                                               << QVector<double>{1., 2., 3., 4., 5.}
-                                               << QVector<double>{500., 400., 300., 200., 100.};
+                 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.};
                  QTest::newRow("unsortedData2")
-                     << QVector<double>{1., 4., 3., 5., 2.} << QVector<double>{100., 200., 300., 400., 500.}
-                     << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 500., 300., 200., 400.};
+                     << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.}
+                     << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
              }
              void TestDataSeries::testCtor()
              {
                  // Creates series
-                 QFETCH(QVector<double>, xAxisData);
-                 QFETCH(QVector<double>, valuesData);
+                 QFETCH(DataContainer, xAxisData);
+                 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(QVector<double>, expectedValuesData);
+                 QFETCH(DataContainer, expectedXAxisData);
+                 QFETCH(DataContainer, expectedValuesData);
                  validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
              }
              namespace {
-             std::shared_ptr<ScalarSeries> createScalarSeries(QVector<double> xAxisData,
-                                                              QVector<double> valuesData)
+             std::shared_ptr<ScalarSeries> createScalarSeries(DataContainer xAxisData, DataContainer valuesData)
              {
                  return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
                                                        Unit{});
              }
-             std::shared_ptr<VectorSeries> createVectorSeries(QVector<double> xAxisData,
-                                                              QVector<double> xValuesData,
-                                                              QVector<double> yValuesData,
-                                                              QVector<double> zValuesData)
+             std::shared_ptr<VectorSeries> createVectorSeries(DataContainer xAxisData, DataContainer xValuesData,
+                                                              DataContainer yValuesData,
+                                                              DataContainer 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<QVector<double> >("expectedValuesData");
+                 QTest::addColumn<DataContainer>("expectedXAxisData");
+                 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.}
-                     << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
+                     << 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")
                      << 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.}
-                     << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
+                     << 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")
-                     << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 300., 400., 500.})
-                     << createScalarSeries({3., 4., 5., 6., 7.}, {600., 700., 800., 900., 1000.})
-                     << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
-                     << QVector<double>{100., 200., 600., 700., 800., 900., 1000., 300., 400., 500.};
+                 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.};
                  QTest::newRow("unsortedMerge3")
-                     << createScalarSeries({3., 5., 8., 7., 2}, {100., 200., 300., 400., 500.})
-                     << createScalarSeries({6., 4., 9., 10., 1.}, {600., 700., 800., 900., 1000.})
-                     << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
-                     << QVector<double>{1000., 500., 100., 700., 200., 600., 400., 300., 800., 900.};
+                     << 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.};
              }
              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(QVector<double>, expectedValuesData);
+                 QFETCH(DataContainer, expectedXAxisData);
+                 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.}
-                                              << QVector<QVector<double> >{{200., 300., 400.}};
+                                              << 2. << 4. << DataContainer{2., 3., 4.}
+                                              << 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.}
-                                               << QVector<QVector<double> >{{100., 200.}};
+                                               << 0. << 2.5 << DataContainer{1., 2.}
+                                               << 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.}
-                                               << QVector<QVector<double> >{{400., 500.}};
+                                               << 3.5 << 7. << DataContainer{4., 5.}
+                                               << 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.}
-                                               << QVector<QVector<double> >{{100., 200., 300., 400., 500.}};
+                                               << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
+                                               << 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>{}
-                                               << QVector<QVector<double> >{{}};
+                                               << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
              }
              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.}
-                                              << QVector<QVector<double> >{
+                                              << 2. << 4. << DataContainer{2., 3., 4.}
+                                              << 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<QVector<double> >("expectedValuesData");
+                 QTest::addColumn<DataContainer>("expectedXAxisData");
+                 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.}
-                                              << QVector<double>{100., 200., 300.};
+                                              << -1. << 3.2 << DataContainer{1., 2., 3.}
+                                              << 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.}
-                                              << QVector<double>{100., 200., 300., 400.};
+                                              << 1. << 4. << DataContainer{1., 2., 3., 4.}
+                                              << 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.}
-                                              << QVector<double>{100., 200., 300.};
+                                              << 1. << 3.9 << DataContainer{1., 2., 3.}
+                                              << 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.}
-                                              << QVector<double>{300., 400., 500.};
+                                              << 2.1 << 6. << DataContainer{3., 4., 5.}
+                                              << 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(QVector<double>, expectedValuesData);
+                 QFETCH(DataContainer, expectedXAxisData);
+                 QFETCH(DataContainer, expectedValuesData);
                  auto bounds = dataSeries->xAxisRange(min, max);
                  validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);

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

              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<QVector<double> >("expectedData"); // expected data
+                 QTest::addColumn<DataContainer>("inputData");    // array's data input
+                 QTest::addColumn<DataContainer>("expectedData"); // expected data
                  // Test cases
-                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.}
-                                        << QVector<double>{1., 2., 3., 4., 5.};
+                 QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.}
+                                        << DataContainer{1., 2., 3., 4., 5.};
              }
              void TestOneDimArrayData::testData()
              {
-                 QFETCH(QVector<double>, inputData);
-                 QFETCH(QVector<double>, expectedData);
+                 QFETCH(DataContainer, inputData);
+                 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<QVector<double> >("otherData");    // array data's input to merge with
+                 QTest::addColumn<DataContainer>("inputData");    // array's data input
+                 QTest::addColumn<DataContainer>("otherData");    // array data's input to merge with
-                 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.}
-                                              << QVector<double>{6., 7., 8.} << false
-                                              << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8.};
-                 QTest::newRow("prependMerge") << QVector<double>{1., 2., 3., 4., 5.}
-                                               << QVector<double>{6., 7., 8.} << true
-                                               << QVector<double>{6., 7., 8., 1., 2., 3., 4., 5.};
+                 QTest::newRow("appendMerge") << DataContainer{1., 2., 3., 4., 5.} << DataContainer{6., 7., 8.}
+                                              << false << DataContainer{1., 2., 3., 4., 5., 6., 7., 8.};
+                 QTest::newRow("prependMerge") << DataContainer{1., 2., 3., 4., 5.} << DataContainer{6., 7., 8.}
+                                               << true << DataContainer{6., 7., 8., 1., 2., 3., 4., 5.};
              }
              void TestOneDimArrayData::testAdd()
              {
-                 QFETCH(QVector<double>, inputData);
-                 QFETCH(QVector<double>, otherData);
+                 QFETCH(DataContainer, inputData);
+                 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<double>("expectedData");        // expected data at index
                  // Test cases
-                 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 0 << 1.;
-                 QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << 3 << 4.;
+                 QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.} << 0 << 1.;
+                 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
                  // 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}
-                                        << QVector<double>{1., 3., 4., 2., 5.};
-                 QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{4, 1, 2, 3, 0}
-                                        << QVector<double>{5., 2., 3., 4., 1.};
+                 QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.} << std::vector<int>{0, 2, 3, 1, 4}
+                                        << DataContainer{1., 3., 4., 2., 5.};
+                 QTest::newRow("data2") << DataContainer{1., 2., 3., 4., 5.} << std::vector<int>{4, 1, 2, 3, 0}
+                                        << 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 InputData = QPair<QVector<double>, int>;
+             using DataContainer = std::vector<double>;
+             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