##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » qtcharts
RSS

Clone from http://code.qt.io/qt/qtcharts.git

Fix unit test
Michal Klocek -
r411:2606ead906f4
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,379 +1,404
1 1 #include "chartdataset_p.h"
2 2 #include "qchartaxis.h"
3 3 //series
4 4 #include "qlineseries.h"
5 5 #include "qbarseries.h"
6 6 #include "qstackedbarseries.h"
7 7 #include "qpercentbarseries.h"
8 8 #include "qpieseries.h"
9 9 #include "qscatterseries.h"
10 10
11 11 QTCOMMERCIALCHART_BEGIN_NAMESPACE
12 12
13 13 ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
14 14 m_axisX(new QChartAxis(this)),
15 15 m_axisY(new QChartAxis(this)),
16 16 m_domainIndex(0),
17 17 m_axisXInitialized(false)
18 18 {
19 19 }
20 20
21 21 ChartDataSet::~ChartDataSet()
22 22 {
23 23 // TODO Auto-generated destructor stub
24 24 }
25 25
26 26 const Domain ChartDataSet::domain(QChartAxis *axisY) const
27 27 {
28 28 int i = m_domainMap.count(axisY);
29 29 if(i == 0){
30 30 return Domain();
31 31 }
32 32 i = i - m_domainIndex -1;
33 33 return m_domainMap.values(axisY).at(i);
34 34 }
35 35
36 36 void ChartDataSet::addSeries(QSeries* series, QChartAxis *axisY)
37 37 {
38 38 // TODO: we should check the series not already added
39 39
40 40 series->setParent(this); // take ownership
41 41 clearDomains();
42 42
43 43 if(axisY==0) axisY = m_axisY;
44 44 axisY->setParent(this); // take ownership
45 45
46 46 QList<QSeries*> seriesList = m_seriesMap.values(axisY);
47 47
48 48 QList<Domain> domainList = m_domainMap.values(axisY);
49 49
50 50 Q_ASSERT(domainList.size()<=1);
51 51
52 52 Domain domain;
53 53
54 54 if(domainList.size()>0) domain = domainList.at(0);
55 55
56 56 switch(series->type())
57 57 {
58 58 case QSeries::SeriesTypeLine: {
59 59
60 60 QLineSeries* xyseries = static_cast<QLineSeries*>(series);
61 61
62 62 for (int i = 0; i < xyseries->count(); i++)
63 63 {
64 64 qreal x = xyseries->x(i);
65 65 qreal y = xyseries->y(i);
66 66 domain.m_minX = qMin(domain.m_minX,x);
67 67 domain.m_minY = qMin(domain.m_minY,y);
68 68 domain.m_maxX = qMax(domain.m_maxX,x);
69 69 domain.m_maxY = qMax(domain.m_maxY,y);
70 70 }
71 71 break;
72 72 }
73 73 case QSeries::SeriesTypeBar: {
74 74 qDebug() << "QChartSeries::SeriesTypeBar";
75 75 QBarSeries* barSeries = static_cast<QBarSeries*>(series);
76 76 qreal x = barSeries->categoryCount();
77 77 qreal y = barSeries->max();
78 78 domain.m_minX = qMin(domain.m_minX,x);
79 79 domain.m_minY = qMin(domain.m_minY,y);
80 80 domain.m_maxX = qMax(domain.m_maxX,x);
81 81 domain.m_maxY = qMax(domain.m_maxY,y);
82 82 break;
83 83 }
84 84 case QSeries::SeriesTypeStackedBar: {
85 85 qDebug() << "QChartSeries::SeriesTypeStackedBar";
86 86
87 87 QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
88 88 qreal x = stackedBarSeries->categoryCount();
89 89 qreal y = stackedBarSeries->maxCategorySum();
90 90 domain.m_minX = qMin(domain.m_minX,x);
91 91 domain.m_minY = qMin(domain.m_minY,y);
92 92 domain.m_maxX = qMax(domain.m_maxX,x);
93 93 domain.m_maxY = qMax(domain.m_maxY,y);
94 94 break;
95 95 }
96 96 case QSeries::SeriesTypePercentBar: {
97 97 qDebug() << "QChartSeries::SeriesTypePercentBar";
98 98
99 99 QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
100 100 qreal x = percentBarSeries->categoryCount();
101 101 domain.m_minX = qMin(domain.m_minX,x);
102 102 domain.m_minY = 0;
103 103 domain.m_maxX = qMax(domain.m_maxX,x);
104 104 domain.m_maxY = 100;
105 105 break;
106 106 }
107 107
108 108 case QSeries::SeriesTypePie: {
109 109 QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
110 110 // TODO: domain stuff
111 111 break;
112 112 }
113 113
114 114 case QSeries::SeriesTypeScatter: {
115 115 QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
116 116 Q_ASSERT(scatterSeries);
117 117 foreach (QPointF point, scatterSeries->data()) {
118 118 domain.m_minX = qMin(domain.m_minX, point.x());
119 119 domain.m_maxX = qMax(domain.m_maxX, point.x());
120 120 domain.m_minY = qMin(domain.m_minY, point.y());
121 121 domain.m_maxY = qMax(domain.m_maxY, point.y());
122 122 }
123 123 break;
124 124 }
125 125
126 126 default: {
127 127 qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
128 128 return;
129 129 break;
130 130 }
131 131
132 132 }
133 133
134 134 if(!m_domainMap.contains(axisY))
135 135 {
136 136 emit axisAdded(axisY);
137 137 QObject::connect(axisY,SIGNAL(rangeChanged(QChartAxis*)),this,SLOT(handleRangeChanged(QChartAxis*)));
138 138 QObject::connect(axisY,SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
139 139 }
140 140
141 141 if(!m_axisXInitialized)
142 142 {
143 143 emit axisAdded(axisX());
144 144 QObject::connect(axisX(),SIGNAL(rangeChanged(QChartAxis*)),this,SLOT(handleRangeChanged(QChartAxis*)));
145 145 QObject::connect(axisX(),SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
146 146 m_axisXInitialized=true;
147 147 }
148 148
149 149 m_domainMap.replace(axisY,domain);
150 150 m_seriesMap.insert(axisY,series);
151 151 emit seriesAdded(series);
152 setDomain(m_domainIndex);
152 setDomain(m_domainIndex,axisY);
153 153
154 154 }
155 155
156 156 void ChartDataSet::removeSeries(QSeries* series)
157 157 {
158 158 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
159 159 foreach(QChartAxis* axis , keys) {
160 160 if(m_seriesMap.contains(axis,series)){
161 161 emit seriesRemoved(series);
162 162 m_seriesMap.remove(axis,series);
163 163 //remove axis if no longer there
164 164 if(!m_seriesMap.contains(axis)){
165 165 emit axisRemoved(axis);
166 166 m_domainMap.remove(axis);
167 167 if(axis != m_axisY)
168 168 delete axis;
169 169 }
170 170 series->setParent(0);
171 171 break;
172 172 }
173 173 }
174 174 }
175 175
176 176 void ChartDataSet::removeAllSeries()
177 177 {
178 178 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
179 179 foreach(QChartAxis* axis , keys) {
180 180 QList<QSeries*> seriesList = m_seriesMap.values(axis);
181 181 for(int i =0 ; i < seriesList.size();i++ )
182 182 {
183 183 emit seriesRemoved(seriesList.at(i));
184 184 delete(seriesList.at(i));
185 185 }
186 186 m_seriesMap.remove(axis);
187 187 m_domainMap.remove(axis);
188 188 emit axisRemoved(axis);
189 189 if(axis != m_axisY) delete axis;
190 190 }
191 191 m_domainIndex=0;
192 192 }
193 193
194 194 bool ChartDataSet::nextDomain()
195 195 {
196 196 int limit = (m_domainMap.values().size()/m_domainMap.uniqueKeys().size())-1;
197 197
198 198 if (m_domainIndex < limit) {
199 199 m_domainIndex++;
200 200 setDomain(m_domainIndex);
201 201 return true;
202 202 }
203 203 else {
204 204 return false;
205 205 }
206 206 }
207 207
208 208 bool ChartDataSet::previousDomain()
209 209 {
210 210 if (m_domainIndex > 0) {
211 211 m_domainIndex--;
212 212 setDomain(m_domainIndex);
213 213 return true;
214 214 }
215 215 else {
216 216 return false;
217 217 }
218 218 }
219 219
220 220 void ChartDataSet::setDomain(int index)
221 221 {
222 222 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
223 223
224 224 if(domainList.count()==0) return;
225 225
226 226 Domain domain;
227 227
228 228 foreach (QChartAxis* axis , domainList) {
229 229 int i = m_domainMap.count(axis) - index -1;
230 230 Q_ASSERT(i>=0);
231 231 domain = m_domainMap.values(axis).at(i);
232 232 QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
233 233 QList<QSeries*> seriesList = m_seriesMap.values(axis);
234 234 foreach(QSeries* series, seriesList) {
235 235 emit seriesDomainChanged(series,domain);
236 236 }
237 237 axis->updateRange(domain.m_minY,domain.m_maxY);
238 238 emit axisRangeChanged(axis,labels);
239 239
240 240 }
241 241
242 242 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
243 243 axisX()->updateRange(domain.m_minX,domain.m_maxY);
244 244 emit axisRangeChanged(axisX(),labels);
245 245 }
246 246
247 void ChartDataSet::setDomain(int index,QChartAxis* axis)
248 {
249 int i = m_domainMap.count(axis) - index -1;
250 Q_ASSERT(i>=0);
251 Domain domain = m_domainMap.values(axis).at(i);
252 {
253 QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
254 QList<QSeries*> seriesList = m_seriesMap.values(axis);
255 foreach(QSeries* series, seriesList) {
256 emit seriesDomainChanged(series,domain);
257 }
258 axis->updateRange(domain.m_minY,domain.m_maxY);
259 emit axisRangeChanged(axis,labels);
260 }
261
262 QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
263 axisX()->updateRange(domain.m_minX,domain.m_maxY);
264 emit axisRangeChanged(axisX(),labels);
265 }
266
267
247 268 void ChartDataSet::clearDomains(int toIndex)
248 269 {
249 270 Q_ASSERT(toIndex>=0);
250 271
251 272 m_domainIndex = toIndex;
252 273
253 274 QList<QChartAxis*> keys = m_domainMap.uniqueKeys();
254 275
255 276 foreach (QChartAxis* key , keys)
256 277 {
257 278 QList<Domain> domains = m_domainMap.values(key);
258 279 m_domainMap.remove(key);
259 280 int i = domains.size() - toIndex - 1;
260 281 while(i--){
261 282 domains.removeFirst();
262 283 }
263 284 for(int j=domains.size()-1; j>=0 ;j--)
264 285 m_domainMap.insert(key,domains.at(j));
265 286 }
266 287 }
267 288
268 289 void ChartDataSet::addDomain(const QRectF& rect, const QRectF& viewport)
269 290 {
270 291 Q_ASSERT(rect.isValid());
271 292 Q_ASSERT(viewport.isValid());
272 293
273 294 clearDomains(m_domainIndex);
274 295
275 296 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
276 297
277 298 Domain domain;
278 299
279 300 foreach (QChartAxis* axis , domainList){
280 301 domain = m_domainMap.value(axis).subDomain(rect,viewport.width(),viewport.height());
281 302 m_domainMap.insert(axis,domain);
282 303 }
283 304
284 305 setDomain(++m_domainIndex);
285 306 }
286 307
287 308 QChartAxis* ChartDataSet::axisY(QSeries* series) const
288 309 {
289 310 if(series == 0) return m_axisY;
290 311
291 312 QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
292 313
293 314 foreach(QChartAxis* axis , keys) {
294 315 if(m_seriesMap.contains(axis,series)){
295 316 return axis;
296 317 }
297 318 }
298 319 return 0;
299 320 }
300 321
301 322 QStringList ChartDataSet::createLabels(QChartAxis* axis,qreal min, qreal max)
302 323 {
303 324 Q_ASSERT(max>=min);
304 325
305 326 QStringList labels;
306 327
307 328 int ticks = axis->ticksCount()-1;
308 329
309 330 for(int i=0; i<= ticks; i++){
310 331 qreal value = min + (i * (max - min)/ ticks);
311 332 QString label = axis->axisTickLabel(value);
312 333 if(label.isEmpty()){
313 334 labels << QString::number(value);
314 335 }else{
315 336 labels << label;
316 337 }
317 338 }
318 339 return labels;
319 340 }
320 341
321 342
322 343 void ChartDataSet::handleRangeChanged(QChartAxis* axis)
323 344 {
324 345 qreal min = axis->min();
325 346 qreal max = axis->max();
326 347
327 348 if(axis==axisX()) {
328 349
329 350 m_domainIndex=0;
330 351
331 352 clearDomains(m_domainIndex);
332 353
333 354 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
334 355
335 356 foreach (QChartAxis* axis , domainList) {
336 357
337 358 Q_ASSERT(m_domainMap.values(axis).size()==1);
338 359
339 360 Domain domain = m_domainMap.value(axis);
340 361 domain.m_minX=min;
341 362 domain.m_maxX=max;
342 363 m_domainMap.replace(axis,domain);
343 364 }
344 365
366 setDomain(m_domainIndex);
367
345 368 }
346 369 else {
347 370
348 371 QList<Domain> domains = m_domainMap.values(axis);
349 372 m_domainMap.remove(axis);
350 373
351 374 for(int i=0;i<domains.size();i++)
352 375 {
353 376 domains[i].m_minY=min;
354 377 domains[i].m_maxY=max;
355 378 }
356 379
357 380 for(int j=domains.size()-1; j>=0;j--)
358 381 m_domainMap.insert(axis,domains.at(j));
382
383 setDomain(m_domainIndex,axis);
359 384 }
360 385
361 setDomain(m_domainIndex);
386
362 387 }
363 388
364 389 void ChartDataSet::handleTickChanged(QChartAxis* axis)
365 390 {
366 391 if(axis==axisX()){
367 392 Domain domain = m_domainMap.value(axisY());
368 393 QStringList labels = createLabels(axis,domain.m_minX,domain.m_maxX);
369 394 emit axisRangeChanged(axis,labels);
370 395 }else{
371 396 Domain domain = m_domainMap.value(axis);
372 397 QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
373 398 emit axisRangeChanged(axis,labels);
374 399 }
375 400 }
376 401
377 402 #include "moc_chartdataset_p.cpp"
378 403
379 404 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,59 +1,60
1 1 #ifndef CHARTDATASET_P_H_
2 2 #define CHARTDATASET_P_H_
3 3
4 4 #include "qseries.h"
5 5 #include "domain_p.h"
6 6 #include <QVector>
7 7
8 8 QTCOMMERCIALCHART_BEGIN_NAMESPACE
9 9
10 10 class QChartAxis;
11 11
12 12 class ChartDataSet : public QObject
13 13 {
14 14 Q_OBJECT
15 15 public:
16 16 ChartDataSet(QObject* parent=0);
17 17 virtual ~ChartDataSet();
18 18
19 19 void addSeries(QSeries* series,QChartAxis *axisY = 0);
20 20 void removeSeries(QSeries* series);
21 21 void removeAllSeries();
22 22 void addDomain(const QRectF& rect, const QRectF& viewport);
23 23 bool nextDomain();
24 24 bool previousDomain();
25 25 void clearDomains(int toIndex =0);
26 26 const Domain domain(QChartAxis *axisY) const;
27 27 int domainIndex() const {return m_domainIndex;}
28 28 void setDomain(int index);
29 void setDomain(int index,QChartAxis* axis);
29 30
30 31 QChartAxis* axisX() const { return m_axisX;};
31 32 QChartAxis* axisY(QSeries* series = 0) const;
32 33
33 34 signals:
34 35 void seriesAdded(QSeries* series);
35 36 void seriesRemoved(QSeries* series);
36 37 void axisAdded(QChartAxis* axis);
37 38 void axisRemoved(QChartAxis* axis);
38 39 void axisRangeChanged(QChartAxis* axis, const QStringList& labels);
39 40 void seriesDomainChanged(QSeries* series,const Domain& domain);
40 41
41 42 private slots:
42 43 void handleRangeChanged(QChartAxis*);
43 44 void handleTickChanged(QChartAxis*);
44 45
45 46 private:
46 47 QStringList createLabels(QChartAxis* axis,qreal min, qreal max);
47 48
48 49 private:
49 50 QMultiMap<QChartAxis*, Domain> m_domainMap;
50 51 QMultiMap<QChartAxis*, QSeries*> m_seriesMap;
51 52 QChartAxis* m_axisX;
52 53 QChartAxis* m_axisY;
53 54 int m_domainIndex;
54 55 bool m_axisXInitialized;
55 56 };
56 57
57 58 QTCOMMERCIALCHART_END_NAMESPACE
58 59
59 60 #endif /* CHARTENGINE_P_H_ */
Show file before | Show file after | Hide comments
@@ -1,598 +1,614
1 1 #include <QtTest/QtTest>
2 2 #include <qchartaxis.h>
3 3 #include <qlineseries.h>
4 4 #include <private/chartdataset_p.h>
5 5 #include <private/domain_p.h>
6 6
7 7 QTCOMMERCIALCHART_USE_NAMESPACE
8 8
9 9 Q_DECLARE_METATYPE(Domain)
10 10 Q_DECLARE_METATYPE(QChartAxis*)
11 11 Q_DECLARE_METATYPE(QSeries*)
12 12 Q_DECLARE_METATYPE(QLineSeries*)
13 13
14 14 class tst_ChartDataSet: public QObject {
15 15 Q_OBJECT
16 16
17 17 public slots:
18 18 void initTestCase();
19 19 void cleanupTestCase();
20 20 void init();
21 21 void cleanup();
22 22
23 23 private slots:
24 24 void chartdataset_data();
25 25 void chartdataset();
26 26
27 27 void addDomain_data();
28 28 void addDomain();
29 29 void addSeries_data();
30 30 void addSeries();
31 31 void axisY_data();
32 32 void axisY();
33 33 void clearDomains_data();
34 34 void clearDomains();
35 35 void domain_data();
36 36 void domain();
37 37 void nextpreviousDomain_data();
38 38 void nextpreviousDomain();
39 39 void removeSeries_data();
40 40 void removeSeries();
41 41 void removeAllSeries_data();
42 42 void removeAllSeries();
43 43 };
44 44
45 45 void tst_ChartDataSet::initTestCase()
46 46 {
47 47 qRegisterMetaType<Domain>("Domain");
48 48 qRegisterMetaType<QChartAxis*>();
49 49 qRegisterMetaType<QSeries*>();
50 50 }
51 51
52 52 void tst_ChartDataSet::cleanupTestCase()
53 53 {
54 54 }
55 55
56 56 void tst_ChartDataSet::init()
57 57 {
58 58 }
59 59
60 60 void tst_ChartDataSet::cleanup()
61 61 {
62 62 }
63 63
64 64 void tst_ChartDataSet::chartdataset_data()
65 65 {
66 66 }
67 67
68 68 void tst_ChartDataSet::chartdataset()
69 69 {
70 70 ChartDataSet dataSet;
71 71 QVERIFY2(dataSet.axisX(), "Missing axisX.");
72 72 QVERIFY2(dataSet.axisY(), "Missing axisY.");
73 73 //check if not dangling pointer
74 74 dataSet.axisX()->objectName();
75 75 dataSet.axisY()->objectName();
76 76 QVERIFY(dataSet.domain(dataSet.axisX())==Domain());
77 77 QVERIFY(dataSet.domain(dataSet.axisY())==Domain());
78 78 QCOMPARE(dataSet.domainIndex(), 0);
79 79 }
80 80
81 81 void tst_ChartDataSet::addDomain_data()
82 82 {
83 83 QTest::addColumn<QRectF>("rect");
84 84 QTest::addColumn<QRectF>("viewport");
85 85 QTest::newRow("400x400,1000x1000") << QRectF(200, 200, 600, 600)
86 86 << QRectF(0, 0, 1000, 1000);
87 87 QTest::newRow("600x600,1000x1000") << QRectF(100, 100, 700, 700)
88 88 << QRectF(0, 0, 1000, 1000);
89 89 QTest::newRow("200x200,1000x1000") << QRectF(400, 400, 600, 600)
90 90 << QRectF(0, 0, 1000, 1000);
91 91 }
92 92
93 93 void tst_ChartDataSet::addDomain()
94 94 {
95 95 QFETCH(QRectF, rect);
96 96 QFETCH(QRectF, viewport);
97 97
98 98 ChartDataSet dataSet;
99 99
100 100 Domain domain1(0, 1000, 0, 1000);
101 101 QLineSeries series;
102 102 series.add(0, 0);
103 103 series.add(1000, 1000);
104 104
105 105 dataSet.addSeries(&series);
106 106
107 107 QCOMPARE(dataSet.domainIndex(), 0);
108 108
109 109 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
110 110 QSignalSpy spy1(&dataSet,
111 111 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
112 112 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
113 113 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
114 114 QSignalSpy spy4(&dataSet,
115 115 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
116 116 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
117 117
118 118 Domain domain2 = dataSet.domain(dataSet.axisY());
119 119 QVERIFY(domain1 == domain2);
120 120
121 121 dataSet.addDomain(rect, viewport);
122 122 QCOMPARE(dataSet.domainIndex(), 1);
123 123 Domain domain3 = dataSet.domain(dataSet.axisY());
124 124 Domain domain4 = domain1.subDomain(rect, viewport.width(),
125 125 viewport.height());
126 126 QVERIFY(domain3 == domain4);
127 127
128 128 QCOMPARE(spy0.count(), 0);
129 129 QCOMPARE(spy1.count(), 2);
130 130 QCOMPARE(spy2.count(), 0);
131 131 QCOMPARE(spy3.count(), 0);
132 132 QCOMPARE(spy4.count(), 1);
133 133 QCOMPARE(spy5.count(), 0);
134 134 }
135 135
136 136 void tst_ChartDataSet::addSeries_data()
137 137 {
138 QTest::addColumn<int>("seriesCount");
139 QTest::addColumn<int>("axisYCount");
140 QTest::newRow("2 series, default axis") << 2 << 0;
141 QTest::newRow("2 series, 2 new axis") << 2 << 2;
142 QTest::newRow("2 series, 1 new axis") << 2 << 2;
143 QTest::newRow("3 series, 3 new axis") << 3 << 3;
144 QTest::newRow("3 series, 2 new axis") << 3 << 2;
145 QTest::newRow("3 series, 1 new axis") << 3 << 1;
138 QTest::addColumn<int>("defaultAxisCount");
139 QTest::addColumn<int>("firstAxisCount");
140 QTest::addColumn<int>("secoundAxisCount");
141 QTest::newRow("2 ,1 ,0") << 2 << 1 << 0;
142 QTest::newRow("2 series, 2 new axis") << 2 << 0 << 2;
143 QTest::newRow("2 series, 1 new axis") << 2 << 0 << 2;
144 QTest::newRow("3 series, 3 new axis") << 3 << 0 << 3;
145 QTest::newRow("3 series, 2 new axis") << 3 << 0 << 2;
146 QTest::newRow("3 series, 1 new axis") << 3 << 0 << 1;
147 QTest::newRow("3 series, default + 1 new axis") << 3 << 0 << 1;
146 148 }
147 149
148 150 void tst_ChartDataSet::addSeries()
149 151 {
150 QFETCH(int, seriesCount);
151 QFETCH(int, axisYCount);
152 QFETCH(int, defaultAxisCount);
153 QFETCH(int, firstAxisCount);
154 QFETCH(int, secoundAxisCount);
152 155
153 156 ChartDataSet dataSet;
154 157
155 158 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
156 QSignalSpy spy1(&dataSet,
157 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
159 QSignalSpy spy1(&dataSet, SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
158 160 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
159 161 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
160 QSignalSpy spy4(&dataSet,
161 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
162 QSignalSpy spy4(&dataSet, SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
162 163 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
163 164
164 QList<QChartAxis*> axisList;
165
166 for (int i = 0; i < axisYCount; i++) {
167 QChartAxis* axis = new QChartAxis();
168 axisList << axis;
165 for (int i = 0; i < defaultAxisCount; i++) {
166 QLineSeries* series = new QLineSeries();
167 dataSet.addSeries(series);
169 168 }
170 169
171 QList<QChartAxis*>::iterator iterator = axisList.begin();
170 QChartAxis* firstAxis = new QChartAxis();
172 171
173 for (int i = 0; i < seriesCount; i++) {
174 QChartAxis* axisY = 0;
172 for (int i = 0; i < firstAxisCount; i++) {
175 173 QLineSeries* series = new QLineSeries();
176 if (iterator != axisList.end()) {
177 axisY = *iterator;
178 iterator++;
179 } else if (axisList.count() > 0) {
180 iterator--;
181 axisY = *iterator;
182 iterator++;
174 dataSet.addSeries(series, firstAxis);
183 175 }
184 dataSet.addSeries(series, axisY);
176
177 QChartAxis* secoundAxis = new QChartAxis();
178
179 for (int i = 0; i < secoundAxisCount; i++) {
180 QLineSeries* series = new QLineSeries();
181 dataSet.addSeries(series, secoundAxis);
185 182 }
186 183
187 //default axis
188 if (axisYCount == 0)
189 axisYCount+=2;
190 else
191 axisYCount++;
184 int axisCount = 1;
185
186 if (defaultAxisCount > 0)
187 axisCount++;
188 if (firstAxisCount > 0)
189 axisCount++;
190 if (secoundAxisCount > 0)
191 axisCount++;
192 192
193 QCOMPARE(spy0.count(), axisYCount);
194 QCOMPARE(spy1.count(), seriesCount*2);
193 QCOMPARE(spy0.count(), axisCount);
194 QCOMPARE(spy1.count(), (defaultAxisCount + firstAxisCount + secoundAxisCount)*2);
195 195 QCOMPARE(spy2.count(), 0);
196 QCOMPARE(spy3.count(), seriesCount);
197 QCOMPARE(spy4.count(), seriesCount);
196 QCOMPARE(spy3.count(), defaultAxisCount + firstAxisCount + secoundAxisCount);
197
198 int i = 0;
199 while (defaultAxisCount) {
200 i+=defaultAxisCount;
201 defaultAxisCount--;
202 }
203 int j = 0;
204 while (firstAxisCount>0) {
205 j += firstAxisCount;
206 firstAxisCount--;
207 }
208 int k = 0;
209 while (secoundAxisCount>0) {
210 k += secoundAxisCount;
211 secoundAxisCount--;
212 }
213 QCOMPARE(spy4.count(),i + j + k);
198 214 QCOMPARE(spy5.count(), 0);
199 215
200 216 QCOMPARE(dataSet.domainIndex(), 0);
201 217 }
202 218
203 219 void tst_ChartDataSet::axisY_data()
204 220 {
205 221 QTest::addColumn<QChartAxis*>("axisY");
206 222 QTest::newRow("axisY1") << new QChartAxis();
207 223 QTest::newRow("axisY2") << new QChartAxis();
208 224 }
209 225
210 226 void tst_ChartDataSet::axisY()
211 227 {
212 228 QFETCH(QChartAxis*, axisY);
213 229
214 230 ChartDataSet dataSet;
215 231
216 232 QChartAxis* defaultAxisY = dataSet.axisY();
217 233
218 234 QVERIFY2(defaultAxisY, "Missing axisY.");
219 235
220 236 QLineSeries* series1 = new QLineSeries();
221 237 dataSet.addSeries(series1);
222 238
223 239 QLineSeries* series2 = new QLineSeries();
224 240 dataSet.addSeries(series2, axisY);
225 241
226 242 QVERIFY(dataSet.axisY(series1) == defaultAxisY);
227 243 QVERIFY(dataSet.axisY(series2) == axisY);
228 244
229 245
230 246 }
231 247
232 248 void tst_ChartDataSet::clearDomains_data()
233 249 {
234 250 QTest::addColumn<int>("indexCount");
235 251 QTest::newRow("0") << 0;
236 252 QTest::newRow("1") << 1;
237 253 QTest::newRow("5") << 2;
238 254 QTest::newRow("8") << 3;
239 255 }
240 256
241 257 void tst_ChartDataSet::clearDomains()
242 258 {
243 259 QFETCH(int, indexCount);
244 260
245 261 Domain domain1(0, 100, 0, 100);
246 262 QLineSeries* series = new QLineSeries();
247 263 series->add(0, 0);
248 264 series->add(100, 100);
249 265
250 266 ChartDataSet dataSet;
251 267
252 268 QCOMPARE(dataSet.domainIndex(), 0);
253 269
254 270 dataSet.addSeries(series);
255 271
256 272 Domain domain2 = dataSet.domain(dataSet.axisY());
257 273
258 274 QVERIFY(domain2 == domain1);
259 275
260 276 QList<Domain> domains;
261 277
262 278 domains << domain1;
263 279
264 280 for (int i = 0; i < indexCount; i++) {
265 281 dataSet.addDomain(QRect(0, 0, 10, 10), QRect(0, 0, 100, 100));
266 282 domains << dataSet.domain(dataSet.axisY());
267 283 }
268 284
269 285 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
270 286 QSignalSpy spy1(&dataSet,
271 287 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
272 288 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
273 289 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
274 290 QSignalSpy spy4(&dataSet,
275 291 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
276 292 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
277 293
278 294 dataSet.clearDomains(indexCount);
279 295
280 296 QCOMPARE(dataSet.domainIndex(), indexCount);
281 297
282 298 domain2 = dataSet.domain(dataSet.axisY());
283 299
284 300 QVERIFY(domain2 == domains.at(indexCount));
285 301
286 302 QCOMPARE(spy0.count(), 0);
287 303 QCOMPARE(spy1.count(), 0);
288 304 QCOMPARE(spy2.count(), 0);
289 305 QCOMPARE(spy3.count(), 0);
290 306 QCOMPARE(spy4.count(), 0);
291 307 QCOMPARE(spy5.count(), 0);
292 308 }
293 309
294 310 void tst_ChartDataSet::domain_data()
295 311 {
296 312 QTest::addColumn<Domain>("domain1");
297 313 QTest::addColumn<Domain>("domain2");
298 314 QTest::addColumn<Domain>("domain3");
299 315 QTest::addColumn<Domain>("domain");
300 316 QTest::newRow("Domain(0,10,0,10)") << Domain(0, 10, 0, 10)
301 317 << Domain(0, 5, 0, 5) << Domain(0, 3, 0, 3) << Domain(0, 10, 0, 10);
302 318 QTest::newRow("Domain(-1,11,0,11)") << Domain(-1, 10, 0, 10)
303 319 << Domain(0, 11, 0, 11) << Domain(0, 3, 0, 3)
304 320 << Domain(-1, 11, 0, 11);
305 321 QTest::newRow("Domain(-5,5,1,8)") << Domain(-5, 0, 1, 1)
306 322 << Domain(0, 5, 0, 8) << Domain(1, 2, 1, 2) << Domain(-5, 5, 0, 8);
307 323 }
308 324
309 325 void tst_ChartDataSet::domain()
310 326 {
311 327 QFETCH(Domain, domain1);
312 328 QFETCH(Domain, domain2);
313 329 QFETCH(Domain, domain3);
314 330 QFETCH(Domain, domain);
315 331
316 332 ChartDataSet dataSet;
317 333 QLineSeries* series1 = new QLineSeries();
318 334 series1->add(domain1.m_minX, domain1.m_minY);
319 335 series1->add(domain1.m_maxX, domain1.m_maxY);
320 336 QLineSeries* series2 = new QLineSeries();
321 337 series2->add(domain2.m_minX, domain2.m_minY);
322 338 series2->add(domain2.m_maxX, domain2.m_maxY);
323 339 QLineSeries* series3 = new QLineSeries();
324 340 series3->add(domain3.m_minX, domain3.m_minY);
325 341 series3->add(domain3.m_maxX, domain3.m_maxY);
326 342
327 343 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
328 344 QSignalSpy spy1(&dataSet,
329 345 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
330 346 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
331 347 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
332 348 QSignalSpy spy4(&dataSet,
333 349 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
334 350 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
335 351
336 352 dataSet.addSeries(series1);
337 353 dataSet.addSeries(series2);
338 354 dataSet.addSeries(series3);
339 355
340 356 QCOMPARE(dataSet.domainIndex(), 0);
341 357 QVERIFY2(dataSet.domain(dataSet.axisY()) == domain, "Domain not equal");
342 358
343 359 QCOMPARE(spy0.count(), 2);
344 360 QCOMPARE(spy1.count(), 6);
345 361 QCOMPARE(spy2.count(), 0);
346 362 QCOMPARE(spy3.count(), 3);
347 QCOMPARE(spy4.count(), 3);
363 QCOMPARE(spy4.count(), 6);
348 364 QCOMPARE(spy5.count(), 0);
349 365 }
350 366
351 367 void tst_ChartDataSet::nextpreviousDomain_data()
352 368 {
353 369 QTest::addColumn<QRectF>("rect");
354 370 QTest::addColumn<QRectF>("viewport");
355 371 QTest::newRow("400x400,1000x1000") << QRectF(200, 200, 600, 600)
356 372 << QRectF(0, 0, 1000, 1000);
357 373 QTest::newRow("600x600,1000x1000") << QRectF(100, 100, 700, 700)
358 374 << QRectF(0, 0, 1000, 1000);
359 375 QTest::newRow("200x200,1000x1000") << QRectF(400, 400, 600, 600)
360 376 << QRectF(0, 0, 1000, 1000);
361 377 }
362 378
363 379 void tst_ChartDataSet::nextpreviousDomain()
364 380 {
365 381
366 382 QFETCH(QRectF, rect);
367 383 QFETCH(QRectF, viewport);
368 384
369 385 ChartDataSet dataSet;
370 386
371 387 Domain domain1(0, 1000, 0, 1000);
372 388 QLineSeries* series = new QLineSeries();
373 389 series->add(0, 0);
374 390 series->add(1000, 1000);
375 391
376 392 dataSet.addSeries(series);
377 393
378 394 QCOMPARE(dataSet.domainIndex(), 0);
379 395
380 396 Domain domain2 = dataSet.domain(dataSet.axisY());
381 397 QVERIFY(domain1 == domain2);
382 398
383 399 dataSet.addDomain(rect, viewport);
384 400 QCOMPARE(dataSet.domainIndex(), 1);
385 401 Domain domain3 = dataSet.domain(dataSet.axisY());
386 402 Domain domain4 = domain1.subDomain(rect, viewport.width(),
387 403 viewport.height());
388 404 QVERIFY(domain3 == domain4);
389 405
390 406 dataSet.addDomain(rect, viewport);
391 407 QCOMPARE(dataSet.domainIndex(), 2);
392 408 Domain domain5 = dataSet.domain(dataSet.axisY());
393 409 Domain domain6 = domain3.subDomain(rect, viewport.width(),
394 410 viewport.height());
395 411 QVERIFY(domain5 == domain6);
396 412
397 413 dataSet.addDomain(rect, viewport);
398 414 QCOMPARE(dataSet.domainIndex(), 3);
399 415 Domain domain7 = dataSet.domain(dataSet.axisY());
400 416 Domain domain8 = domain5.subDomain(rect, viewport.width(),
401 417 viewport.height());
402 418 QVERIFY(domain7 == domain8);
403 419
404 420 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
405 421 QSignalSpy spy1(&dataSet,
406 422 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
407 423 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
408 424 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
409 425 QSignalSpy spy4(&dataSet,
410 426 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
411 427 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
412 428
413 429 Domain domain;
414 430
415 431 bool previous = dataSet.previousDomain();
416 432 QCOMPARE(previous, true);
417 433 QCOMPARE(dataSet.domainIndex(), 2);
418 434 domain = dataSet.domain(dataSet.axisY());
419 435 QVERIFY(domain == domain5);
420 436 previous = dataSet.previousDomain();
421 437 QCOMPARE(previous, true);
422 438 QCOMPARE(dataSet.domainIndex(), 1);
423 439 domain = dataSet.domain(dataSet.axisY());
424 440 QVERIFY(domain == domain3);
425 441 previous = dataSet.previousDomain();
426 442 QCOMPARE(previous, true);
427 443 QCOMPARE(dataSet.domainIndex(), 0);
428 444 domain = dataSet.domain(dataSet.axisY());
429 445 QVERIFY(domain == domain1);
430 446 previous = dataSet.previousDomain();
431 447 QCOMPARE(previous, false);
432 448 QCOMPARE(dataSet.domainIndex(), 0);
433 449 domain = dataSet.domain(dataSet.axisY());
434 450 QVERIFY(domain == domain1);
435 451
436 452 bool next = dataSet.nextDomain();
437 453 QCOMPARE(next, true);
438 454 QCOMPARE(dataSet.domainIndex(),1);
439 455 next = dataSet.nextDomain();
440 456 QCOMPARE(next, true);
441 457 QCOMPARE(dataSet.domainIndex(),2);
442 458 next = dataSet.nextDomain();
443 459 QCOMPARE(next, true);
444 460 QCOMPARE(dataSet.domainIndex(),3);
445 461 next = dataSet.nextDomain();
446 462 QCOMPARE(next, false);
447 463 QCOMPARE(dataSet.domainIndex(),3);
448 464
449 465
450 466 QCOMPARE(spy0.count(), 0);
451 467 QCOMPARE(spy1.count(), 12);
452 468 QCOMPARE(spy2.count(), 0);
453 469 QCOMPARE(spy3.count(), 0);
454 470 QCOMPARE(spy4.count(), 6);
455 471 QCOMPARE(spy5.count(), 0);
456 472 }
457 473
458 474 void tst_ChartDataSet::removeSeries_data()
459 475 {
460 476 QTest::addColumn<int>("seriesCount");
461 477 QTest::addColumn<int>("axisYCount");
462 478 QTest::newRow("2 series, default axis") << 2 << 0;
463 479 QTest::newRow("2 series, 2 new axis") << 2 << 2;
464 480 QTest::newRow("2 series, 1 new axis") << 2 << 2;
465 481 QTest::newRow("3 series, 3 new axis") << 3 << 3;
466 482 QTest::newRow("3 series, 2 new axis") << 3 << 2;
467 483 QTest::newRow("3 series, 1 new axis") << 3 << 1;
468 484 }
469 485
470 486 void tst_ChartDataSet::removeSeries()
471 487 {
472 488 QFETCH(int, seriesCount);
473 489 QFETCH(int, axisYCount);
474 490
475 491 ChartDataSet dataSet;
476 492
477 493 QList<QChartAxis*> axisList;
478 494 QList<QSeries*> seriesList;
479 495
480 496 for (int i = 0; i < axisYCount; i++) {
481 497 QChartAxis* axis = new QChartAxis();
482 498 axisList << axis;
483 499 }
484 500
485 501 QList<QChartAxis*>::iterator iterator = axisList.begin();
486 502
487 503 for (int i = 0; i < seriesCount; i++) {
488 504 QChartAxis* axisY = 0;
489 505 QLineSeries* series = new QLineSeries();
490 506 if (iterator != axisList.end()) {
491 507 axisY = *iterator;
492 508 iterator++;
493 509 } else if (axisList.count() > 0) {
494 510 iterator--;
495 511 axisY = *iterator;
496 512 iterator++;
497 513 }
498 514 dataSet.addSeries(series, axisY);
499 515 seriesList << series;
500 516 }
501 517
502 518 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
503 519 QSignalSpy spy1(&dataSet,
504 520 SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
505 521 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
506 522 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
507 523 QSignalSpy spy4(&dataSet,
508 524 SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
509 525 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
510 526
511 527 for (int i = 0; i < seriesCount; i++) {
512 528 dataSet.removeSeries(seriesList.at(i));
513 529 }
514 530
515 531 //default axis
516 532 if (axisYCount == 0)
517 533 axisYCount++;
518 534
519 535 QCOMPARE(spy0.count(), 0);
520 536 QCOMPARE(spy1.count(), 0);
521 537 QCOMPARE(spy2.count(), axisYCount);
522 538 QCOMPARE(spy3.count(), 0);
523 539 QCOMPARE(spy4.count(), 0);
524 540 QCOMPARE(spy5.count(), seriesCount);
525 541
526 542 QCOMPARE(dataSet.domainIndex(), 0);
527 543
528 544 qDeleteAll(seriesList);
529 545 }
530 546
531 547 void tst_ChartDataSet::removeAllSeries_data()
532 548 {
533 549 QTest::addColumn<int>("seriesCount");
534 550 QTest::addColumn<int>("axisYCount");
535 551 QTest::newRow("2 series, default axis") << 2 << 0;
536 552 QTest::newRow("2 series, 2 new axis") << 2 << 2;
537 553 QTest::newRow("2 series, 1 new axis") << 2 << 2;
538 554 QTest::newRow("3 series, 3 new axis") << 3 << 3;
539 555 QTest::newRow("3 series, 2 new axis") << 3 << 2;
540 556 QTest::newRow("3 series, 1 new axis") << 3 << 1;
541 557 }
542 558
543 559 void tst_ChartDataSet::removeAllSeries()
544 560 {
545 561 QFETCH(int, seriesCount);
546 562 QFETCH(int, axisYCount);
547 563
548 564 ChartDataSet dataSet;
549 565
550 566 QList<QChartAxis*> axisList;
551 567
552 568 for (int i = 0; i < axisYCount; i++) {
553 569 QChartAxis* axis = new QChartAxis();
554 570 axisList << axis;
555 571 }
556 572
557 573 QList<QChartAxis*>::iterator iterator = axisList.begin();
558 574
559 575 for (int i = 0; i < seriesCount; i++) {
560 576 QChartAxis* axisY = 0;
561 577 QLineSeries* series = new QLineSeries();
562 578 if (iterator != axisList.end()) {
563 579 axisY = *iterator;
564 580 iterator++;
565 581 } else if (axisList.count() > 0) {
566 582 iterator--;
567 583 axisY = *iterator;
568 584 iterator++;
569 585 }
570 586 dataSet.addSeries(series, axisY);
571 587 }
572 588
573 589 QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*)));
574 590 QSignalSpy spy1(&dataSet, SIGNAL(axisRangeChanged(QChartAxis*, QStringList const&)));
575 591 QSignalSpy spy2(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
576 592 QSignalSpy spy3(&dataSet, SIGNAL(seriesAdded(QSeries*)));
577 593 QSignalSpy spy4(&dataSet, SIGNAL(seriesDomainChanged(QSeries*, Domain const&)));
578 594 QSignalSpy spy5(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
579 595
580 596 dataSet.removeAllSeries();
581 597 //default axis
582 598 if (axisYCount == 0)
583 599 axisYCount++;
584 600
585 601 QCOMPARE(spy0.count(), 0);
586 602 QCOMPARE(spy1.count(), 0);
587 603 QCOMPARE(spy2.count(), axisYCount);
588 604 QCOMPARE(spy3.count(), 0);
589 605 QCOMPARE(spy4.count(), 0);
590 606 QCOMPARE(spy5.count(), seriesCount);
591 607
592 608 QCOMPARE(dataSet.domainIndex(), 0);
593 609 }
594 610
595 611
596 612 QTEST_MAIN(tst_ChartDataSet)
597 613 #include "tst_chartdataset.moc"
598 614
General Comments 0
You need to be logged in to leave comments. Login now