##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Completes DataSeries::merge() test
Alexandre Leroux -
r800:7c2c4ced55cd
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,702 +1,707
1 #include "Data/DataSeries.h"
1 #include "Data/DataSeries.h"
2 #include "Data/ScalarSeries.h"
2 #include "Data/ScalarSeries.h"
3 #include "Data/VectorSeries.h"
3 #include "Data/VectorSeries.h"
4
4
5 #include <cmath>
5 #include <cmath>
6
6
7 #include <QObject>
7 #include <QObject>
8 #include <QtTest>
8 #include <QtTest>
9
9
10 Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
10 Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
11 Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
11 Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
12
12
13 namespace {
13 namespace {
14
14
15 using DataContainer = std::vector<double>;
15 using DataContainer = std::vector<double>;
16
16
17 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
17 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
18 const DataContainer &valuesData)
18 const DataContainer &valuesData)
19 {
19 {
20 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
20 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
21 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
21 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
22 QVERIFY(std::equal(
22 QVERIFY(std::equal(
23 first, last, valuesData.cbegin(), valuesData.cend(),
23 first, last, valuesData.cbegin(), valuesData.cend(),
24 [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
24 [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
25 }
25 }
26
26
27 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
27 void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
28 const std::vector<DataContainer> &valuesData)
28 const std::vector<DataContainer> &valuesData)
29 {
29 {
30 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
30 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
31 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
31 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
32 for (auto i = 0; i < valuesData.size(); ++i) {
32 for (auto i = 0; i < valuesData.size(); ++i) {
33 auto componentData = valuesData.at(i);
33 auto componentData = valuesData.at(i);
34
34
35 QVERIFY(std::equal(
35 QVERIFY(std::equal(
36 first, last, componentData.cbegin(), componentData.cend(),
36 first, last, componentData.cbegin(), componentData.cend(),
37 [i](const auto &it, const auto &expectedVal) { return it.value(i) == expectedVal; }));
37 [i](const auto &it, const auto &expectedVal) { return it.value(i) == expectedVal; }));
38 }
38 }
39 }
39 }
40
40
41 } // namespace
41 } // namespace
42
42
43 class TestDataSeries : public QObject {
43 class TestDataSeries : public QObject {
44 Q_OBJECT
44 Q_OBJECT
45 private:
45 private:
46 template <typename T>
46 template <typename T>
47 void testValuesBoundsStructure()
47 void testValuesBoundsStructure()
48 {
48 {
49 // ////////////// //
49 // ////////////// //
50 // Test structure //
50 // Test structure //
51 // ////////////// //
51 // ////////////// //
52
52
53 // Data series to get values bounds
53 // Data series to get values bounds
54 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
54 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
55
55
56 // x-axis range
56 // x-axis range
57 QTest::addColumn<double>("minXAxis");
57 QTest::addColumn<double>("minXAxis");
58 QTest::addColumn<double>("maxXAxis");
58 QTest::addColumn<double>("maxXAxis");
59
59
60 // Expected results
60 // Expected results
61 QTest::addColumn<bool>(
61 QTest::addColumn<bool>(
62 "expectedOK"); // Test is expected to be ok (i.e. method doesn't return end iterators)
62 "expectedOK"); // Test is expected to be ok (i.e. method doesn't return end iterators)
63 QTest::addColumn<double>("expectedMinValue");
63 QTest::addColumn<double>("expectedMinValue");
64 QTest::addColumn<double>("expectedMaxValue");
64 QTest::addColumn<double>("expectedMaxValue");
65 }
65 }
66
66
67 template <typename T>
67 template <typename T>
68 void testValuesBounds()
68 void testValuesBounds()
69 {
69 {
70 QFETCH(std::shared_ptr<T>, dataSeries);
70 QFETCH(std::shared_ptr<T>, dataSeries);
71 QFETCH(double, minXAxis);
71 QFETCH(double, minXAxis);
72 QFETCH(double, maxXAxis);
72 QFETCH(double, maxXAxis);
73
73
74 QFETCH(bool, expectedOK);
74 QFETCH(bool, expectedOK);
75 QFETCH(double, expectedMinValue);
75 QFETCH(double, expectedMinValue);
76 QFETCH(double, expectedMaxValue);
76 QFETCH(double, expectedMaxValue);
77
77
78 auto minMaxIts = dataSeries->valuesBounds(minXAxis, maxXAxis);
78 auto minMaxIts = dataSeries->valuesBounds(minXAxis, maxXAxis);
79 auto end = dataSeries->cend();
79 auto end = dataSeries->cend();
80
80
81 // Checks iterators with expected result
81 // Checks iterators with expected result
82 QCOMPARE(expectedOK, minMaxIts.first != end && minMaxIts.second != end);
82 QCOMPARE(expectedOK, minMaxIts.first != end && minMaxIts.second != end);
83
83
84 if (expectedOK) {
84 if (expectedOK) {
85 auto compare = [](const auto &v1, const auto &v2) {
85 auto compare = [](const auto &v1, const auto &v2) {
86 return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
86 return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
87 };
87 };
88
88
89 QVERIFY(compare(expectedMinValue, minMaxIts.first->minValue()));
89 QVERIFY(compare(expectedMinValue, minMaxIts.first->minValue()));
90 QVERIFY(compare(expectedMaxValue, minMaxIts.second->maxValue()));
90 QVERIFY(compare(expectedMaxValue, minMaxIts.second->maxValue()));
91 }
91 }
92 }
92 }
93
93
94 template <typename T>
94 template <typename T>
95 void testPurgeStructure()
95 void testPurgeStructure()
96 {
96 {
97 // ////////////// //
97 // ////////////// //
98 // Test structure //
98 // Test structure //
99 // ////////////// //
99 // ////////////// //
100
100
101 // Data series to purge
101 // Data series to purge
102 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
102 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
103 QTest::addColumn<double>("min");
103 QTest::addColumn<double>("min");
104 QTest::addColumn<double>("max");
104 QTest::addColumn<double>("max");
105
105
106 // Expected values after purge
106 // Expected values after purge
107 QTest::addColumn<DataContainer>("expectedXAxisData");
107 QTest::addColumn<DataContainer>("expectedXAxisData");
108 QTest::addColumn<std::vector<DataContainer> >("expectedValuesData");
108 QTest::addColumn<std::vector<DataContainer> >("expectedValuesData");
109 }
109 }
110
110
111 template <typename T>
111 template <typename T>
112 void testPurge()
112 void testPurge()
113 {
113 {
114 QFETCH(std::shared_ptr<T>, dataSeries);
114 QFETCH(std::shared_ptr<T>, dataSeries);
115 QFETCH(double, min);
115 QFETCH(double, min);
116 QFETCH(double, max);
116 QFETCH(double, max);
117
117
118 dataSeries->purge(min, max);
118 dataSeries->purge(min, max);
119
119
120 // Validates results
120 // Validates results
121 QFETCH(DataContainer, expectedXAxisData);
121 QFETCH(DataContainer, expectedXAxisData);
122 QFETCH(std::vector<DataContainer>, expectedValuesData);
122 QFETCH(std::vector<DataContainer>, expectedValuesData);
123
123
124 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData,
124 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData,
125 expectedValuesData);
125 expectedValuesData);
126 }
126 }
127
127
128 template <typename SourceType, typename DestType>
128 template <typename SourceType, typename DestType>
129 void testMergeDifferentTypesStructure()
129 void testMergeDifferentTypesStructure()
130 {
130 {
131 // ////////////// //
131 // ////////////// //
132 // Test structure //
132 // Test structure //
133 // ////////////// //
133 // ////////////// //
134
134
135 // Data series to merge
135 // Data series to merge
136 QTest::addColumn<std::shared_ptr<DestType> >("dest");
136 QTest::addColumn<std::shared_ptr<DestType> >("dest");
137 QTest::addColumn<std::shared_ptr<SourceType> >("source");
137 QTest::addColumn<std::shared_ptr<SourceType> >("source");
138
138
139 // Expected values in the dest data series after merge
139 // Expected values in the dest data series after merge
140 QTest::addColumn<DataContainer>("expectedXAxisData");
140 QTest::addColumn<DataContainer>("expectedXAxisData");
141 QTest::addColumn<DataContainer>("expectedValuesData");
141 QTest::addColumn<DataContainer>("expectedValuesData");
142 }
142 }
143
143
144 template <typename SourceType, typename DestType>
144 template <typename SourceType, typename DestType>
145 void testMergeDifferentTypes()
145 void testMergeDifferentTypes()
146 {
146 {
147 // Merges series
147 // Merges series
148 QFETCH(std::shared_ptr<SourceType>, source);
148 QFETCH(std::shared_ptr<SourceType>, source);
149 QFETCH(std::shared_ptr<DestType>, dest);
149 QFETCH(std::shared_ptr<DestType>, dest);
150
150
151 dest->merge(source.get());
151 dest->merge(source.get());
152
152
153 // Validates results : we check that the merge is valid and the data series is sorted on its
153 // Validates results : we check that the merge is valid and the data series is sorted on its
154 // x-axis data
154 // x-axis data
155 QFETCH(DataContainer, expectedXAxisData);
155 QFETCH(DataContainer, expectedXAxisData);
156 QFETCH(DataContainer, expectedValuesData);
156 QFETCH(DataContainer, expectedValuesData);
157
157
158 validateRange(dest->cbegin(), dest->cend(), expectedXAxisData, expectedValuesData);
158 validateRange(dest->cbegin(), dest->cend(), expectedXAxisData, expectedValuesData);
159 }
159 }
160
160
161 private slots:
161 private slots:
162
162
163 /// Input test data
163 /// Input test data
164 /// @sa testCtor()
164 /// @sa testCtor()
165 void testCtor_data();
165 void testCtor_data();
166
166
167 /// Tests construction of a data series
167 /// Tests construction of a data series
168 void testCtor();
168 void testCtor();
169
169
170 /// Input test data
170 /// Input test data
171 /// @sa testMerge()
171 /// @sa testMerge()
172 void testMerge_data();
172 void testMerge_data();
173
173
174 /// Tests merge of two data series
174 /// Tests merge of two data series
175 void testMerge();
175 void testMerge();
176
176
177 /// Input test data
177 /// Input test data
178 /// @sa testMergeVectorInScalar()
178 /// @sa testMergeVectorInScalar()
179 void testMergeVectorInScalar_data();
179 void testMergeVectorInScalar_data();
180
180
181 /// Tests merge of vector series in scalar series
181 /// Tests merge of vector series in scalar series
182 void testMergeVectorInScalar();
182 void testMergeVectorInScalar();
183
183
184 /// Input test data
184 /// Input test data
185 /// @sa testPurgeScalar()
185 /// @sa testPurgeScalar()
186 void testPurgeScalar_data();
186 void testPurgeScalar_data();
187
187
188 /// Tests purge of a scalar series
188 /// Tests purge of a scalar series
189 void testPurgeScalar();
189 void testPurgeScalar();
190
190
191 /// Input test data
191 /// Input test data
192 /// @sa testPurgeVector()
192 /// @sa testPurgeVector()
193 void testPurgeVector_data();
193 void testPurgeVector_data();
194
194
195 /// Tests purge of a vector series
195 /// Tests purge of a vector series
196 void testPurgeVector();
196 void testPurgeVector();
197
197
198 /// Input test data
198 /// Input test data
199 /// @sa testMinXAxisData()
199 /// @sa testMinXAxisData()
200 void testMinXAxisData_data();
200 void testMinXAxisData_data();
201
201
202 /// Tests get min x-axis data of a data series
202 /// Tests get min x-axis data of a data series
203 void testMinXAxisData();
203 void testMinXAxisData();
204
204
205 /// Input test data
205 /// Input test data
206 /// @sa testMaxXAxisData()
206 /// @sa testMaxXAxisData()
207 void testMaxXAxisData_data();
207 void testMaxXAxisData_data();
208
208
209 /// Tests get max x-axis data of a data series
209 /// Tests get max x-axis data of a data series
210 void testMaxXAxisData();
210 void testMaxXAxisData();
211
211
212 /// Input test data
212 /// Input test data
213 /// @sa testXAxisRange()
213 /// @sa testXAxisRange()
214 void testXAxisRange_data();
214 void testXAxisRange_data();
215
215
216 /// Tests get x-axis range of a data series
216 /// Tests get x-axis range of a data series
217 void testXAxisRange();
217 void testXAxisRange();
218
218
219 /// Input test data
219 /// Input test data
220 /// @sa testValuesBoundsScalar()
220 /// @sa testValuesBoundsScalar()
221 void testValuesBoundsScalar_data();
221 void testValuesBoundsScalar_data();
222
222
223 /// Tests get values bounds of a scalar series
223 /// Tests get values bounds of a scalar series
224 void testValuesBoundsScalar();
224 void testValuesBoundsScalar();
225
225
226 /// Input test data
226 /// Input test data
227 /// @sa testValuesBoundsVector()
227 /// @sa testValuesBoundsVector()
228 void testValuesBoundsVector_data();
228 void testValuesBoundsVector_data();
229
229
230 /// Tests get values bounds of a vector series
230 /// Tests get values bounds of a vector series
231 void testValuesBoundsVector();
231 void testValuesBoundsVector();
232 };
232 };
233
233
234 void TestDataSeries::testCtor_data()
234 void TestDataSeries::testCtor_data()
235 {
235 {
236 // ////////////// //
236 // ////////////// //
237 // Test structure //
237 // Test structure //
238 // ////////////// //
238 // ////////////// //
239
239
240 // x-axis data
240 // x-axis data
241 QTest::addColumn<DataContainer>("xAxisData");
241 QTest::addColumn<DataContainer>("xAxisData");
242 // values data
242 // values data
243 QTest::addColumn<DataContainer>("valuesData");
243 QTest::addColumn<DataContainer>("valuesData");
244
244
245 // expected x-axis data
245 // expected x-axis data
246 QTest::addColumn<DataContainer>("expectedXAxisData");
246 QTest::addColumn<DataContainer>("expectedXAxisData");
247 // expected values data
247 // expected values data
248 QTest::addColumn<DataContainer>("expectedValuesData");
248 QTest::addColumn<DataContainer>("expectedValuesData");
249
249
250 // ////////// //
250 // ////////// //
251 // Test cases //
251 // Test cases //
252 // ////////// //
252 // ////////// //
253
253
254 QTest::newRow("invalidData (different sizes of vectors)")
254 QTest::newRow("invalidData (different sizes of vectors)")
255 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << DataContainer{}
255 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << DataContainer{}
256 << DataContainer{};
256 << DataContainer{};
257
257
258 QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
258 QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
259 << DataContainer{100., 200., 300., 400., 500.}
259 << DataContainer{100., 200., 300., 400., 500.}
260 << DataContainer{1., 2., 3., 4., 5.}
260 << DataContainer{1., 2., 3., 4., 5.}
261 << DataContainer{100., 200., 300., 400., 500.};
261 << DataContainer{100., 200., 300., 400., 500.};
262
262
263 QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
263 QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
264 << DataContainer{100., 200., 300., 400., 500.}
264 << DataContainer{100., 200., 300., 400., 500.}
265 << DataContainer{1., 2., 3., 4., 5.}
265 << DataContainer{1., 2., 3., 4., 5.}
266 << DataContainer{500., 400., 300., 200., 100.};
266 << DataContainer{500., 400., 300., 200., 100.};
267
267
268 QTest::newRow("unsortedData2")
268 QTest::newRow("unsortedData2")
269 << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.}
269 << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.}
270 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
270 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
271 }
271 }
272
272
273 void TestDataSeries::testCtor()
273 void TestDataSeries::testCtor()
274 {
274 {
275 // Creates series
275 // Creates series
276 QFETCH(DataContainer, xAxisData);
276 QFETCH(DataContainer, xAxisData);
277 QFETCH(DataContainer, valuesData);
277 QFETCH(DataContainer, valuesData);
278
278
279 auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
279 auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
280 Unit{}, Unit{});
280 Unit{}, Unit{});
281
281
282 // Validates results : we check that the data series is sorted on its x-axis data
282 // Validates results : we check that the data series is sorted on its x-axis data
283 QFETCH(DataContainer, expectedXAxisData);
283 QFETCH(DataContainer, expectedXAxisData);
284 QFETCH(DataContainer, expectedValuesData);
284 QFETCH(DataContainer, expectedValuesData);
285
285
286 validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
286 validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
287 }
287 }
288
288
289 namespace {
289 namespace {
290
290
291 std::shared_ptr<ScalarSeries> createScalarSeries(DataContainer xAxisData, DataContainer valuesData)
291 std::shared_ptr<ScalarSeries> createScalarSeries(DataContainer xAxisData, DataContainer valuesData)
292 {
292 {
293 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
293 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
294 Unit{});
294 Unit{});
295 }
295 }
296
296
297 std::shared_ptr<VectorSeries> createVectorSeries(DataContainer xAxisData, DataContainer xValuesData,
297 std::shared_ptr<VectorSeries> createVectorSeries(DataContainer xAxisData, DataContainer xValuesData,
298 DataContainer yValuesData,
298 DataContainer yValuesData,
299 DataContainer zValuesData)
299 DataContainer zValuesData)
300 {
300 {
301 return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
301 return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
302 std::move(yValuesData), std::move(zValuesData), Unit{},
302 std::move(yValuesData), std::move(zValuesData), Unit{},
303 Unit{});
303 Unit{});
304 }
304 }
305
305
306 } // namespace
306 } // namespace
307
307
308 void TestDataSeries::testMerge_data()
308 void TestDataSeries::testMerge_data()
309 {
309 {
310 // ////////////// //
310 // ////////////// //
311 // Test structure //
311 // Test structure //
312 // ////////////// //
312 // ////////////// //
313
313
314 // Data series to merge
314 // Data series to merge
315 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
315 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
316 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
316 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
317
317
318 // Expected values in the first data series after merge
318 // Expected values in the first data series after merge
319 QTest::addColumn<DataContainer>("expectedXAxisData");
319 QTest::addColumn<DataContainer>("expectedXAxisData");
320 QTest::addColumn<DataContainer>("expectedValuesData");
320 QTest::addColumn<DataContainer>("expectedValuesData");
321
321
322 // ////////// //
322 // ////////// //
323 // Test cases //
323 // Test cases //
324 // ////////// //
324 // ////////// //
325
325
326 QTest::newRow("sortedMerge")
326 QTest::newRow("sortedMerge")
327 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
327 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
328 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
328 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
329 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
329 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
330 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
330 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
331
331
332 QTest::newRow("unsortedMerge")
332 QTest::newRow("unsortedMerge")
333 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
333 << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
334 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
334 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
335 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
335 << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
336 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
336 << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
337
337
338 QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
338 QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
339 << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 800., 900., 1000.})
339 << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 800., 900., 1000.})
340 << createScalarSeries({3., 4., 5., 6., 7.}, {300., 400., 500., 600., 700.})
340 << createScalarSeries({3., 4., 5., 6., 7.}, {300., 400., 500., 600., 700.})
341 << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
341 << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
342
342
343 QTest::newRow("unsortedMerge3")
343 QTest::newRow("unsortedMerge3")
344 << createScalarSeries({3., 4., 5., 7., 8}, {300., 400., 500., 700., 800.})
344 << createScalarSeries({3., 4., 5., 7., 8}, {300., 400., 500., 700., 800.})
345 << createScalarSeries({1., 2., 3., 7., 10.}, {100., 200., 333., 777., 1000.})
345 << createScalarSeries({1., 2., 3., 7., 10.}, {100., 200., 333., 777., 1000.})
346 << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
346 << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
347 << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
347 << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
348
349 QTest::newRow("emptySource") << createScalarSeries({3., 4., 5., 7., 8},
350 {300., 400., 500., 700., 800.})
351 << createScalarSeries({}, {}) << DataContainer{3., 4., 5., 7., 8.}
352 << DataContainer{300., 400., 500., 700., 800.};
348 }
353 }
349
354
350 void TestDataSeries::testMerge()
355 void TestDataSeries::testMerge()
351 {
356 {
352 // Merges series
357 // Merges series
353 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
358 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
354 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries2);
359 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries2);
355
360
356 dataSeries->merge(dataSeries2.get());
361 dataSeries->merge(dataSeries2.get());
357
362
358 // Validates results : we check that the merge is valid and the data series is sorted on its
363 // Validates results : we check that the merge is valid and the data series is sorted on its
359 // x-axis data
364 // x-axis data
360 QFETCH(DataContainer, expectedXAxisData);
365 QFETCH(DataContainer, expectedXAxisData);
361 QFETCH(DataContainer, expectedValuesData);
366 QFETCH(DataContainer, expectedValuesData);
362
367
363 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
368 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
364 }
369 }
365
370
366 void TestDataSeries::testMergeVectorInScalar_data()
371 void TestDataSeries::testMergeVectorInScalar_data()
367 {
372 {
368 testMergeDifferentTypesStructure<VectorSeries, ScalarSeries>();
373 testMergeDifferentTypesStructure<VectorSeries, ScalarSeries>();
369
374
370 // ////////// //
375 // ////////// //
371 // Test cases //
376 // Test cases //
372 // ////////// //
377 // ////////// //
373
378
374 QTest::newRow("purgeVectorInScalar")
379 QTest::newRow("purgeVectorInScalar")
375 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
380 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
376 << createVectorSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.},
381 << createVectorSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.},
377 {610., 710., 810., 910., 1010.}, {620., 720., 820., 920., 1020.})
382 {610., 710., 810., 910., 1010.}, {620., 720., 820., 920., 1020.})
378 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300., 400., 500.};
383 << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300., 400., 500.};
379 }
384 }
380
385
381 void TestDataSeries::testMergeVectorInScalar()
386 void TestDataSeries::testMergeVectorInScalar()
382 {
387 {
383 testMergeDifferentTypes<VectorSeries, ScalarSeries>();
388 testMergeDifferentTypes<VectorSeries, ScalarSeries>();
384 }
389 }
385
390
386 void TestDataSeries::testPurgeScalar_data()
391 void TestDataSeries::testPurgeScalar_data()
387 {
392 {
388 testPurgeStructure<ScalarSeries>();
393 testPurgeStructure<ScalarSeries>();
389
394
390 // ////////// //
395 // ////////// //
391 // Test cases //
396 // Test cases //
392 // ////////// //
397 // ////////// //
393
398
394 QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.},
399 QTest::newRow("purgeScalar") << createScalarSeries({1., 2., 3., 4., 5.},
395 {100., 200., 300., 400., 500.})
400 {100., 200., 300., 400., 500.})
396 << 2. << 4. << DataContainer{2., 3., 4.}
401 << 2. << 4. << DataContainer{2., 3., 4.}
397 << std::vector<DataContainer>{{200., 300., 400.}};
402 << std::vector<DataContainer>{{200., 300., 400.}};
398 QTest::newRow("purgeScalar1 (min/max swap)")
403 QTest::newRow("purgeScalar1 (min/max swap)")
399 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 4. << 2.
404 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 4. << 2.
400 << DataContainer{2., 3., 4.} << std::vector<DataContainer>{{200., 300., 400.}};
405 << DataContainer{2., 3., 4.} << std::vector<DataContainer>{{200., 300., 400.}};
401 QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.},
406 QTest::newRow("purgeScalar2") << createScalarSeries({1., 2., 3., 4., 5.},
402 {100., 200., 300., 400., 500.})
407 {100., 200., 300., 400., 500.})
403 << 0. << 2.5 << DataContainer{1., 2.}
408 << 0. << 2.5 << DataContainer{1., 2.}
404 << std::vector<DataContainer>{{100., 200.}};
409 << std::vector<DataContainer>{{100., 200.}};
405 QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.},
410 QTest::newRow("purgeScalar3") << createScalarSeries({1., 2., 3., 4., 5.},
406 {100., 200., 300., 400., 500.})
411 {100., 200., 300., 400., 500.})
407 << 3.5 << 7. << DataContainer{4., 5.}
412 << 3.5 << 7. << DataContainer{4., 5.}
408 << std::vector<DataContainer>{{400., 500.}};
413 << std::vector<DataContainer>{{400., 500.}};
409 QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.},
414 QTest::newRow("purgeScalar4") << createScalarSeries({1., 2., 3., 4., 5.},
410 {100., 200., 300., 400., 500.})
415 {100., 200., 300., 400., 500.})
411 << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
416 << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
412 << std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
417 << std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
413 QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.},
418 QTest::newRow("purgeScalar5") << createScalarSeries({1., 2., 3., 4., 5.},
414 {100., 200., 300., 400., 500.})
419 {100., 200., 300., 400., 500.})
415 << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
420 << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
416 }
421 }
417
422
418 void TestDataSeries::testPurgeScalar()
423 void TestDataSeries::testPurgeScalar()
419 {
424 {
420 testPurge<ScalarSeries>();
425 testPurge<ScalarSeries>();
421 }
426 }
422
427
423 void TestDataSeries::testPurgeVector_data()
428 void TestDataSeries::testPurgeVector_data()
424 {
429 {
425 testPurgeStructure<VectorSeries>();
430 testPurgeStructure<VectorSeries>();
426
431
427 // ////////// //
432 // ////////// //
428 // Test cases //
433 // Test cases //
429 // ////////// //
434 // ////////// //
430
435
431 QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.},
436 QTest::newRow("purgeVector") << createVectorSeries({1., 2., 3., 4., 5.}, {6., 7., 8., 9., 10.},
432 {11., 12., 13., 14., 15.},
437 {11., 12., 13., 14., 15.},
433 {16., 17., 18., 19., 20.})
438 {16., 17., 18., 19., 20.})
434 << 2. << 4. << DataContainer{2., 3., 4.}
439 << 2. << 4. << DataContainer{2., 3., 4.}
435 << std::vector<DataContainer>{
440 << std::vector<DataContainer>{
436 {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}};
441 {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}};
437 }
442 }
438
443
439 void TestDataSeries::testPurgeVector()
444 void TestDataSeries::testPurgeVector()
440 {
445 {
441 testPurge<VectorSeries>();
446 testPurge<VectorSeries>();
442 }
447 }
443
448
444 void TestDataSeries::testMinXAxisData_data()
449 void TestDataSeries::testMinXAxisData_data()
445 {
450 {
446 // ////////////// //
451 // ////////////// //
447 // Test structure //
452 // Test structure //
448 // ////////////// //
453 // ////////////// //
449
454
450 // Data series to get min data
455 // Data series to get min data
451 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
456 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
452
457
453 // Min data
458 // Min data
454 QTest::addColumn<double>("min");
459 QTest::addColumn<double>("min");
455
460
456 // Expected results
461 // Expected results
457 QTest::addColumn<bool>(
462 QTest::addColumn<bool>(
458 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
463 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
459 QTest::addColumn<double>(
464 QTest::addColumn<double>(
460 "expectedMin"); // Expected value when method doesn't return end iterator
465 "expectedMin"); // Expected value when method doesn't return end iterator
461
466
462 // ////////// //
467 // ////////// //
463 // Test cases //
468 // Test cases //
464 // ////////// //
469 // ////////// //
465
470
466 QTest::newRow("minData1") << createScalarSeries({1., 2., 3., 4., 5.},
471 QTest::newRow("minData1") << createScalarSeries({1., 2., 3., 4., 5.},
467 {100., 200., 300., 400., 500.})
472 {100., 200., 300., 400., 500.})
468 << 0. << true << 1.;
473 << 0. << true << 1.;
469 QTest::newRow("minData2") << createScalarSeries({1., 2., 3., 4., 5.},
474 QTest::newRow("minData2") << createScalarSeries({1., 2., 3., 4., 5.},
470 {100., 200., 300., 400., 500.})
475 {100., 200., 300., 400., 500.})
471 << 1. << true << 1.;
476 << 1. << true << 1.;
472 QTest::newRow("minData3") << createScalarSeries({1., 2., 3., 4., 5.},
477 QTest::newRow("minData3") << createScalarSeries({1., 2., 3., 4., 5.},
473 {100., 200., 300., 400., 500.})
478 {100., 200., 300., 400., 500.})
474 << 1.1 << true << 2.;
479 << 1.1 << true << 2.;
475 QTest::newRow("minData4") << createScalarSeries({1., 2., 3., 4., 5.},
480 QTest::newRow("minData4") << createScalarSeries({1., 2., 3., 4., 5.},
476 {100., 200., 300., 400., 500.})
481 {100., 200., 300., 400., 500.})
477 << 5. << true << 5.;
482 << 5. << true << 5.;
478 QTest::newRow("minData5") << createScalarSeries({1., 2., 3., 4., 5.},
483 QTest::newRow("minData5") << createScalarSeries({1., 2., 3., 4., 5.},
479 {100., 200., 300., 400., 500.})
484 {100., 200., 300., 400., 500.})
480 << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
485 << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
481 QTest::newRow("minData6") << createScalarSeries({}, {}) << 1.1 << false
486 QTest::newRow("minData6") << createScalarSeries({}, {}) << 1.1 << false
482 << std::numeric_limits<double>::quiet_NaN();
487 << std::numeric_limits<double>::quiet_NaN();
483 }
488 }
484
489
485 void TestDataSeries::testMinXAxisData()
490 void TestDataSeries::testMinXAxisData()
486 {
491 {
487 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
492 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
488 QFETCH(double, min);
493 QFETCH(double, min);
489
494
490 QFETCH(bool, expectedOK);
495 QFETCH(bool, expectedOK);
491 QFETCH(double, expectedMin);
496 QFETCH(double, expectedMin);
492
497
493 auto it = dataSeries->minXAxisData(min);
498 auto it = dataSeries->minXAxisData(min);
494
499
495 QCOMPARE(expectedOK, it != dataSeries->cend());
500 QCOMPARE(expectedOK, it != dataSeries->cend());
496
501
497 // If the method doesn't return a end iterator, checks with expected value
502 // If the method doesn't return a end iterator, checks with expected value
498 if (expectedOK) {
503 if (expectedOK) {
499 QCOMPARE(expectedMin, it->x());
504 QCOMPARE(expectedMin, it->x());
500 }
505 }
501 }
506 }
502
507
503 void TestDataSeries::testMaxXAxisData_data()
508 void TestDataSeries::testMaxXAxisData_data()
504 {
509 {
505 // ////////////// //
510 // ////////////// //
506 // Test structure //
511 // Test structure //
507 // ////////////// //
512 // ////////////// //
508
513
509 // Data series to get max data
514 // Data series to get max data
510 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
515 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
511
516
512 // Max data
517 // Max data
513 QTest::addColumn<double>("max");
518 QTest::addColumn<double>("max");
514
519
515 // Expected results
520 // Expected results
516 QTest::addColumn<bool>(
521 QTest::addColumn<bool>(
517 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
522 "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
518 QTest::addColumn<double>(
523 QTest::addColumn<double>(
519 "expectedMax"); // Expected value when method doesn't return end iterator
524 "expectedMax"); // Expected value when method doesn't return end iterator
520
525
521 // ////////// //
526 // ////////// //
522 // Test cases //
527 // Test cases //
523 // ////////// //
528 // ////////// //
524
529
525 QTest::newRow("maxData1") << createScalarSeries({1., 2., 3., 4., 5.},
530 QTest::newRow("maxData1") << createScalarSeries({1., 2., 3., 4., 5.},
526 {100., 200., 300., 400., 500.})
531 {100., 200., 300., 400., 500.})
527 << 6. << true << 5.;
532 << 6. << true << 5.;
528 QTest::newRow("maxData2") << createScalarSeries({1., 2., 3., 4., 5.},
533 QTest::newRow("maxData2") << createScalarSeries({1., 2., 3., 4., 5.},
529 {100., 200., 300., 400., 500.})
534 {100., 200., 300., 400., 500.})
530 << 5. << true << 5.;
535 << 5. << true << 5.;
531 QTest::newRow("maxData3") << createScalarSeries({1., 2., 3., 4., 5.},
536 QTest::newRow("maxData3") << createScalarSeries({1., 2., 3., 4., 5.},
532 {100., 200., 300., 400., 500.})
537 {100., 200., 300., 400., 500.})
533 << 4.9 << true << 4.;
538 << 4.9 << true << 4.;
534 QTest::newRow("maxData4") << createScalarSeries({1., 2., 3., 4., 5.},
539 QTest::newRow("maxData4") << createScalarSeries({1., 2., 3., 4., 5.},
535 {100., 200., 300., 400., 500.})
540 {100., 200., 300., 400., 500.})
536 << 1.1 << true << 1.;
541 << 1.1 << true << 1.;
537 QTest::newRow("maxData5") << createScalarSeries({1., 2., 3., 4., 5.},
542 QTest::newRow("maxData5") << createScalarSeries({1., 2., 3., 4., 5.},
538 {100., 200., 300., 400., 500.})
543 {100., 200., 300., 400., 500.})
539 << 1. << true << 1.;
544 << 1. << true << 1.;
540 QTest::newRow("maxData6") << createScalarSeries({}, {}) << 1.1 << false
545 QTest::newRow("maxData6") << createScalarSeries({}, {}) << 1.1 << false
541 << std::numeric_limits<double>::quiet_NaN();
546 << std::numeric_limits<double>::quiet_NaN();
542 }
547 }
543
548
544 void TestDataSeries::testMaxXAxisData()
549 void TestDataSeries::testMaxXAxisData()
545 {
550 {
546 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
551 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
547 QFETCH(double, max);
552 QFETCH(double, max);
548
553
549 QFETCH(bool, expectedOK);
554 QFETCH(bool, expectedOK);
550 QFETCH(double, expectedMax);
555 QFETCH(double, expectedMax);
551
556
552 auto it = dataSeries->maxXAxisData(max);
557 auto it = dataSeries->maxXAxisData(max);
553
558
554 QCOMPARE(expectedOK, it != dataSeries->cend());
559 QCOMPARE(expectedOK, it != dataSeries->cend());
555
560
556 // If the method doesn't return a end iterator, checks with expected value
561 // If the method doesn't return a end iterator, checks with expected value
557 if (expectedOK) {
562 if (expectedOK) {
558 QCOMPARE(expectedMax, it->x());
563 QCOMPARE(expectedMax, it->x());
559 }
564 }
560 }
565 }
561
566
562 void TestDataSeries::testXAxisRange_data()
567 void TestDataSeries::testXAxisRange_data()
563 {
568 {
564 // ////////////// //
569 // ////////////// //
565 // Test structure //
570 // Test structure //
566 // ////////////// //
571 // ////////////// //
567
572
568 // Data series to get x-axis range
573 // Data series to get x-axis range
569 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
574 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
570
575
571 // Min/max values
576 // Min/max values
572 QTest::addColumn<double>("min");
577 QTest::addColumn<double>("min");
573 QTest::addColumn<double>("max");
578 QTest::addColumn<double>("max");
574
579
575 // Expected values
580 // Expected values
576 QTest::addColumn<DataContainer>("expectedXAxisData");
581 QTest::addColumn<DataContainer>("expectedXAxisData");
577 QTest::addColumn<DataContainer>("expectedValuesData");
582 QTest::addColumn<DataContainer>("expectedValuesData");
578
583
579 // ////////// //
584 // ////////// //
580 // Test cases //
585 // Test cases //
581 // ////////// //
586 // ////////// //
582
587
583 QTest::newRow("xAxisRange") << createScalarSeries({1., 2., 3., 4., 5.},
588 QTest::newRow("xAxisRange") << createScalarSeries({1., 2., 3., 4., 5.},
584 {100., 200., 300., 400., 500.})
589 {100., 200., 300., 400., 500.})
585 << -1. << 3.2 << DataContainer{1., 2., 3.}
590 << -1. << 3.2 << DataContainer{1., 2., 3.}
586 << DataContainer{100., 200., 300.};
591 << DataContainer{100., 200., 300.};
587 QTest::newRow("xAxisRange1 (min/max swap)")
592 QTest::newRow("xAxisRange1 (min/max swap)")
588 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 3.2 << -1.
593 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 3.2 << -1.
589 << DataContainer{1., 2., 3.} << DataContainer{100., 200., 300.};
594 << DataContainer{1., 2., 3.} << DataContainer{100., 200., 300.};
590 QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
595 QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
591 {100., 200., 300., 400., 500.})
596 {100., 200., 300., 400., 500.})
592 << 1. << 4. << DataContainer{1., 2., 3., 4.}
597 << 1. << 4. << DataContainer{1., 2., 3., 4.}
593 << DataContainer{100., 200., 300., 400.};
598 << DataContainer{100., 200., 300., 400.};
594 QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
599 QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
595 {100., 200., 300., 400., 500.})
600 {100., 200., 300., 400., 500.})
596 << 1. << 3.9 << DataContainer{1., 2., 3.}
601 << 1. << 3.9 << DataContainer{1., 2., 3.}
597 << DataContainer{100., 200., 300.};
602 << DataContainer{100., 200., 300.};
598 QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
603 QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
599 {100., 200., 300., 400., 500.})
604 {100., 200., 300., 400., 500.})
600 << 0. << 0.9 << DataContainer{} << DataContainer{};
605 << 0. << 0.9 << DataContainer{} << DataContainer{};
601 QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
606 QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
602 {100., 200., 300., 400., 500.})
607 {100., 200., 300., 400., 500.})
603 << 0. << 1. << DataContainer{1.} << DataContainer{100.};
608 << 0. << 1. << DataContainer{1.} << DataContainer{100.};
604 QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
609 QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
605 {100., 200., 300., 400., 500.})
610 {100., 200., 300., 400., 500.})
606 << 2.1 << 6. << DataContainer{3., 4., 5.}
611 << 2.1 << 6. << DataContainer{3., 4., 5.}
607 << DataContainer{300., 400., 500.};
612 << DataContainer{300., 400., 500.};
608 QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
613 QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
609 {100., 200., 300., 400., 500.})
614 {100., 200., 300., 400., 500.})
610 << 6. << 9. << DataContainer{} << DataContainer{};
615 << 6. << 9. << DataContainer{} << DataContainer{};
611 QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
616 QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
612 {100., 200., 300., 400., 500.})
617 {100., 200., 300., 400., 500.})
613 << 5. << 9. << DataContainer{5.} << DataContainer{500.};
618 << 5. << 9. << DataContainer{5.} << DataContainer{500.};
614 }
619 }
615
620
616 void TestDataSeries::testXAxisRange()
621 void TestDataSeries::testXAxisRange()
617 {
622 {
618 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
623 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
619 QFETCH(double, min);
624 QFETCH(double, min);
620 QFETCH(double, max);
625 QFETCH(double, max);
621
626
622 QFETCH(DataContainer, expectedXAxisData);
627 QFETCH(DataContainer, expectedXAxisData);
623 QFETCH(DataContainer, expectedValuesData);
628 QFETCH(DataContainer, expectedValuesData);
624
629
625 auto bounds = dataSeries->xAxisRange(min, max);
630 auto bounds = dataSeries->xAxisRange(min, max);
626 validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
631 validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
627 }
632 }
628
633
629 void TestDataSeries::testValuesBoundsScalar_data()
634 void TestDataSeries::testValuesBoundsScalar_data()
630 {
635 {
631 testValuesBoundsStructure<ScalarSeries>();
636 testValuesBoundsStructure<ScalarSeries>();
632
637
633 // ////////// //
638 // ////////// //
634 // Test cases //
639 // Test cases //
635 // ////////// //
640 // ////////// //
636 auto nan = std::numeric_limits<double>::quiet_NaN();
641 auto nan = std::numeric_limits<double>::quiet_NaN();
637
642
638 QTest::newRow("scalarBounds1")
643 QTest::newRow("scalarBounds1")
639 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 6.
644 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 6.
640 << true << 100. << 500.;
645 << true << 100. << 500.;
641 QTest::newRow("scalarBounds2")
646 QTest::newRow("scalarBounds2")
642 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 2. << 4.
647 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 2. << 4.
643 << true << 200. << 400.;
648 << true << 200. << 400.;
644 QTest::newRow("scalarBounds3")
649 QTest::newRow("scalarBounds3")
645 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 0.5
650 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 0.5
646 << false << nan << nan;
651 << false << nan << nan;
647 QTest::newRow("scalarBounds4")
652 QTest::newRow("scalarBounds4")
648 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
653 << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
649 << false << nan << nan;
654 << false << nan << nan;
650 QTest::newRow("scalarBounds5")
655 QTest::newRow("scalarBounds5")
651 << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100. << 100.;
656 << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100. << 100.;
652 QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
657 QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
653
658
654 // Tests with NaN values: NaN values are not included in min/max search
659 // Tests with NaN values: NaN values are not included in min/max search
655 QTest::newRow("scalarBounds7")
660 QTest::newRow("scalarBounds7")
656 << createScalarSeries({1., 2., 3., 4., 5.}, {nan, 200., 300., 400., nan}) << 0. << 6.
661 << createScalarSeries({1., 2., 3., 4., 5.}, {nan, 200., 300., 400., nan}) << 0. << 6.
657 << true << 200. << 400.;
662 << true << 200. << 400.;
658 QTest::newRow("scalarBounds8")
663 QTest::newRow("scalarBounds8")
659 << createScalarSeries({1., 2., 3., 4., 5.}, {nan, nan, nan, nan, nan}) << 0. << 6. << true
664 << createScalarSeries({1., 2., 3., 4., 5.}, {nan, nan, nan, nan, nan}) << 0. << 6. << true
660 << std::numeric_limits<double>::quiet_NaN() << std::numeric_limits<double>::quiet_NaN();
665 << std::numeric_limits<double>::quiet_NaN() << std::numeric_limits<double>::quiet_NaN();
661 }
666 }
662
667
663 void TestDataSeries::testValuesBoundsScalar()
668 void TestDataSeries::testValuesBoundsScalar()
664 {
669 {
665 testValuesBounds<ScalarSeries>();
670 testValuesBounds<ScalarSeries>();
666 }
671 }
667
672
668 void TestDataSeries::testValuesBoundsVector_data()
673 void TestDataSeries::testValuesBoundsVector_data()
669 {
674 {
670 testValuesBoundsStructure<VectorSeries>();
675 testValuesBoundsStructure<VectorSeries>();
671
676
672 // ////////// //
677 // ////////// //
673 // Test cases //
678 // Test cases //
674 // ////////// //
679 // ////////// //
675 auto nan = std::numeric_limits<double>::quiet_NaN();
680 auto nan = std::numeric_limits<double>::quiet_NaN();
676
681
677 QTest::newRow("vectorBounds1")
682 QTest::newRow("vectorBounds1")
678 << createVectorSeries({1., 2., 3., 4., 5.}, {10., 15., 20., 13., 12.},
683 << createVectorSeries({1., 2., 3., 4., 5.}, {10., 15., 20., 13., 12.},
679 {35., 24., 10., 9., 0.3}, {13., 14., 12., 9., 24.})
684 {35., 24., 10., 9., 0.3}, {13., 14., 12., 9., 24.})
680 << 0. << 6. << true << 0.3 << 35.; // min/max in same component
685 << 0. << 6. << true << 0.3 << 35.; // min/max in same component
681 QTest::newRow("vectorBounds2")
686 QTest::newRow("vectorBounds2")
682 << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
687 << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
683 {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
688 {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
684 << 0. << 6. << true << 2.3 << 35.; // min/max in same entry
689 << 0. << 6. << true << 2.3 << 35.; // min/max in same entry
685 QTest::newRow("vectorBounds3")
690 QTest::newRow("vectorBounds3")
686 << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
691 << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
687 {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
692 {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
688 << 2. << 3. << true << 10. << 24.;
693 << 2. << 3. << true << 10. << 24.;
689
694
690 // Tests with NaN values: NaN values are not included in min/max search
695 // Tests with NaN values: NaN values are not included in min/max search
691 QTest::newRow("vectorBounds4")
696 QTest::newRow("vectorBounds4")
692 << createVectorSeries({1., 2.}, {nan, nan}, {nan, nan}, {nan, nan}) << 0. << 6. << true
697 << createVectorSeries({1., 2.}, {nan, nan}, {nan, nan}, {nan, nan}) << 0. << 6. << true
693 << nan << nan;
698 << nan << nan;
694 }
699 }
695
700
696 void TestDataSeries::testValuesBoundsVector()
701 void TestDataSeries::testValuesBoundsVector()
697 {
702 {
698 testValuesBounds<VectorSeries>();
703 testValuesBounds<VectorSeries>();
699 }
704 }
700
705
701 QTEST_MAIN(TestDataSeries)
706 QTEST_MAIN(TestDataSeries)
702 #include "TestDataSeries.moc"
707 #include "TestDataSeries.moc"
General Comments 0
You need to be logged in to leave comments. Login now