##// END OF EJS Templates
Uses std::vector instead of QVector in ArrayData (2)...
Alexandre Leroux -
r645:17f44c407bff
parent child
Show More
@@ -12,8 +12,10 Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
12
12
13 namespace {
13 namespace {
14
14
15 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const QVector<double> &xData,
15 using DataContainer = std::vector<double>;
16 const QVector<double> &valuesData)
16
17 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
18 const DataContainer &valuesData)
17 {
19 {
18 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
20 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
19 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
21 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
@@ -22,8 +24,8 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const QVec
22 [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
24 [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
23 }
25 }
24
26
25 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const QVector<double> &xData,
27 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
26 const QVector<QVector<double> > &valuesData)
28 const std::vector<DataContainer> &valuesData)
27 {
29 {
28 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
30 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
29 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
31 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
@@ -102,8 +104,8 private:
102 QTest::addColumn<double>("max");
104 QTest::addColumn<double>("max");
103
105
104 // Expected values after purge
106 // Expected values after purge
105 QTest::addColumn<QVector<double> >("expectedXAxisData");
107 QTest::addColumn<DataContainer>("expectedXAxisData");
106 QTest::addColumn<QVector<QVector<double> > >("expectedValuesData");
108 QTest::addColumn<std::vector<DataContainer> >("expectedValuesData");
107 }
109 }
108
110
109 template <typename T>
111 template <typename T>
@@ -116,8 +118,8 private:
116 dataSeries->purge(min, max);
118 dataSeries->purge(min, max);
117
119
118 // Validates results
120 // Validates results
119 QFETCH(QVector<double>, expectedXAxisData);
121 QFETCH(DataContainer, expectedXAxisData);
120 QFETCH(QVector<QVector<double> >, expectedValuesData);
122 QFETCH(std::vector<DataContainer>, expectedValuesData);
121
123
122 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData,
124 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData,
123 expectedValuesData);
125 expectedValuesData);
@@ -196,67 +198,65 void TestDataSeries::testCtor_data()
196 // ////////////// //
198 // ////////////// //
197
199
198 // x-axis data
200 // x-axis data
199 QTest::addColumn<QVector<double> >("xAxisData");
201 QTest::addColumn<DataContainer>("xAxisData");
200 // values data
202 // values data
201 QTest::addColumn<QVector<double> >("valuesData");
203 QTest::addColumn<DataContainer>("valuesData");
202
204
203 // expected x-axis data
205 // expected x-axis data
204 QTest::addColumn<QVector<double> >("expectedXAxisData");
206 QTest::addColumn<DataContainer>("expectedXAxisData");
205 // expected values data
207 // expected values data
206 QTest::addColumn<QVector<double> >("expectedValuesData");
208 QTest::addColumn<DataContainer>("expectedValuesData");
207
209
208 // ////////// //
210 // ////////// //
209 // Test cases //
211 // Test cases //
210 // ////////// //
212 // ////////// //
211
213
212 QTest::newRow("invalidData (different sizes of vectors)")
214 QTest::newRow("invalidData (different sizes of vectors)")
213 << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 200., 300.}
215 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << DataContainer{}
214 << QVector<double>{} << QVector<double>{};
216 << DataContainer{};
215
217
216 QTest::newRow("sortedData") << QVector<double>{1., 2., 3., 4., 5.}
218 QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
217 << QVector<double>{100., 200., 300., 400., 500.}
219 << DataContainer{100., 200., 300., 400., 500.}
218 << QVector<double>{1., 2., 3., 4., 5.}
220 << DataContainer{1., 2., 3., 4., 5.}
219 << QVector<double>{100., 200., 300., 400., 500.};
221 << DataContainer{100., 200., 300., 400., 500.};
220
222
221 QTest::newRow("unsortedData") << QVector<double>{5., 4., 3., 2., 1.}
223 QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
222 << QVector<double>{100., 200., 300., 400., 500.}
224 << DataContainer{100., 200., 300., 400., 500.}
223 << QVector<double>{1., 2., 3., 4., 5.}
225 << DataContainer{1., 2., 3., 4., 5.}
224 << QVector<double>{500., 400., 300., 200., 100.};
226 << DataContainer{500., 400., 300., 200., 100.};
225
227
226 QTest::newRow("unsortedData2")
228 QTest::newRow("unsortedData2")
227 << QVector<double>{1., 4., 3., 5., 2.} << QVector<double>{100., 200., 300., 400., 500.}
229 << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.}
228 << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 500., 300., 200., 400.};
230 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
229 }
231 }
230
232
231 void TestDataSeries::testCtor()
233 void TestDataSeries::testCtor()
232 {
234 {
233 // Creates series
235 // Creates series
234 QFETCH(QVector<double>, xAxisData);
236 QFETCH(DataContainer, xAxisData);
235 QFETCH(QVector<double>, valuesData);
237 QFETCH(DataContainer, valuesData);
236
238
237 auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
239 auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
238 Unit{}, Unit{});
240 Unit{}, Unit{});
239
241
240 // Validates results : we check that the data series is sorted on its x-axis data
242 // Validates results : we check that the data series is sorted on its x-axis data
241 QFETCH(QVector<double>, expectedXAxisData);
243 QFETCH(DataContainer, expectedXAxisData);
242 QFETCH(QVector<double>, expectedValuesData);
244 QFETCH(DataContainer, expectedValuesData);
243
245
244 validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
246 validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
245 }
247 }
246
248
247 namespace {
249 namespace {
248
250
249 std::shared_ptr<ScalarSeries> createScalarSeries(QVector<double> xAxisData,
251 std::shared_ptr<ScalarSeries> createScalarSeries(DataContainer xAxisData, DataContainer valuesData)
250 QVector<double> valuesData)
251 {
252 {
252 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
253 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
253 Unit{});
254 Unit{});
254 }
255 }
255
256
256 std::shared_ptr<VectorSeries> createVectorSeries(QVector<double> xAxisData,
257 std::shared_ptr<VectorSeries> createVectorSeries(DataContainer xAxisData, DataContainer xValuesData,
257 QVector<double> xValuesData,
258 DataContainer yValuesData,
258 QVector<double> yValuesData,
259 DataContainer zValuesData)
259 QVector<double> zValuesData)
260 {
260 {
261 return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
261 return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
262 std::move(yValuesData), std::move(zValuesData), Unit{},
262 std::move(yValuesData), std::move(zValuesData), Unit{},
@@ -276,8 +276,8 void TestDataSeries::testMerge_data()
276 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
276 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
277
277
278 // Expected values in the first data series after merge
278 // Expected values in the first data series after merge
279 QTest::addColumn<QVector<double> >("expectedXAxisData");
279 QTest::addColumn<DataContainer>("expectedXAxisData");
280 QTest::addColumn<QVector<double> >("expectedValuesData");
280 QTest::addColumn<DataContainer>("expectedValuesData");
281
281
282 // ////////// //
282 // ////////// //
283 // Test cases //
283 // Test cases //
@@ -286,26 +286,25 void TestDataSeries::testMerge_data()
286 QTest::newRow("sortedMerge")
286 QTest::newRow("sortedMerge")
287 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
287 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
288 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
288 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
289 << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
289 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
290 << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
290 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
291
291
292 QTest::newRow("unsortedMerge")
292 QTest::newRow("unsortedMerge")
293 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
293 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
294 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
294 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
295 << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
295 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
296 << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
296 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
297
297
298 QTest::newRow("unsortedMerge2")
298 QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
299 << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 300., 400., 500.})
299 << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 800., 900., 1000.})
300 << createScalarSeries({3., 4., 5., 6., 7.}, {600., 700., 800., 900., 1000.})
300 << createScalarSeries({3., 4., 5., 6., 7.}, {300., 400., 500., 600., 700.})
301 << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
301 << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
302 << QVector<double>{100., 200., 600., 700., 800., 900., 1000., 300., 400., 500.};
303
302
304 QTest::newRow("unsortedMerge3")
303 QTest::newRow("unsortedMerge3")
305 << createScalarSeries({3., 5., 8., 7., 2}, {100., 200., 300., 400., 500.})
304 << createScalarSeries({3., 4., 5., 7., 8}, {300., 400., 500., 700., 800.})
306 << createScalarSeries({6., 4., 9., 10., 1.}, {600., 700., 800., 900., 1000.})
305 << createScalarSeries({1., 2., 3., 7., 10.}, {100., 200., 333., 777., 1000.})
307 << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
306 << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
308 << QVector<double>{1000., 500., 100., 700., 200., 600., 400., 300., 800., 900.};
307 << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
309 }
308 }
310
309
311 void TestDataSeries::testMerge()
310 void TestDataSeries::testMerge()
@@ -318,8 +317,8 void TestDataSeries::testMerge()
318
317
319 // Validates results : we check that the merge is valid and the data series is sorted on its
318 // Validates results : we check that the merge is valid and the data series is sorted on its
320 // x-axis data
319 // x-axis data
321 QFETCH(QVector<double>, expectedXAxisData);
320 QFETCH(DataContainer, expectedXAxisData);
322 QFETCH(QVector<double>, expectedValuesData);
321 QFETCH(DataContainer, expectedValuesData);
323
322
324 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
323 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
325 }
324 }
@@ -334,24 +333,23 void TestDataSeries::testPurgeScalar_data()
334
333
335 QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.},
334 QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.},
336 {100., 200., 300., 400., 500.})
335 {100., 200., 300., 400., 500.})
337 << 2. << 4. << QVector<double>{2., 3., 4.}
336 << 2. << 4. << DataContainer{2., 3., 4.}
338 << QVector<QVector<double> >{{200., 300., 400.}};
337 << std::vector<DataContainer>{{200., 300., 400.}};
339 QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.},
338 QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.},
340 {100., 200., 300., 400., 500.})
339 {100., 200., 300., 400., 500.})
341 << 0. << 2.5 << QVector<double>{1., 2.}
340 << 0. << 2.5 << DataContainer{1., 2.}
342 << QVector<QVector<double> >{{100., 200.}};
341 << std::vector<DataContainer>{{100., 200.}};
343 QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.},
342 QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.},
344 {100., 200., 300., 400., 500.})
343 {100., 200., 300., 400., 500.})
345 << 3.5 << 7. << QVector<double>{4., 5.}
344 << 3.5 << 7. << DataContainer{4., 5.}
346 << QVector<QVector<double> >{{400., 500.}};
345 << std::vector<DataContainer>{{400., 500.}};
347 QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.},
346 QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.},
348 {100., 200., 300., 400., 500.})
347 {100., 200., 300., 400., 500.})
349 << 0. << 7. << QVector<double>{1., 2., 3., 4., 5.}
348 << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
350 << QVector<QVector<double> >{{100., 200., 300., 400., 500.}};
349 << std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
351 QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.},
350 QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.},
352 {100., 200., 300., 400., 500.})
351 {100., 200., 300., 400., 500.})
353 << 5.5 << 7. << QVector<double>{}
352 << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
354 << QVector<QVector<double> >{{}};
355 }
353 }
356
354
357 void TestDataSeries::testPurgeScalar()
355 void TestDataSeries::testPurgeScalar()
@@ -370,8 +368,8 void TestDataSeries::testPurgeVector_data()
370 QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.},
368 QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.},
371 {11., 12., 13., 14., 15.},
369 {11., 12., 13., 14., 15.},
372 {16., 17., 18., 19., 20.})
370 {16., 17., 18., 19., 20.})
373 << 2. << 4. << QVector<double>{2., 3., 4.}
371 << 2. << 4. << DataContainer{2., 3., 4.}
374 << QVector<QVector<double> >{
372 << std::vector<DataContainer>{
375 {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}};
373 {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}};
376 }
374 }
377
375
@@ -512,8 +510,8 void TestDataSeries::testXAxisRange_data()
512 QTest::addColumn<double>("max");
510 QTest::addColumn<double>("max");
513
511
514 // Expected values
512 // Expected values
515 QTest::addColumn<QVector<double> >("expectedXAxisData");
513 QTest::addColumn<DataContainer>("expectedXAxisData");
516 QTest::addColumn<QVector<double> >("expectedValuesData");
514 QTest::addColumn<DataContainer>("expectedValuesData");
517
515
518 // ////////// //
516 // ////////// //
519 // Test cases //
517 // Test cases //
@@ -521,32 +519,32 void TestDataSeries::testXAxisRange_data()
521
519
522 QTest::newRow("xAxisRange1") << createScalarSeries({1., 2., 3., 4., 5.},
520 QTest::newRow("xAxisRange1") << createScalarSeries({1., 2., 3., 4., 5.},
523 {100., 200., 300., 400., 500.})
521 {100., 200., 300., 400., 500.})
524 << -1. << 3.2 << QVector<double>{1., 2., 3.}
522 << -1. << 3.2 << DataContainer{1., 2., 3.}
525 << QVector<double>{100., 200., 300.};
523 << DataContainer{100., 200., 300.};
526 QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
524 QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
527 {100., 200., 300., 400., 500.})
525 {100., 200., 300., 400., 500.})
528 << 1. << 4. << QVector<double>{1., 2., 3., 4.}
526 << 1. << 4. << DataContainer{1., 2., 3., 4.}
529 << QVector<double>{100., 200., 300., 400.};
527 << DataContainer{100., 200., 300., 400.};
530 QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
528 QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
531 {100., 200., 300., 400., 500.})
529 {100., 200., 300., 400., 500.})
532 << 1. << 3.9 << QVector<double>{1., 2., 3.}
530 << 1. << 3.9 << DataContainer{1., 2., 3.}
533 << QVector<double>{100., 200., 300.};
531 << DataContainer{100., 200., 300.};
534 QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
532 QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
535 {100., 200., 300., 400., 500.})
533 {100., 200., 300., 400., 500.})
536 << 0. << 0.9 << QVector<double>{} << QVector<double>{};
534 << 0. << 0.9 << DataContainer{} << DataContainer{};
537 QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
535 QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
538 {100., 200., 300., 400., 500.})
536 {100., 200., 300., 400., 500.})
539 << 0. << 1. << QVector<double>{1.} << QVector<double>{100.};
537 << 0. << 1. << DataContainer{1.} << DataContainer{100.};
540 QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
538 QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
541 {100., 200., 300., 400., 500.})
539 {100., 200., 300., 400., 500.})
542 << 2.1 << 6. << QVector<double>{3., 4., 5.}
540 << 2.1 << 6. << DataContainer{3., 4., 5.}
543 << QVector<double>{300., 400., 500.};
541 << DataContainer{300., 400., 500.};
544 QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
542 QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
545 {100., 200., 300., 400., 500.})
543 {100., 200., 300., 400., 500.})
546 << 6. << 9. << QVector<double>{} << QVector<double>{};
544 << 6. << 9. << DataContainer{} << DataContainer{};
547 QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
545 QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
548 {100., 200., 300., 400., 500.})
546 {100., 200., 300., 400., 500.})
549 << 5. << 9. << QVector<double>{5.} << QVector<double>{500.};
547 << 5. << 9. << DataContainer{5.} << DataContainer{500.};
550 }
548 }
551
549
552 void TestDataSeries::testXAxisRange()
550 void TestDataSeries::testXAxisRange()
@@ -555,8 +553,8 void TestDataSeries::testXAxisRange()
555 QFETCH(double, min);
553 QFETCH(double, min);
556 QFETCH(double, max);
554 QFETCH(double, max);
557
555
558 QFETCH(QVector<double>, expectedXAxisData);
556 QFETCH(DataContainer, expectedXAxisData);
559 QFETCH(QVector<double>, expectedValuesData);
557 QFETCH(DataContainer, expectedValuesData);
560
558
561 auto bounds = dataSeries->xAxisRange(min, max);
559 auto bounds = dataSeries->xAxisRange(min, max);
562 validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
560 validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
@@ -4,7 +4,9
4
4
5 namespace {
5 namespace {
6
6
7 void verifyArrayData(const ArrayData<1> &arrayData, const QVector<double> &expectedData)
7 using DataContainer = std::vector<double>;
8
9 void verifyArrayData(const ArrayData<1> &arrayData, const DataContainer &expectedData)
8 {
10 {
9 QVERIFY(std::equal(
11 QVERIFY(std::equal(
10 arrayData.cbegin(), arrayData.cend(), expectedData.cbegin(), expectedData.cend(),
12 arrayData.cbegin(), arrayData.cend(), expectedData.cbegin(), expectedData.cend(),
@@ -44,18 +46,18 private slots:
44 void TestOneDimArrayData::testData_data()
46 void TestOneDimArrayData::testData_data()
45 {
47 {
46 // Test structure
48 // Test structure
47 QTest::addColumn<QVector<double> >("inputData"); // array's data input
49 QTest::addColumn<DataContainer>("inputData"); // array's data input
48 QTest::addColumn<QVector<double> >("expectedData"); // expected data
50 QTest::addColumn<DataContainer>("expectedData"); // expected data
49
51
50 // Test cases
52 // Test cases
51 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.}
53 QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.}
52 << QVector<double>{1., 2., 3., 4., 5.};
54 << DataContainer{1., 2., 3., 4., 5.};
53 }
55 }
54
56
55 void TestOneDimArrayData::testData()
57 void TestOneDimArrayData::testData()
56 {
58 {
57 QFETCH(QVector<double>, inputData);
59 QFETCH(DataContainer, inputData);
58 QFETCH(QVector<double>, expectedData);
60 QFETCH(DataContainer, expectedData);
59
61
60 ArrayData<1> arrayData{inputData};
62 ArrayData<1> arrayData{inputData};
61 verifyArrayData(arrayData, expectedData);
63 verifyArrayData(arrayData, expectedData);
@@ -64,26 +66,24 void TestOneDimArrayData::testData()
64 void TestOneDimArrayData::testAdd_data()
66 void TestOneDimArrayData::testAdd_data()
65 {
67 {
66 // Test structure
68 // Test structure
67 QTest::addColumn<QVector<double> >("inputData"); // array's data input
69 QTest::addColumn<DataContainer>("inputData"); // array's data input
68 QTest::addColumn<QVector<double> >("otherData"); // array data's input to merge with
70 QTest::addColumn<DataContainer>("otherData"); // array data's input to merge with
69 QTest::addColumn<bool>("prepend"); // prepend or append merge
71 QTest::addColumn<bool>("prepend"); // prepend or append merge
70 QTest::addColumn<QVector<double> >("expectedData"); // expected data after merge
72 QTest::addColumn<DataContainer>("expectedData"); // expected data after merge
71
73
72 // Test cases
74 // Test cases
73 QTest::newRow("appendMerge") << QVector<double>{1., 2., 3., 4., 5.}
75 QTest::newRow("appendMerge") << DataContainer{1., 2., 3., 4., 5.} << DataContainer{6., 7., 8.}
74 << QVector<double>{6., 7., 8.} << false
76 << false << DataContainer{1., 2., 3., 4., 5., 6., 7., 8.};
75 << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8.};
77 QTest::newRow("prependMerge") << DataContainer{1., 2., 3., 4., 5.} << DataContainer{6., 7., 8.}
76 QTest::newRow("prependMerge") << QVector<double>{1., 2., 3., 4., 5.}
78 << true << DataContainer{6., 7., 8., 1., 2., 3., 4., 5.};
77 << QVector<double>{6., 7., 8.} << true
78 << QVector<double>{6., 7., 8., 1., 2., 3., 4., 5.};
79 }
79 }
80
80
81 void TestOneDimArrayData::testAdd()
81 void TestOneDimArrayData::testAdd()
82 {
82 {
83 QFETCH(QVector<double>, inputData);
83 QFETCH(DataContainer, inputData);
84 QFETCH(QVector<double>, otherData);
84 QFETCH(DataContainer, otherData);
85 QFETCH(bool, prepend);
85 QFETCH(bool, prepend);
86 QFETCH(QVector<double>, expectedData);
86 QFETCH(DataContainer, expectedData);
87
87
88 ArrayData<1> arrayData{inputData};
88 ArrayData<1> arrayData{inputData};
89 ArrayData<1> other{otherData};
89 ArrayData<1> other{otherData};
@@ -95,18 +95,18 void TestOneDimArrayData::testAdd()
95 void TestOneDimArrayData::testAt_data()
95 void TestOneDimArrayData::testAt_data()
96 {
96 {
97 // Test structure
97 // Test structure
98 QTest::addColumn<QVector<double> >("inputData"); // array data's input
98 QTest::addColumn<DataContainer>("inputData"); // array data's input
99 QTest::addColumn<int>("index"); // index to retrieve data
99 QTest::addColumn<int>("index"); // index to retrieve data
100 QTest::addColumn<double>("expectedData"); // expected data at index
100 QTest::addColumn<double>("expectedData"); // expected data at index
101
101
102 // Test cases
102 // Test cases
103 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 0 << 1.;
103 QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.} << 0 << 1.;
104 QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << 3 << 4.;
104 QTest::newRow("data2") << DataContainer{1., 2., 3., 4., 5.} << 3 << 4.;
105 }
105 }
106
106
107 void TestOneDimArrayData::testAt()
107 void TestOneDimArrayData::testAt()
108 {
108 {
109 QFETCH(QVector<double>, inputData);
109 QFETCH(DataContainer, inputData);
110 QFETCH(int, index);
110 QFETCH(int, index);
111 QFETCH(double, expectedData);
111 QFETCH(double, expectedData);
112
112
@@ -117,34 +117,34 void TestOneDimArrayData::testAt()
117 void TestOneDimArrayData::testClear_data()
117 void TestOneDimArrayData::testClear_data()
118 {
118 {
119 // Test structure
119 // Test structure
120 QTest::addColumn<QVector<double> >("inputData"); // array data's input
120 QTest::addColumn<DataContainer>("inputData"); // array data's input
121
121
122 // Test cases
122 // Test cases
123 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.};
123 QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.};
124 }
124 }
125
125
126 void TestOneDimArrayData::testClear()
126 void TestOneDimArrayData::testClear()
127 {
127 {
128 QFETCH(QVector<double>, inputData);
128 QFETCH(DataContainer, inputData);
129
129
130 ArrayData<1> arrayData{inputData};
130 ArrayData<1> arrayData{inputData};
131 arrayData.clear();
131 arrayData.clear();
132 verifyArrayData(arrayData, QVector<double>{});
132 verifyArrayData(arrayData, DataContainer{});
133 }
133 }
134
134
135 void TestOneDimArrayData::testSize_data()
135 void TestOneDimArrayData::testSize_data()
136 {
136 {
137 // Test structure
137 // Test structure
138 QTest::addColumn<QVector<double> >("inputData"); // array data's input
138 QTest::addColumn<DataContainer>("inputData"); // array data's input
139 QTest::addColumn<int>("expectedSize"); // expected array data size
139 QTest::addColumn<int>("expectedSize"); // expected array data size
140
140
141 // Test cases
141 // Test cases
142 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << 5;
142 QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.} << 5;
143 }
143 }
144
144
145 void TestOneDimArrayData::testSize()
145 void TestOneDimArrayData::testSize()
146 {
146 {
147 QFETCH(QVector<double>, inputData);
147 QFETCH(DataContainer, inputData);
148 QFETCH(int, expectedSize);
148 QFETCH(int, expectedSize);
149
149
150 ArrayData<1> arrayData{inputData};
150 ArrayData<1> arrayData{inputData};
@@ -154,22 +154,22 void TestOneDimArrayData::testSize()
154 void TestOneDimArrayData::testSort_data()
154 void TestOneDimArrayData::testSort_data()
155 {
155 {
156 // Test structure
156 // Test structure
157 QTest::addColumn<QVector<double> >("inputData"); // array data's input
157 QTest::addColumn<DataContainer>("inputData"); // array data's input
158 QTest::addColumn<std::vector<int> >("sortPermutation"); // permutation used to sort data
158 QTest::addColumn<std::vector<int> >("sortPermutation"); // permutation used to sort data
159 QTest::addColumn<QVector<double> >("expectedData"); // expected data after sorting
159 QTest::addColumn<DataContainer>("expectedData"); // expected data after sorting
160
160
161 // Test cases
161 // Test cases
162 QTest::newRow("data1") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{0, 2, 3, 1, 4}
162 QTest::newRow("data1") << DataContainer{1., 2., 3., 4., 5.} << std::vector<int>{0, 2, 3, 1, 4}
163 << QVector<double>{1., 3., 4., 2., 5.};
163 << DataContainer{1., 3., 4., 2., 5.};
164 QTest::newRow("data2") << QVector<double>{1., 2., 3., 4., 5.} << std::vector<int>{4, 1, 2, 3, 0}
164 QTest::newRow("data2") << DataContainer{1., 2., 3., 4., 5.} << std::vector<int>{4, 1, 2, 3, 0}
165 << QVector<double>{5., 2., 3., 4., 1.};
165 << DataContainer{5., 2., 3., 4., 1.};
166 }
166 }
167
167
168 void TestOneDimArrayData::testSort()
168 void TestOneDimArrayData::testSort()
169 {
169 {
170 QFETCH(QVector<double>, inputData);
170 QFETCH(DataContainer, inputData);
171 QFETCH(std::vector<int>, sortPermutation);
171 QFETCH(std::vector<int>, sortPermutation);
172 QFETCH(QVector<double>, expectedData);
172 QFETCH(DataContainer, expectedData);
173
173
174 ArrayData<1> arrayData{inputData};
174 ArrayData<1> arrayData{inputData};
175 auto sortedArrayData = arrayData.sort(sortPermutation);
175 auto sortedArrayData = arrayData.sort(sortPermutation);
@@ -2,31 +2,32
2 #include <QObject>
2 #include <QObject>
3 #include <QtTest>
3 #include <QtTest>
4
4
5 using Container = QVector<QVector<double> >;
5 using DataContainer = std::vector<double>;
6 using InputData = QPair<QVector<double>, int>;
6 using Container = std::vector<DataContainer>;
7 using InputData = QPair<DataContainer, int>;
7
8
8 namespace {
9 namespace {
9
10
10 InputData flatten(const Container &container)
11 InputData flatten(const Container &container)
11 {
12 {
12 if (container.isEmpty()) {
13 if (container.empty()) {
13 return {};
14 return {};
14 }
15 }
15
16
16 // We assume here that each component of the container have the same size
17 // We assume here that each component of the container have the same size
17 auto containerSize = container.size();
18 auto containerSize = container.size();
18 auto componentSize = container.first().size();
19 auto componentSize = container.front().size();
19
20
20 auto result = QVector<double>{};
21 auto result = DataContainer{};
21 result.reserve(componentSize * containerSize);
22 result.reserve(componentSize * containerSize);
22
23
23 for (auto i = 0; i < componentSize; ++i) {
24 for (auto i = 0; i < componentSize; ++i) {
24 for (auto j = 0; j < containerSize; ++j) {
25 for (auto j = 0; j < containerSize; ++j) {
25 result.append(container.at(j).at(i));
26 result.push_back(container.at(j).at(i));
26 }
27 }
27 }
28 }
28
29
29 return {result, containerSize};
30 return {result, static_cast<int>(containerSize)};
30 }
31 }
31
32
32 void verifyArrayData(const ArrayData<2> &arrayData, const Container &expectedData)
33 void verifyArrayData(const ArrayData<2> &arrayData, const Container &expectedData)
@@ -175,7 +176,7 void TestTwoDimArrayData::testClear()
175 ArrayData<2> arrayData{inputData.first, inputData.second};
176 ArrayData<2> arrayData{inputData.first, inputData.second};
176 arrayData.clear();
177 arrayData.clear();
177
178
178 auto emptyData = Container(inputData.second, QVector<double>{});
179 auto emptyData = Container(inputData.second, DataContainer{});
179 verifyArrayData(arrayData, emptyData);
180 verifyArrayData(arrayData, emptyData);
180 }
181 }
181
182
General Comments 0
You need to be logged in to leave comments. Login now