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

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

Update tst_qchart to match current axis implementation
Michal Klocek -
r1660:525c02d166a8
parent child
Show More
Side by Side Unified
Context file:
r1660:525c02d166a8 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,624 +1,623
1 /****************************************************************************
1 /****************************************************************************
2 **
2 **
3 ** Copyright (C) 2012 Digia Plc
3 ** Copyright (C) 2012 Digia Plc
4 ** All rights reserved.
4 ** All rights reserved.
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 **
6 **
7 ** This file is part of the Qt Commercial Charts Add-on.
7 ** This file is part of the Qt Commercial Charts Add-on.
8 **
8 **
9 ** $QT_BEGIN_LICENSE$
9 ** $QT_BEGIN_LICENSE$
10 ** Licensees holding valid Qt Commercial licenses may use this file in
10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 ** accordance with the Qt Commercial License Agreement provided with the
11 ** accordance with the Qt Commercial License Agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.
13 ** a written agreement between you and Digia.
14 **
14 **
15 ** If you have questions regarding the use of this file, please use
15 ** If you have questions regarding the use of this file, please use
16 ** contact form at http://qt.digia.com
16 ** contact form at http://qt.digia.com
17 ** $QT_END_LICENSE$
17 ** $QT_END_LICENSE$
18 **
18 **
19 ****************************************************************************/
19 ****************************************************************************/
20
20
21 #include <QtTest/QtTest>
21 #include <QtTest/QtTest>
22 #include <qabstractaxis.h>
22 #include <qabstractaxis.h>
23 #include <qvaluesaxis.h>
23 #include <qvaluesaxis.h>
24 #include <qbarcategoriesaxis.h>
24 #include <qbarcategoriesaxis.h>
25 #include <qlineseries.h>
25 #include <qlineseries.h>
26 #include <qareaseries.h>
26 #include <qareaseries.h>
27 #include <qscatterseries.h>
27 #include <qscatterseries.h>
28 #include <qsplineseries.h>
28 #include <qsplineseries.h>
29 #include <qpieseries.h>
29 #include <qpieseries.h>
30 #include <qbarseries.h>
30 #include <qbarseries.h>
31 #include <qpercentbarseries.h>
31 #include <qpercentbarseries.h>
32 #include <qstackedbarseries.h>
32 #include <qstackedbarseries.h>
33 #include <private/chartdataset_p.h>
33 #include <private/chartdataset_p.h>
34 #include <private/domain_p.h>
34 #include <private/domain_p.h>
35 #include <tst_definitions.h>
35 #include <tst_definitions.h>
36
36
37 QTCOMMERCIALCHART_USE_NAMESPACE
37 QTCOMMERCIALCHART_USE_NAMESPACE
38
38
39 Q_DECLARE_METATYPE(Domain *)
39 Q_DECLARE_METATYPE(Domain *)
40 Q_DECLARE_METATYPE(QAbstractAxis *)
40 Q_DECLARE_METATYPE(QAbstractAxis *)
41 Q_DECLARE_METATYPE(QAbstractSeries *)
41 Q_DECLARE_METATYPE(QAbstractSeries *)
42 Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
42 Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
43 Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
43 Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
44 Q_DECLARE_METATYPE(QLineSeries *)
44 Q_DECLARE_METATYPE(QLineSeries *)
45
45
46 class tst_ChartDataSet: public QObject {
46 class tst_ChartDataSet: public QObject {
47
47
48 Q_OBJECT
48 Q_OBJECT
49
49
50 public Q_SLOTS:
50 public Q_SLOTS:
51 void initTestCase();
51 void initTestCase();
52 void cleanupTestCase();
52 void cleanupTestCase();
53 void init();
53 void init();
54 void cleanup();
54 void cleanup();
55
55
56 private Q_SLOTS:
56 private Q_SLOTS:
57 void chartdataset_data();
57 void chartdataset_data();
58 void chartdataset();
58 void chartdataset();
59 void addSeries_data();
59 void addSeries_data();
60 void addSeries();
60 void addSeries();
61 void setAxisX_data();
61 void setAxisX_data();
62 void setAxisX();
62 void setAxisX();
63 void setAxisY_data();
63 void setAxisY_data();
64 void setAxisY();
64 void setAxisY();
65 void removeSeries_data();
65 void removeSeries_data();
66 void removeSeries();
66 void removeSeries();
67 void removeAllSeries_data();
67 void removeAllSeries_data();
68 void removeAllSeries();
68 void removeAllSeries();
69 void seriesCount_data();
69 void seriesCount_data();
70 void seriesCount();
70 void seriesCount();
71 void seriesIndex_data();
71 void seriesIndex_data();
72 void seriesIndex();
72 void seriesIndex();
73 void domain_data();
73 void domain_data();
74 void domain();
74 void domain();
75 void zoomInDomain_data();
75 void zoomInDomain_data();
76 void zoomInDomain();
76 void zoomInDomain();
77 void zoomOutDomain_data();
77 void zoomOutDomain_data();
78 void zoomOutDomain();
78 void zoomOutDomain();
79 void scrollDomain_data();
79 void scrollDomain_data();
80 void scrollDomain();
80 void scrollDomain();
81
81
82 private:
82 private:
83 ChartDataSet* m_dataset;
83 ChartDataSet* m_dataset;
84 };
84 };
85
85
86 void tst_ChartDataSet::initTestCase()
86 void tst_ChartDataSet::initTestCase()
87 {
87 {
88 qRegisterMetaType<Domain*>();
88 qRegisterMetaType<Domain*>();
89 qRegisterMetaType<QAbstractAxis*>();
89 qRegisterMetaType<QAbstractAxis*>();
90 qRegisterMetaType<QAbstractSeries*>();
90 qRegisterMetaType<QAbstractSeries*>();
91 }
91 }
92
92
93 void tst_ChartDataSet::cleanupTestCase()
93 void tst_ChartDataSet::cleanupTestCase()
94 {
94 {
95 }
95 }
96
96
97 void tst_ChartDataSet::init()
97 void tst_ChartDataSet::init()
98 {
98 {
99 m_dataset = new ChartDataSet();
99 m_dataset = new ChartDataSet();
100 }
100 }
101
101
102
102
103 void tst_ChartDataSet::cleanup()
103 void tst_ChartDataSet::cleanup()
104 {
104 {
105 QList<QAbstractSeries*> series = m_dataset->series();
105 QList<QAbstractSeries*> series = m_dataset->series();
106 foreach(QAbstractSeries* serie, series)
106 foreach(QAbstractSeries* serie, series)
107 {
107 {
108 m_dataset->removeSeries(serie);
108 m_dataset->removeSeries(serie);
109 }
109 }
110 }
110 }
111
111
112 void tst_ChartDataSet::chartdataset_data()
112 void tst_ChartDataSet::chartdataset_data()
113 {
113 {
114 }
114 }
115
115
116 void tst_ChartDataSet::chartdataset()
116 void tst_ChartDataSet::chartdataset()
117 {
117 {
118 QVERIFY(m_dataset->axisX(0) == 0);
118 QVERIFY(m_dataset->axisX(0) == 0);
119 QVERIFY(m_dataset->axisY(0) == 0);
119 QVERIFY(m_dataset->axisY(0) == 0);
120 QLineSeries* series = new QLineSeries(this);
120 QLineSeries* series = new QLineSeries(this);
121 QCOMPARE(m_dataset->seriesIndex(series),-1);
121 QCOMPARE(m_dataset->seriesIndex(series),-1);
122 QVERIFY(m_dataset->domain(series) == 0);
122 QVERIFY(m_dataset->domain(series) == 0);
123 QVERIFY(m_dataset->axisX(series) == 0);
123 QVERIFY(m_dataset->axisX(series) == 0);
124 QVERIFY(m_dataset->axisY(series) == 0);
124 QVERIFY(m_dataset->axisY(series) == 0);
125 m_dataset->createDefaultAxes();
125 m_dataset->createDefaultAxes();
126 }
126 }
127
127
128
128
129 void tst_ChartDataSet::addSeries_data()
129 void tst_ChartDataSet::addSeries_data()
130 {
130 {
131 QTest::addColumn<QAbstractSeries*>("series");
131 QTest::addColumn<QAbstractSeries*>("series");
132
132
133 QAbstractSeries* line = new QLineSeries(this);
133 QAbstractSeries* line = new QLineSeries(this);
134 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
134 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
135 QAbstractSeries* scatter = new QScatterSeries(this);
135 QAbstractSeries* scatter = new QScatterSeries(this);
136 QAbstractSeries* spline = new QSplineSeries(this);
136 QAbstractSeries* spline = new QSplineSeries(this);
137 QAbstractSeries* pie = new QPieSeries(this);
137 QAbstractSeries* pie = new QPieSeries(this);
138 QAbstractSeries* bar = new QBarSeries(this);
138 QAbstractSeries* bar = new QBarSeries(this);
139 QAbstractSeries* percent = new QPercentBarSeries(this);
139 QAbstractSeries* percent = new QPercentBarSeries(this);
140 QAbstractSeries* stacked = new QStackedBarSeries(this);
140 QAbstractSeries* stacked = new QStackedBarSeries(this);
141
141
142 QTest::newRow("line") << line;
142 QTest::newRow("line") << line;
143 QTest::newRow("area") << area;
143 QTest::newRow("area") << area;
144 QTest::newRow("scatter") << scatter;
144 QTest::newRow("scatter") << scatter;
145 QTest::newRow("spline") << spline;
145 QTest::newRow("spline") << spline;
146 QTest::newRow("pie") << pie;
146 QTest::newRow("pie") << pie;
147 QTest::newRow("bar") << bar;
147 QTest::newRow("bar") << bar;
148 QTest::newRow("percent") << percent;
148 QTest::newRow("percent") << percent;
149 QTest::newRow("stacked") << stacked;
149 QTest::newRow("stacked") << stacked;
150 }
150 }
151
151
152 void tst_ChartDataSet::addSeries()
152 void tst_ChartDataSet::addSeries()
153 {
153 {
154
154
155 QFETCH(QAbstractSeries*, series);
155 QFETCH(QAbstractSeries*, series);
156
156
157 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
157 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
158 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
158 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
159 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
159 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
160 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
160 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
161
161
162 m_dataset->addSeries(series);
162 m_dataset->addSeries(series);
163 m_dataset->createDefaultAxes();
163 m_dataset->createDefaultAxes();
164 if(series->type()==QAbstractSeries::SeriesTypePie){
164 if(series->type()==QAbstractSeries::SeriesTypePie){
165 TRY_COMPARE(spy0.count(), 0);
165 TRY_COMPARE(spy0.count(), 0);
166 }else{
166 }else{
167 TRY_COMPARE(spy0.count(), 2);
167 TRY_COMPARE(spy0.count(), 2);
168 }
168 }
169 TRY_COMPARE(spy1.count(), 0);
169 TRY_COMPARE(spy1.count(), 0);
170 TRY_COMPARE(spy2.count(), 1);
170 TRY_COMPARE(spy2.count(), 1);
171 TRY_COMPARE(spy3.count(), 0);
171 TRY_COMPARE(spy3.count(), 0);
172 }
172 }
173
173
174
174
175 void tst_ChartDataSet::setAxisX_data()
175 void tst_ChartDataSet::setAxisX_data()
176 {
176 {
177
178 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
177 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
179 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
178 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
180 QTest::addColumn<int>("axisCount");
179 QTest::addColumn<int>("axisCount");
181
180
182 QAbstractSeries* line = new QLineSeries(this);
181 QAbstractSeries* line = new QLineSeries(this);
183 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
182 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
184 QAbstractSeries* scatter = new QScatterSeries(this);
183 QAbstractSeries* scatter = new QScatterSeries(this);
185 QAbstractSeries* spline = new QSplineSeries(this);
184 QAbstractSeries* spline = new QSplineSeries(this);
186 QAbstractSeries* pie = new QPieSeries(this);
185 QAbstractSeries* pie = new QPieSeries(this);
187 QAbstractSeries* bar = new QBarSeries(this);
186 QAbstractSeries* bar = new QBarSeries(this);
188 QAbstractSeries* percent = new QPercentBarSeries(this);
187 QAbstractSeries* percent = new QPercentBarSeries(this);
189 QAbstractSeries* stacked = new QStackedBarSeries(this);
188 QAbstractSeries* stacked = new QStackedBarSeries(this);
190
189
191 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
190 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
192 << (QList<QAbstractSeries*>() << line << spline << scatter)
191 << (QList<QAbstractSeries*>() << line << spline << scatter)
193 << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this) << new QValuesAxis(this)) << 3;
192 << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this) << new QValuesAxis(this)) << 3;
194
193
195 QTest::newRow("area: axis 0") << (QList<QAbstractSeries*>() << area)
194 QTest::newRow("area: axis 0") << (QList<QAbstractSeries*>() << area)
196 << (QList<QAbstractAxis*>() << new QValuesAxis(this)) << 1;
195 << (QList<QAbstractAxis*>() << new QValuesAxis(this)) << 1;
197
196
198 QList<QAbstractAxis*> axes0;
197 QList<QAbstractAxis*> axes0;
199 axes0 << new QValuesAxis(this) << new QValuesAxis(this);
198 axes0 << new QValuesAxis(this) << new QValuesAxis(this);
200 axes0 << axes0.last();
199 axes0 << axes0.last();
201 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 1")
200 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 1")
202 << (QList<QAbstractSeries*>() << line << spline << scatter)
201 << (QList<QAbstractSeries*>() << line << spline << scatter)
203 << axes0 << 2;
202 << axes0 << 2;
204 //TODO: add more test cases
203 //TODO: add more test cases
205 }
204 }
206
205
207 void tst_ChartDataSet::setAxisX()
206 void tst_ChartDataSet::setAxisX()
208 {
207 {
209 QFETCH(QList<QAbstractSeries*>, seriesList);
208 QFETCH(QList<QAbstractSeries*>, seriesList);
210 QFETCH(QList<QAbstractAxis*>, axisList);
209 QFETCH(QList<QAbstractAxis*>, axisList);
211 QFETCH(int, axisCount);
210 QFETCH(int, axisCount);
212
211
213 Q_ASSERT(seriesList.count() == axisList.count());
212 Q_ASSERT(seriesList.count() == axisList.count());
214
213
215 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
214 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
216 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
215 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
217 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
216 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
218 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
217 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
219
218
220 foreach(QAbstractSeries* series, seriesList){
219 foreach(QAbstractSeries* series, seriesList){
221 m_dataset->addSeries(series);
220 m_dataset->addSeries(series);
222 }
221 }
223
222
224 TRY_COMPARE(spy0.count(), 0);
223 TRY_COMPARE(spy0.count(), 0);
225 TRY_COMPARE(spy1.count(), 0);
224 TRY_COMPARE(spy1.count(), 0);
226 TRY_COMPARE(spy2.count(), seriesList.count());
225 TRY_COMPARE(spy2.count(), seriesList.count());
227 TRY_COMPARE(spy3.count(), 0);
226 TRY_COMPARE(spy3.count(), 0);
228
227
229 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
228 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
230 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
229 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
231 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
230 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
232 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
231 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
233
232
234 for(int i=0 ; i < seriesList.count(); i++){
233 for(int i=0 ; i < seriesList.count(); i++){
235 m_dataset->setAxisX(seriesList.at(i),axisList.at(i));
234 m_dataset->setAxisX(seriesList.at(i),axisList.at(i));
236 }
235 }
237
236
238 TRY_COMPARE(spy4.count(), axisCount);
237 TRY_COMPARE(spy4.count(), axisCount);
239 TRY_COMPARE(spy5.count(), 0);
238 TRY_COMPARE(spy5.count(), 0);
240 TRY_COMPARE(spy6.count(), 0);
239 TRY_COMPARE(spy6.count(), 0);
241 TRY_COMPARE(spy7.count(), 0);
240 TRY_COMPARE(spy7.count(), 0);
242
241
243 for(int i=0 ; i < seriesList.count(); i++){
242 for(int i=0 ; i < seriesList.count(); i++){
244 QVERIFY(m_dataset->axisX(seriesList.at(i)) == axisList.at(i));
243 QVERIFY(m_dataset->axisX(seriesList.at(i)) == axisList.at(i));
245 }
244 }
246 }
245 }
247
246
248 void tst_ChartDataSet::setAxisY_data()
247 void tst_ChartDataSet::setAxisY_data()
249 {
248 {
250 setAxisX_data();
249 setAxisX_data();
251 }
250 }
252
251
253 void tst_ChartDataSet::setAxisY()
252 void tst_ChartDataSet::setAxisY()
254 {
253 {
255 QFETCH(QList<QAbstractSeries*>, seriesList);
254 QFETCH(QList<QAbstractSeries*>, seriesList);
256 QFETCH(QList<QAbstractAxis*>, axisList);
255 QFETCH(QList<QAbstractAxis*>, axisList);
257 QFETCH(int, axisCount);
256 QFETCH(int, axisCount);
258
257
259 Q_ASSERT(seriesList.count() == axisList.count());
258 Q_ASSERT(seriesList.count() == axisList.count());
260
259
261 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
260 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
262 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
261 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
263 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
262 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
264 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
263 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
265
264
266 foreach(QAbstractSeries* series, seriesList){
265 foreach(QAbstractSeries* series, seriesList){
267 m_dataset->addSeries(series);
266 m_dataset->addSeries(series);
268 }
267 }
269
268
270 TRY_COMPARE(spy0.count(), 0);
269 TRY_COMPARE(spy0.count(), 0);
271 TRY_COMPARE(spy1.count(), 0);
270 TRY_COMPARE(spy1.count(), 0);
272 TRY_COMPARE(spy2.count(), seriesList.count());
271 TRY_COMPARE(spy2.count(), seriesList.count());
273 TRY_COMPARE(spy3.count(), 0);
272 TRY_COMPARE(spy3.count(), 0);
274
273
275 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
274 QSignalSpy spy4(m_dataset, SIGNAL(axisAdded(QAbstractAxis*,Domain*)));
276 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
275 QSignalSpy spy5(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
277 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
276 QSignalSpy spy6(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
278 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
277 QSignalSpy spy7(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
279
278
280 for(int i=0 ; i < seriesList.count(); i++){
279 for(int i=0 ; i < seriesList.count(); i++){
281 m_dataset->setAxisY(seriesList.at(i),axisList.at(i));
280 m_dataset->setAxisY(seriesList.at(i),axisList.at(i));
282 }
281 }
283
282
284 TRY_COMPARE(spy4.count(), axisCount);
283 TRY_COMPARE(spy4.count(), axisCount);
285 TRY_COMPARE(spy5.count(), 0);
284 TRY_COMPARE(spy5.count(), 0);
286 TRY_COMPARE(spy6.count(), 0);
285 TRY_COMPARE(spy6.count(), 0);
287 TRY_COMPARE(spy7.count(), 0);
286 TRY_COMPARE(spy7.count(), 0);
288
287
289 for(int i=0 ; i < seriesList.count(); i++){
288 for(int i=0 ; i < seriesList.count(); i++){
290 QVERIFY(m_dataset->axisY(seriesList.at(i)) == axisList.at(i));
289 QVERIFY(m_dataset->axisY(seriesList.at(i)) == axisList.at(i));
291 }
290 }
292 }
291 }
293
292
294 void tst_ChartDataSet::removeSeries_data()
293 void tst_ChartDataSet::removeSeries_data()
295 {
294 {
296 addSeries_data();
295 addSeries_data();
297 }
296 }
298
297
299 void tst_ChartDataSet::removeSeries()
298 void tst_ChartDataSet::removeSeries()
300 {
299 {
301 QFETCH(QAbstractSeries*, series);
300 QFETCH(QAbstractSeries*, series);
302
301
303 m_dataset->addSeries(series);
302 m_dataset->addSeries(series);
304 m_dataset->createDefaultAxes();
303 m_dataset->createDefaultAxes();
305
304
306 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
305 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*, Domain *)));
307 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
306 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
308 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
307 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
309 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
308 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
310
309
311 m_dataset->removeSeries(series);
310 m_dataset->removeSeries(series);
312
311
313 TRY_COMPARE(spy0.count(), 0);
312 TRY_COMPARE(spy0.count(), 0);
314 if (series->type() == QAbstractSeries::SeriesTypePie) {
313 if (series->type() == QAbstractSeries::SeriesTypePie) {
315 TRY_COMPARE(spy1.count(), 0);
314 TRY_COMPARE(spy1.count(), 0);
316 }
315 }
317 else {
316 else {
318 TRY_COMPARE(spy1.count(), 2);
317 TRY_COMPARE(spy1.count(), 2);
319 }
318 }
320 TRY_COMPARE(spy2.count(), 0);
319 TRY_COMPARE(spy2.count(), 0);
321 TRY_COMPARE(spy3.count(), 1);
320 TRY_COMPARE(spy3.count(), 1);
322 }
321 }
323
322
324 void tst_ChartDataSet::removeAllSeries_data()
323 void tst_ChartDataSet::removeAllSeries_data()
325 {
324 {
326 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
325 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
327 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
326 QTest::addColumn<QList<QAbstractAxis*> >("axisList");
328 QTest::addColumn<int>("axisCount");
327 QTest::addColumn<int>("axisCount");
329
328
330 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
329 QTest::newRow("line,spline,scatter: axis 0 axis1 axis 2")
331 << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QSplineSeries(this)
330 << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QSplineSeries(this)
332 << new QScatterSeries(this))
331 << new QScatterSeries(this))
333 << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this)
332 << (QList<QAbstractAxis*>() << new QValuesAxis(this) << new QValuesAxis(this)
334 << new QValuesAxis(this)) << 3;
333 << new QValuesAxis(this)) << 3;
335 //TODO:
334 //TODO:
336 }
335 }
337
336
338 void tst_ChartDataSet::removeAllSeries()
337 void tst_ChartDataSet::removeAllSeries()
339 {
338 {
340 QFETCH(QList<QAbstractSeries*>, seriesList);
339 QFETCH(QList<QAbstractSeries*>, seriesList);
341 QFETCH(QList<QAbstractAxis*>, axisList);
340 QFETCH(QList<QAbstractAxis*>, axisList);
342 QFETCH(int, axisCount);
341 QFETCH(int, axisCount);
343
342
344 foreach(QAbstractSeries* series, seriesList) {
343 foreach(QAbstractSeries* series, seriesList) {
345 m_dataset->addSeries(series);
344 m_dataset->addSeries(series);
346 }
345 }
347
346
348 for (int i = 0; i < seriesList.count(); i++) {
347 for (int i = 0; i < seriesList.count(); i++) {
349 m_dataset->setAxisX(seriesList.at(i), axisList.at(i));
348 m_dataset->setAxisX(seriesList.at(i), axisList.at(i));
350 }
349 }
351
350
352 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
351 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
353 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
352 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
354 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
353 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
355 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
354 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
356
355
357 m_dataset->removeAllSeries();
356 m_dataset->removeAllSeries();
358
357
359 TRY_COMPARE(spy0.count(), 0);
358 TRY_COMPARE(spy0.count(), 0);
360 TRY_COMPARE(spy1.count(), axisCount);
359 TRY_COMPARE(spy1.count(), axisCount);
361 TRY_COMPARE(spy2.count(), 0);
360 TRY_COMPARE(spy2.count(), 0);
362 TRY_COMPARE(spy3.count(), seriesList.count());
361 TRY_COMPARE(spy3.count(), seriesList.count());
363 }
362 }
364
363
365
364
366 void tst_ChartDataSet::seriesCount_data()
365 void tst_ChartDataSet::seriesCount_data()
367 {
366 {
368 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
367 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
369 QTest::addColumn<int>("seriesCount");
368 QTest::addColumn<int>("seriesCount");
370
369
371 QTest::newRow("line,line, line, spline 3") << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) ) << 3;
370 QTest::newRow("line,line, line, spline 3") << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) ) << 3;
372 QTest::newRow("scatter,scatter, line, line 2") << (QList<QAbstractSeries*>() << new QScatterSeries(this) << new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) ) << 2;
371 QTest::newRow("scatter,scatter, line, line 2") << (QList<QAbstractSeries*>() << new QScatterSeries(this) << new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) ) << 2;
373 }
372 }
374
373
375 void tst_ChartDataSet::seriesCount()
374 void tst_ChartDataSet::seriesCount()
376 {
375 {
377 QFETCH(QList<QAbstractSeries*>, seriesList);
376 QFETCH(QList<QAbstractSeries*>, seriesList);
378 QFETCH(int, seriesCount);
377 QFETCH(int, seriesCount);
379
378
380 foreach(QAbstractSeries* series, seriesList){
379 foreach(QAbstractSeries* series, seriesList){
381 m_dataset->addSeries(series);
380 m_dataset->addSeries(series);
382 }
381 }
383
382
384 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
383 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
385 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
384 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
386 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
385 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
387 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
386 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
388
387
389 QCOMPARE(m_dataset->seriesCount(seriesList.at(0)->type()),seriesCount);
388 QCOMPARE(m_dataset->seriesCount(seriesList.at(0)->type()),seriesCount);
390 TRY_COMPARE(spy0.count(), 0);
389 TRY_COMPARE(spy0.count(), 0);
391 TRY_COMPARE(spy1.count(), 0);
390 TRY_COMPARE(spy1.count(), 0);
392 TRY_COMPARE(spy2.count(), 0);
391 TRY_COMPARE(spy2.count(), 0);
393 TRY_COMPARE(spy3.count(), 0);
392 TRY_COMPARE(spy3.count(), 0);
394 }
393 }
395
394
396 void tst_ChartDataSet::seriesIndex_data()
395 void tst_ChartDataSet::seriesIndex_data()
397 {
396 {
398 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
397 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
399
398
400 QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
399 QTest::newRow("line,line, line, spline") << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
401 QTest::newRow("scatter,scatter, line, line") << (QList<QAbstractSeries*>() << new QScatterSeries(this) << new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) );
400 QTest::newRow("scatter,scatter, line, line") << (QList<QAbstractSeries*>() << new QScatterSeries(this) << new QScatterSeries(this) << new QLineSeries(this) << new QLineSeries(this) );
402 }
401 }
403
402
404 void tst_ChartDataSet::seriesIndex()
403 void tst_ChartDataSet::seriesIndex()
405 {
404 {
406
405
407 QFETCH(QList<QAbstractSeries*>, seriesList);
406 QFETCH(QList<QAbstractSeries*>, seriesList);
408
407
409 foreach(QAbstractSeries* series, seriesList) {
408 foreach(QAbstractSeries* series, seriesList) {
410 m_dataset->addSeries(series);
409 m_dataset->addSeries(series);
411 }
410 }
412
411
413 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
412 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *,Domain*)));
414 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
413 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
415 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*,Domain*)));
414 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*,Domain*)));
416 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
415 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
417
416
418 for (int i = 0; i < seriesList.count(); i++) {
417 for (int i = 0; i < seriesList.count(); i++) {
419 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
418 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
420 }
419 }
421
420
422 TRY_COMPARE(spy0.count(), 0);
421 TRY_COMPARE(spy0.count(), 0);
423 TRY_COMPARE(spy1.count(), 0);
422 TRY_COMPARE(spy1.count(), 0);
424 TRY_COMPARE(spy2.count(), 0);
423 TRY_COMPARE(spy2.count(), 0);
425 TRY_COMPARE(spy3.count(), 0);
424 TRY_COMPARE(spy3.count(), 0);
426
425
427 foreach(QAbstractSeries* series, seriesList) {
426 foreach(QAbstractSeries* series, seriesList) {
428 m_dataset->removeSeries(series);
427 m_dataset->removeSeries(series);
429 }
428 }
430
429
431 for (int i = 0; i < seriesList.count(); i++) {
430 for (int i = 0; i < seriesList.count(); i++) {
432 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
431 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
433 }
432 }
434
433
435 foreach(QAbstractSeries* series, seriesList) {
434 foreach(QAbstractSeries* series, seriesList) {
436 m_dataset->addSeries(series);
435 m_dataset->addSeries(series);
437 }
436 }
438
437
439 for (int i = 0; i < seriesList.count(); i++) {
438 for (int i = 0; i < seriesList.count(); i++) {
440 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
439 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
441 }
440 }
442
441
443 m_dataset->removeSeries(seriesList.at(1));
442 m_dataset->removeSeries(seriesList.at(1));
444
443
445 for (int i = 0; i < seriesList.count(); i++) {
444 for (int i = 0; i < seriesList.count(); i++) {
446 if (i != 1)
445 if (i != 1)
447 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
446 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
448 else
447 else
449 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
448 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
450 }
449 }
451
450
452 m_dataset->addSeries(seriesList.at(1));
451 m_dataset->addSeries(seriesList.at(1));
453
452
454 for (int i = 0; i < seriesList.count(); i++) {
453 for (int i = 0; i < seriesList.count(); i++) {
455 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
454 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
456 }
455 }
457
456
458 m_dataset->removeSeries(seriesList.at(2));
457 m_dataset->removeSeries(seriesList.at(2));
459
458
460 for (int i = 0; i < seriesList.count(); i++) {
459 for (int i = 0; i < seriesList.count(); i++) {
461 if (i != 2)
460 if (i != 2)
462 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
461 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
463 else
462 else
464 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
463 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
465 }
464 }
466
465
467 m_dataset->removeSeries(seriesList.at(0));
466 m_dataset->removeSeries(seriesList.at(0));
468
467
469 for (int i = 0; i < seriesList.count(); i++) {
468 for (int i = 0; i < seriesList.count(); i++) {
470 if (i != 2 && i != 0)
469 if (i != 2 && i != 0)
471 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
470 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
472 else
471 else
473 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
472 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), -1);
474 }
473 }
475
474
476 m_dataset->addSeries(seriesList.at(2));
475 m_dataset->addSeries(seriesList.at(2));
477 m_dataset->addSeries(seriesList.at(0));
476 m_dataset->addSeries(seriesList.at(0));
478
477
479 for (int i = 0; i < seriesList.count(); i++) {
478 for (int i = 0; i < seriesList.count(); i++) {
480 if (i == 2)
479 if (i == 2)
481 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 0);
480 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 0);
482 else if (i == 0)
481 else if (i == 0)
483 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 2);
482 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), 2);
484 else
483 else
485 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
484 QCOMPARE(m_dataset->seriesIndex(seriesList.at(i)), i);
486 }
485 }
487
486
488 }
487 }
489
488
490 void tst_ChartDataSet::domain_data()
489 void tst_ChartDataSet::domain_data()
491 {
490 {
492 addSeries_data();
491 addSeries_data();
493 }
492 }
494
493
495 void tst_ChartDataSet::domain()
494 void tst_ChartDataSet::domain()
496 {
495 {
497 QFETCH(QAbstractSeries*, series);
496 QFETCH(QAbstractSeries*, series);
498
497
499 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
498 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis *, Domain *)));
500 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
499 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis *)));
501 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
500 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
502 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
501 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries *)));
503
502
504 m_dataset->addSeries(series);
503 m_dataset->addSeries(series);
505 QVERIFY(m_dataset->domain(series));
504 QVERIFY(m_dataset->domain(series));
506
505
507
506
508 TRY_COMPARE(spy0.count(), 0);
507 TRY_COMPARE(spy0.count(), 0);
509 TRY_COMPARE(spy1.count(), 0);
508 TRY_COMPARE(spy1.count(), 0);
510 TRY_COMPARE(spy2.count(), 1);
509 TRY_COMPARE(spy2.count(), 1);
511
510
512 QList<QVariant> arguments = spy2.takeFirst();
511 QList<QVariant> arguments = spy2.takeFirst();
513 Domain *domain = (Domain *) arguments.at(1).value<Domain *>();
512 Domain *domain = (Domain *) arguments.at(1).value<Domain *>();
514 QVERIFY(m_dataset->domain(series) == domain);
513 QVERIFY(m_dataset->domain(series) == domain);
515
514
516 TRY_COMPARE(spy3.count(), 0);
515 TRY_COMPARE(spy3.count(), 0);
517
516
518 }
517 }
519
518
520 void tst_ChartDataSet::zoomInDomain_data()
519 void tst_ChartDataSet::zoomInDomain_data()
521 {
520 {
522 QTest::addColumn<bool >("sameAxis");
521 QTest::addColumn<bool >("sameAxis");
523 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
522 QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
524 QTest::newRow("sameAxis: line,line, line, spline") << true << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
523 QTest::newRow("sameAxis: line,line, line, spline") << true << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
525 QTest::newRow("separeateAxis: line,line, line, spline") << false << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
524 QTest::newRow("separeateAxis: line,line, line, spline") << false << (QList<QAbstractSeries*>() << new QLineSeries(this) << new QLineSeries(this) << new QLineSeries(this) << new QSplineSeries(this) );
526 }
525 }
527
526
528 void tst_ChartDataSet::zoomInDomain()
527 void tst_ChartDataSet::zoomInDomain()
529 {
528 {
530 QFETCH(bool, sameAxis);
529 QFETCH(bool, sameAxis);
531 QFETCH(QList<QAbstractSeries*>, seriesList);
530 QFETCH(QList<QAbstractSeries*>, seriesList);
532
531
533 foreach(QAbstractSeries* series, seriesList) {
532 foreach(QAbstractSeries* series, seriesList) {
534 m_dataset->addSeries(series);
533 m_dataset->addSeries(series);
535 }
534 }
536
535
537 if(sameAxis) m_dataset->createDefaultAxes();
536 if(sameAxis) m_dataset->createDefaultAxes();
538
537
539 QList<QSignalSpy*> spyList;
538 QList<QSignalSpy*> spyList;
540
539
541 foreach(QAbstractSeries* series, seriesList) {
540 foreach(QAbstractSeries* series, seriesList) {
542 spyList << new QSignalSpy(m_dataset->domain(series),SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
541 spyList << new QSignalSpy(m_dataset->domain(series),SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
543 }
542 }
544
543
545 m_dataset->zoomInDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
544 m_dataset->zoomInDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
546
545
547 foreach(QSignalSpy* spy, spyList) {
546 foreach(QSignalSpy* spy, spyList) {
548 TRY_COMPARE(spy->count(), 1);
547 TRY_COMPARE(spy->count(), 1);
549 }
548 }
550
549
551 qDeleteAll(spyList);
550 qDeleteAll(spyList);
552 }
551 }
553
552
554
553
555
554
556 void tst_ChartDataSet::zoomOutDomain_data()
555 void tst_ChartDataSet::zoomOutDomain_data()
557 {
556 {
558 zoomInDomain_data();
557 zoomInDomain_data();
559 }
558 }
560
559
561 void tst_ChartDataSet::zoomOutDomain()
560 void tst_ChartDataSet::zoomOutDomain()
562 {
561 {
563 QFETCH(bool, sameAxis);
562 QFETCH(bool, sameAxis);
564 QFETCH(QList<QAbstractSeries*>, seriesList);
563 QFETCH(QList<QAbstractSeries*>, seriesList);
565
564
566 foreach(QAbstractSeries* series, seriesList) {
565 foreach(QAbstractSeries* series, seriesList) {
567 m_dataset->addSeries(series);
566 m_dataset->addSeries(series);
568 }
567 }
569
568
570 if (sameAxis)
569 if (sameAxis)
571 m_dataset->createDefaultAxes();
570 m_dataset->createDefaultAxes();
572
571
573 QList<QSignalSpy*> spyList;
572 QList<QSignalSpy*> spyList;
574
573
575 foreach(QAbstractSeries* series, seriesList) {
574 foreach(QAbstractSeries* series, seriesList) {
576 spyList << new QSignalSpy(m_dataset->domain(series), SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
575 spyList << new QSignalSpy(m_dataset->domain(series), SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
577 }
576 }
578
577
579 m_dataset->zoomOutDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
578 m_dataset->zoomOutDomain(QRect(0, 0, 100, 100), QSize(1000, 1000));
580
579
581 foreach(QSignalSpy* spy, spyList) {
580 foreach(QSignalSpy* spy, spyList) {
582 TRY_COMPARE(spy->count(), 1);
581 TRY_COMPARE(spy->count(), 1);
583 }
582 }
584
583
585 qDeleteAll (spyList);
584 qDeleteAll (spyList);
586 }
585 }
587
586
588 void tst_ChartDataSet::scrollDomain_data()
587 void tst_ChartDataSet::scrollDomain_data()
589 {
588 {
590 zoomInDomain_data();
589 zoomInDomain_data();
591 }
590 }
592
591
593 void tst_ChartDataSet::scrollDomain()
592 void tst_ChartDataSet::scrollDomain()
594 {
593 {
595 QFETCH(bool, sameAxis);
594 QFETCH(bool, sameAxis);
596 QFETCH(QList<QAbstractSeries*>, seriesList);
595 QFETCH(QList<QAbstractSeries*>, seriesList);
597
596
598 foreach(QAbstractSeries* series, seriesList) {
597 foreach(QAbstractSeries* series, seriesList) {
599 m_dataset->addSeries(series);
598 m_dataset->addSeries(series);
600 }
599 }
601
600
602 if (sameAxis)
601 if (sameAxis)
603 m_dataset->createDefaultAxes();
602 m_dataset->createDefaultAxes();
604
603
605 QList<QSignalSpy*> spyList;
604 QList<QSignalSpy*> spyList;
606
605
607 foreach(QAbstractSeries* series, seriesList) {
606 foreach(QAbstractSeries* series, seriesList) {
608 spyList
607 spyList
609 << new QSignalSpy(m_dataset->domain(series),
608 << new QSignalSpy(m_dataset->domain(series),
610 SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
609 SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
611 }
610 }
612
611
613 m_dataset->scrollDomain(10, 10, QSize(1000, 1000));
612 m_dataset->scrollDomain(10, 10, QSize(1000, 1000));
614
613
615 foreach(QSignalSpy* spy, spyList) {
614 foreach(QSignalSpy* spy, spyList) {
616 TRY_COMPARE(spy->count(), 1);
615 TRY_COMPARE(spy->count(), 1);
617 }
616 }
618
617
619 qDeleteAll(spyList);
618 qDeleteAll(spyList);
620 }
619 }
621
620
622 QTEST_MAIN(tst_ChartDataSet)
621 QTEST_MAIN(tst_ChartDataSet)
623 #include "tst_chartdataset.moc"
622 #include "tst_chartdataset.moc"
624
623
Show file before | Show file after | Hide comments
@@ -1,615 +1,791
1 /****************************************************************************
1 /****************************************************************************
2 **
2 **
3 ** Copyright (C) 2012 Digia Plc
3 ** Copyright (C) 2012 Digia Plc
4 ** All rights reserved.
4 ** All rights reserved.
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 **
6 **
7 ** This file is part of the Qt Commercial Charts Add-on.
7 ** This file is part of the Qt Commercial Charts Add-on.
8 **
8 **
9 ** $QT_BEGIN_LICENSE$
9 ** $QT_BEGIN_LICENSE$
10 ** Licensees holding valid Qt Commercial licenses may use this file in
10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 ** accordance with the Qt Commercial License Agreement provided with the
11 ** accordance with the Qt Commercial License Agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.
13 ** a written agreement between you and Digia.
14 **
14 **
15 ** If you have questions regarding the use of this file, please use
15 ** If you have questions regarding the use of this file, please use
16 ** contact form at http://qt.digia.com
16 ** contact form at http://qt.digia.com
17 ** $QT_END_LICENSE$
17 ** $QT_END_LICENSE$
18 **
18 **
19 ****************************************************************************/
19 ****************************************************************************/
20
20
21 #include <QtTest/QtTest>
21 #include <QtTest/QtTest>
22 #include <qchartview.h>
22 #include <qchartview.h>
23 #include <qlineseries.h>
23 #include <qlineseries.h>
24 #include <qareaseries.h>
24 #include <qareaseries.h>
25 #include <qscatterseries.h>
25 #include <qscatterseries.h>
26 #include <qsplineseries.h>
26 #include <qsplineseries.h>
27 #include <qpieseries.h>
27 #include <qpieseries.h>
28 #include <qabstractbarseries.h>
28 #include <qabstractbarseries.h>
29 #include <qbarseries.h>
29 #include <qbarseries.h>
30 #include <qpercentbarseries.h>
30 #include <qpercentbarseries.h>
31 #include <qstackedbarseries.h>
31 #include <qstackedbarseries.h>
32 #include <qvaluesaxis.h>
32 #include <qvaluesaxis.h>
33 #include <qbarcategoriesaxis.h>
33
34
34 QTCOMMERCIALCHART_USE_NAMESPACE
35 QTCOMMERCIALCHART_USE_NAMESPACE
35
36
36 Q_DECLARE_METATYPE(QAbstractAxis *)
37 Q_DECLARE_METATYPE(QAbstractAxis *)
37 Q_DECLARE_METATYPE(QValuesAxis *)
38 Q_DECLARE_METATYPE(QValuesAxis *)
39 Q_DECLARE_METATYPE(QBarCategoriesAxis *)
38 Q_DECLARE_METATYPE(QAbstractSeries *)
40 Q_DECLARE_METATYPE(QAbstractSeries *)
39 Q_DECLARE_METATYPE(QChart::AnimationOption)
41 Q_DECLARE_METATYPE(QChart::AnimationOption)
40 Q_DECLARE_METATYPE(QBrush)
42 Q_DECLARE_METATYPE(QBrush)
41 Q_DECLARE_METATYPE(QPen)
43 Q_DECLARE_METATYPE(QPen)
42 Q_DECLARE_METATYPE(QChart::ChartTheme)
44 Q_DECLARE_METATYPE(QChart::ChartTheme)
43
45
44 class tst_QChart : public QObject
46 class tst_QChart : public QObject
45 {
47 {
46 Q_OBJECT
48 Q_OBJECT
47
49
48 public slots:
50 public slots:
49 void initTestCase();
51 void initTestCase();
50 void cleanupTestCase();
52 void cleanupTestCase();
51 void init();
53 void init();
52 void cleanup();
54 void cleanup();
53
55
54 private slots:
56 private slots:
55 void qchart_data();
57 void qchart_data();
56 void qchart();
58 void qchart();
57
58 void addSeries_data();
59 void addSeries_data();
59 void addSeries();
60 void addSeries();
60 void animationOptions_data();
61 void animationOptions_data();
61 void animationOptions();
62 void animationOptions();
62 void axisX_data();
63 void axisX_data();
63 void axisX();
64 void axisX();
64 void axisY_data();
65 void axisY_data();
65 void axisY();
66 void axisY();
66 void backgroundBrush_data();
67 void backgroundBrush_data();
67 void backgroundBrush();
68 void backgroundBrush();
68 void backgroundPen_data();
69 void backgroundPen_data();
69 void backgroundPen();
70 void backgroundPen();
70 void isBackgroundVisible_data();
71 void isBackgroundVisible_data();
71 void isBackgroundVisible();
72 void isBackgroundVisible();
72 void legend_data();
73 void legend_data();
73 void legend();
74 void legend();
74 void margins_data();
75 void margins_data();
75 void margins();
76 void margins();
76 void removeAllSeries_data();
77 void removeAllSeries_data();
77 void removeAllSeries();
78 void removeAllSeries();
78 void removeSeries_data();
79 void removeSeries_data();
79 void removeSeries();
80 void removeSeries();
80 void scroll_data();
81 void scroll_right_data();
81 void scroll();
82 void scroll_right();
83 void scroll_left_data();
84 void scroll_left();
85 void scroll_up_data();
86 void scroll_up();
87 void scroll_down_data();
88 void scroll_down();
82 void theme_data();
89 void theme_data();
83 void theme();
90 void theme();
84 void title_data();
91 void title_data();
85 void title();
92 void title();
86 void titleBrush_data();
93 void titleBrush_data();
87 void titleBrush();
94 void titleBrush();
88 void titleFont_data();
95 void titleFont_data();
89 void titleFont();
96 void titleFont();
90 void zoomIn_data();
97 void zoomIn_data();
91 void zoomIn();
98 void zoomIn();
92 void zoomOut_data();
99 void zoomOut_data();
93 void zoomOut();
100 void zoomOut();
94
101
95 private:
102 private:
96 void createTestData();
103 void createTestData();
97
104
98 private:
105 private:
99 QChartView* m_view;
106 QChartView* m_view;
100 QChart* m_chart;
107 QChart* m_chart;
101 };
108 };
102
109
103 void tst_QChart::initTestCase()
110 void tst_QChart::initTestCase()
104 {
111 {
105
112
106 }
113 }
107
114
108 void tst_QChart::cleanupTestCase()
115 void tst_QChart::cleanupTestCase()
109 {
116 {
110
117
111 }
118 }
112
119
113 void tst_QChart::init()
120 void tst_QChart::init()
114 {
121 {
115 m_view = new QChartView(new QChart());
122 m_view = new QChartView(new QChart());
116 m_chart = m_view->chart();
123 m_chart = m_view->chart();
117 }
124 }
118
125
126 void tst_QChart::cleanup()
127 {
128 delete m_view;
129 m_view = 0;
130 m_chart = 0;
131 }
132
133
119 void tst_QChart::createTestData()
134 void tst_QChart::createTestData()
120 {
135 {
121 QLineSeries* series0 = new QLineSeries(this);
136 QLineSeries* series0 = new QLineSeries(this);
122 *series0 << QPointF(0, 0) << QPointF(100, 100);
137 *series0 << QPointF(0, 0) << QPointF(100, 100);
123 m_chart->addSeries(series0);
138 m_chart->addSeries(series0);
124 m_view->show();
139 m_view->show();
125 QTest::qWaitForWindowShown(m_view);
140 QTest::qWaitForWindowShown(m_view);
126 }
141 }
127
142
128 void tst_QChart::cleanup()
129 {
130 delete m_view;
131 m_view = 0;
132 m_chart = 0;
133 }
134
135 void tst_QChart::qchart_data()
143 void tst_QChart::qchart_data()
136 {
144 {
137 }
145 }
138
146
139 void tst_QChart::qchart()
147 void tst_QChart::qchart()
140 {
148 {
141 QVERIFY(m_chart);
149 QVERIFY(m_chart);
142 QVERIFY(m_chart->legend());
150 QVERIFY(m_chart->legend());
143 QVERIFY(m_chart->legend()->isVisible());
151 QVERIFY(m_chart->legend()->isVisible());
144
152
145 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
153 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
146 QVERIFY(m_chart->axisX());
154 QVERIFY(!m_chart->axisX());
147 QVERIFY(m_chart->axisY());
155 QVERIFY(!m_chart->axisY());
148 QVERIFY(m_chart->backgroundBrush()!=QBrush());
156 QVERIFY(m_chart->backgroundBrush()!=QBrush());
149 QVERIFY(m_chart->backgroundPen()!=QPen());
157 QVERIFY(m_chart->backgroundPen()!=QPen());
150 QCOMPARE(m_chart->isBackgroundVisible(), true);
158 QCOMPARE(m_chart->isBackgroundVisible(), true);
151
159
152 QVERIFY(m_chart->margins().top()>0);
160 QVERIFY(m_chart->margins().top()>0);
153 QVERIFY(m_chart->margins().left()>0);
161 QVERIFY(m_chart->margins().left()>0);
154 QVERIFY(m_chart->margins().right()>0);
162 QVERIFY(m_chart->margins().right()>0);
155 QVERIFY(m_chart->margins().bottom()>0);
163 QVERIFY(m_chart->margins().bottom()>0);
156
164
157 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
165 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
158 QCOMPARE(m_chart->title(), QString());
166 QCOMPARE(m_chart->title(), QString());
159
167
160 //QCOMPARE(m_chart->titleBrush(),QBrush());
168 //QCOMPARE(m_chart->titleBrush(),QBrush());
161 //QCOMPARE(m_chart->titleFont(),QFont());
169 //QCOMPARE(m_chart->titleFont(),QFont());
162
170
163 m_chart->removeAllSeries();
171 m_chart->removeAllSeries();
164 m_chart->scroll(0,0);
172 m_chart->scroll(0,0);
165
173
166 m_chart->zoomIn();
174 m_chart->zoomIn();
167 m_chart->zoomIn(QRectF());
175 m_chart->zoomIn(QRectF());
168 m_chart->zoomOut();
176 m_chart->zoomOut();
169 }
177 }
170
178
171 void tst_QChart::addSeries_data()
179 void tst_QChart::addSeries_data()
172 {
180 {
173 QTest::addColumn<QAbstractSeries *>("series");
181 QTest::addColumn<QAbstractSeries *>("series");
174 QTest::addColumn<QAbstractAxis *>("axis");
175
182
176 QAbstractSeries* series0 = new QLineSeries(this);
183 QAbstractSeries* line = new QLineSeries(this);
177 QAbstractSeries* series1 = new QAreaSeries(static_cast<QLineSeries*>(series0));
184 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
178 QAbstractSeries* series2 = new QScatterSeries(this);
185 QAbstractSeries* scatter = new QScatterSeries(this);
179 QAbstractSeries* series3 = new QSplineSeries(this);
186 QAbstractSeries* spline = new QSplineSeries(this);
180 QAbstractSeries* series4 = new QPieSeries(this);
187 QAbstractSeries* pie = new QPieSeries(this);
181 QAbstractSeries* series5 = new QBarSeries(this);
188 QAbstractSeries* bar = new QBarSeries(this);
182 QAbstractSeries* series6 = new QPercentBarSeries(this);
189 QAbstractSeries* percent = new QPercentBarSeries(this);
183 QAbstractSeries* series7 = new QStackedBarSeries(this);
190 QAbstractSeries* stacked = new QStackedBarSeries(this);
184
191
185 QValuesAxis* axis = new QValuesAxis(this);
192 QTest::newRow("lineSeries") << line;
186
193 QTest::newRow("areaSeries") << area;
187 QTest::newRow("default axis: lineSeries") << series0 << (QAbstractAxis*) 0;
194 QTest::newRow("scatterSeries") << scatter;
188 QTest::newRow("axis0: lineSeries") << series0 << axis;
195 QTest::newRow("splineSeries") << spline;
189 QTest::newRow("default axis: areaSeries") << series1 << (QAbstractAxis*) 0;
196 QTest::newRow("pieSeries") << pie;
190 QTest::newRow("axis: areaSeries") << series1 << axis;
197 QTest::newRow("barSeries") << bar;
191 QTest::newRow("default axis: scatterSeries") << series2 << (QAbstractAxis*) 0;
198 QTest::newRow("percentBarSeries") << percent;
192 QTest::newRow("axis1: scatterSeries") << series2 << axis;
199 QTest::newRow("stackedBarSeries") << stacked;
193 QTest::newRow("default axis: splineSeries") << series3 << (QAbstractAxis*) 0;
194 QTest::newRow("axis: splineSeries") << series3 << axis;
195 QTest::newRow("default axis: pieSeries") << series4 << (QAbstractAxis*) 0;
196 QTest::newRow("axis: pieSeries") << series4 << axis;
197 QTest::newRow("default axis: barSeries") << series5 << (QAbstractAxis*) 0;
198 QTest::newRow("axis: barSeries") << series5 << axis;
199 QTest::newRow("default axis: percentBarSeries") << series6 << (QAbstractAxis*) 0;
200 QTest::newRow("axis: barSeries") << series6 << axis;
201 QTest::newRow("default axis: stackedBarSeries") << series7 << (QAbstractAxis*) 0;
202 QTest::newRow("axis: barSeries") << series7 << axis;
203
200
204 }
201 }
205
202
206 void tst_QChart::addSeries()
203 void tst_QChart::addSeries()
207 {
204 {
208 QFETCH(QAbstractSeries *, series);
205 QFETCH(QAbstractSeries *, series);
209 QFETCH(QAbstractAxis *, axis);
210 m_view->show();
206 m_view->show();
211 QTest::qWaitForWindowShown(m_view);
207 QTest::qWaitForWindowShown(m_view);
212 if(!axis) axis = m_chart->axisY();
213 QVERIFY(!series->chart());
208 QVERIFY(!series->chart());
214 QCOMPARE(m_chart->series().count(), 0);
209 QCOMPARE(m_chart->series().count(), 0);
215 m_chart->addSeries(series);
210 m_chart->addSeries(series);
216 m_chart->setAxisY(axis,series);
217 QCOMPARE(m_chart->series().count(), 1);
211 QCOMPARE(m_chart->series().count(), 1);
218 QCOMPARE(m_chart->series().first(), series);
212 QCOMPARE(m_chart->series().first(), series);
219 QVERIFY(series->chart() == m_chart);
213 QVERIFY(series->chart() == m_chart);
220 QCOMPARE(m_chart->axisY(series),axis);
214 m_chart->createDefaultAxes();
215 if(series->type()!=QAbstractSeries::SeriesTypePie){
216 QVERIFY(m_chart->axisY(series));
217 QVERIFY(m_chart->axisX(series));
218 }else{
219 QVERIFY(!m_chart->axisY(series));
220 QVERIFY(!m_chart->axisX(series));
221 }
221 m_chart->removeSeries(series);
222 m_chart->removeSeries(series);
222 QVERIFY(!series->chart());
223 QVERIFY(!series->chart());
223 QCOMPARE(m_chart->series().count(), 0);
224 QCOMPARE(m_chart->series().count(), 0);
224 }
225 }
225
226
226 void tst_QChart::animationOptions_data()
227 void tst_QChart::animationOptions_data()
227 {
228 {
228 QTest::addColumn<QChart::AnimationOption>("animationOptions");
229 QTest::addColumn<QChart::AnimationOption>("animationOptions");
229 QTest::newRow("AllAnimations") << QChart::AllAnimations;
230 QTest::newRow("AllAnimations") << QChart::AllAnimations;
230 QTest::newRow("NoAnimation") << QChart::NoAnimation;
231 QTest::newRow("NoAnimation") << QChart::NoAnimation;
231 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
232 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
232 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
233 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
233 }
234 }
234
235
235 void tst_QChart::animationOptions()
236 void tst_QChart::animationOptions()
236 {
237 {
237 createTestData();
238 createTestData();
238 QFETCH(QChart::AnimationOption, animationOptions);
239 QFETCH(QChart::AnimationOption, animationOptions);
239 m_chart->setAnimationOptions(animationOptions);
240 m_chart->setAnimationOptions(animationOptions);
240 QCOMPARE(m_chart->animationOptions(), animationOptions);
241 QCOMPARE(m_chart->animationOptions(), animationOptions);
241 }
242 }
242
243
243 void tst_QChart::axisX_data()
244 void tst_QChart::axisX_data()
244 {
245 {
245
246
247 QTest::addColumn<QAbstractAxis*>("axis");
248 QTest::addColumn<QAbstractSeries *>("series");
249
250 QTest::newRow("categories,lineSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QLineSeries(this);
251 QTest::newRow("categories,areaSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
252 QTest::newRow("categories,scatterSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QScatterSeries(this);
253 QTest::newRow("categories,splineSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QSplineSeries(this);
254 QTest::newRow("categories,pieSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QPieSeries(this);
255 QTest::newRow("categories,barSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QBarSeries(this);
256 QTest::newRow("categories,percentBarSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
257 QTest::newRow("categories,stackedBarSeries") << (QAbstractAxis*) new QBarCategoriesAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
258
259 QTest::newRow("value,lineSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QLineSeries(this);
260 QTest::newRow("value,areaSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QAreaSeries(new QLineSeries(this));
261 QTest::newRow("value,scatterSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QScatterSeries(this);
262 QTest::newRow("value,splineSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QSplineSeries(this);
263 QTest::newRow("value,pieSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QPieSeries(this);
264 QTest::newRow("value,barSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QBarSeries(this);
265 QTest::newRow("value,percentBarSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QPercentBarSeries(this);
266 QTest::newRow("value,stackedBarSeries") << (QAbstractAxis*) new QValuesAxis() << (QAbstractSeries*) new QStackedBarSeries(this);
267
246 }
268 }
247
269
248 void tst_QChart::axisX()
270 void tst_QChart::axisX()
249 {
271 {
250 QVERIFY(m_chart->axisX());
272 QFETCH(QAbstractAxis*, axis);
251 QAbstractAxis* axis = m_chart->axisX();
273 QFETCH(QAbstractSeries*, series);
252 createTestData();
274 QVERIFY(!m_chart->axisX());
253 //it should be the same axis
275 m_view->show();
254 QCOMPARE(axis,m_chart->axisX());
276 QTest::qWaitForWindowShown(m_view);
277 m_chart->addSeries(series);
278 m_chart->setAxisX(axis,series);
279 QVERIFY(m_chart->axisX(series)==axis);
255 }
280 }
256
281
257 void tst_QChart::axisY_data()
282 void tst_QChart::axisY_data()
258 {
283 {
259 QTest::addColumn<QAbstractAxis*>("axis0");
284 axisX_data();
260 QTest::addColumn<QAbstractAxis*>("axis1");
261 QTest::addColumn<QAbstractAxis*>("axis2");
262 QTest::newRow("1 defualt, 2 optional") << (QAbstractAxis*)0 << new QValuesAxis() << new QValuesAxis();
263 QTest::newRow("3 optional") << new QValuesAxis() << new QValuesAxis() << new QValuesAxis();
264 }
285 }
265
286
266
287
267 void tst_QChart::axisY()
288 void tst_QChart::axisY()
268 {
289 {
269 QFETCH(QAbstractAxis*, axis0);
290 QFETCH(QAbstractAxis*, axis);
270 QFETCH(QAbstractAxis*, axis1);
291 QFETCH(QAbstractSeries*, series);
271 QFETCH(QAbstractAxis*, axis2);
292 QVERIFY(!m_chart->axisY());
272
293 m_view->show();
273 QAbstractAxis* defaultAxisY = m_chart->axisY();
294 QTest::qWaitForWindowShown(m_view);
274
295 m_chart->addSeries(series);
275 QVERIFY2(defaultAxisY, "Missing axisY.");
296 m_chart->setAxisY(axis,series);
276
297 QVERIFY(m_chart->axisY(series)==axis);
277 QLineSeries* series0 = new QLineSeries();
278 m_chart->addSeries(series0);
279 m_chart->setAxisY(axis0,series0);
280
281 QLineSeries* series1 = new QLineSeries();
282 m_chart->addSeries(series1);
283 m_chart->setAxisY(axis1,series1);
284
285 QLineSeries* series2 = new QLineSeries();
286 m_chart->addSeries(series2);
287 m_chart->setAxisY(axis2,series2);
288
289 if (!axis0)
290 axis0 = defaultAxisY;
291 if (!axis1)
292 axis1 = defaultAxisY;
293 if (!axis2)
294 axis2 = defaultAxisY;
295
296 QVERIFY(m_chart->axisY(series0) == axis0);
297 QVERIFY(m_chart->axisY(series1) == axis1);
298 QVERIFY(m_chart->axisY(series2) == axis2);
299 }
298 }
300
299
301 void tst_QChart::backgroundBrush_data()
300 void tst_QChart::backgroundBrush_data()
302 {
301 {
303 QTest::addColumn<QBrush>("backgroundBrush");
302 QTest::addColumn<QBrush>("backgroundBrush");
304 QTest::newRow("null") << QBrush();
303 QTest::newRow("null") << QBrush();
305 QTest::newRow("blue") << QBrush(Qt::blue);
304 QTest::newRow("blue") << QBrush(Qt::blue);
306 QTest::newRow("white") << QBrush(Qt::white);
305 QTest::newRow("white") << QBrush(Qt::white);
307 QTest::newRow("black") << QBrush(Qt::black);
306 QTest::newRow("black") << QBrush(Qt::black);
308 }
307 }
309
308
310 void tst_QChart::backgroundBrush()
309 void tst_QChart::backgroundBrush()
311 {
310 {
312 QFETCH(QBrush, backgroundBrush);
311 QFETCH(QBrush, backgroundBrush);
313 m_chart->setBackgroundBrush(backgroundBrush);
312 m_chart->setBackgroundBrush(backgroundBrush);
314 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
313 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
315 }
314 }
316
315
317 void tst_QChart::backgroundPen_data()
316 void tst_QChart::backgroundPen_data()
318 {
317 {
319 QTest::addColumn<QPen>("backgroundPen");
318 QTest::addColumn<QPen>("backgroundPen");
320 QTest::newRow("null") << QPen();
319 QTest::newRow("null") << QPen();
321 QTest::newRow("blue") << QPen(Qt::blue);
320 QTest::newRow("blue") << QPen(Qt::blue);
322 QTest::newRow("white") << QPen(Qt::white);
321 QTest::newRow("white") << QPen(Qt::white);
323 QTest::newRow("black") << QPen(Qt::black);
322 QTest::newRow("black") << QPen(Qt::black);
324 }
323 }
325
324
326
325
327 void tst_QChart::backgroundPen()
326 void tst_QChart::backgroundPen()
328 {
327 {
329 QFETCH(QPen, backgroundPen);
328 QFETCH(QPen, backgroundPen);
330 m_chart->setBackgroundPen(backgroundPen);
329 m_chart->setBackgroundPen(backgroundPen);
331 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
330 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
332 }
331 }
333
332
334 void tst_QChart::isBackgroundVisible_data()
333 void tst_QChart::isBackgroundVisible_data()
335 {
334 {
336 QTest::addColumn<bool>("isBackgroundVisible");
335 QTest::addColumn<bool>("isBackgroundVisible");
337 QTest::newRow("true") << true;
336 QTest::newRow("true") << true;
338 QTest::newRow("false") << false;
337 QTest::newRow("false") << false;
339 }
338 }
340
339
341 void tst_QChart::isBackgroundVisible()
340 void tst_QChart::isBackgroundVisible()
342 {
341 {
343 QFETCH(bool, isBackgroundVisible);
342 QFETCH(bool, isBackgroundVisible);
344 m_chart->setBackgroundVisible(isBackgroundVisible);
343 m_chart->setBackgroundVisible(isBackgroundVisible);
345 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
344 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
346 }
345 }
347
346
348 void tst_QChart::legend_data()
347 void tst_QChart::legend_data()
349 {
348 {
350
349
351 }
350 }
352
351
353 void tst_QChart::legend()
352 void tst_QChart::legend()
354 {
353 {
355 QLegend *legend = m_chart->legend();
354 QLegend *legend = m_chart->legend();
356 QVERIFY(legend);
355 QVERIFY(legend);
357
356
358 // Colors related signals
357 // Colors related signals
359 QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor)));
358 QSignalSpy colorSpy(legend, SIGNAL(colorChanged(QColor)));
360 QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor)));
359 QSignalSpy borderColorSpy(legend, SIGNAL(borderColorChanged(QColor)));
361 QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor)));
360 QSignalSpy labelColorSpy(legend, SIGNAL(labelColorChanged(QColor)));
362
361
363 // colorChanged
362 // colorChanged
364 legend->setColor(QColor("aliceblue"));
363 legend->setColor(QColor("aliceblue"));
365 QCOMPARE(colorSpy.count(), 1);
364 QCOMPARE(colorSpy.count(), 1);
366 QBrush b = legend->brush();
365 QBrush b = legend->brush();
367 b.setColor(QColor("aqua"));
366 b.setColor(QColor("aqua"));
368 legend->setBrush(b);
367 legend->setBrush(b);
369 QCOMPARE(colorSpy.count(), 2);
368 QCOMPARE(colorSpy.count(), 2);
370
369
371 // borderColorChanged
370 // borderColorChanged
372 legend->setBorderColor(QColor("aliceblue"));
371 legend->setBorderColor(QColor("aliceblue"));
373 QCOMPARE(borderColorSpy.count(), 1);
372 QCOMPARE(borderColorSpy.count(), 1);
374 QPen p = legend->pen();
373 QPen p = legend->pen();
375 p.setColor(QColor("aqua"));
374 p.setColor(QColor("aqua"));
376 legend->setPen(p);
375 legend->setPen(p);
377 QCOMPARE(borderColorSpy.count(), 2);
376 QCOMPARE(borderColorSpy.count(), 2);
378
377
379 // labelColorChanged
378 // labelColorChanged
380 legend->setLabelColor(QColor("lightsalmon"));
379 legend->setLabelColor(QColor("lightsalmon"));
381 QCOMPARE(labelColorSpy.count(), 1);
380 QCOMPARE(labelColorSpy.count(), 1);
382 b = legend->labelBrush();
381 b = legend->labelBrush();
383 b.setColor(QColor("lightseagreen"));
382 b.setColor(QColor("lightseagreen"));
384 legend->setLabelBrush(b);
383 legend->setLabelBrush(b);
385 QCOMPARE(labelColorSpy.count(), 2);
384 QCOMPARE(labelColorSpy.count(), 2);
386
385
387 // fontChanged
386 // fontChanged
388 QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont)));
387 QSignalSpy fontSpy(legend, SIGNAL(fontChanged(QFont)));
389 QFont f = legend->font();
388 QFont f = legend->font();
390 f.setBold(!f.bold());
389 f.setBold(!f.bold());
391 legend->setFont(f);
390 legend->setFont(f);
392 QCOMPARE(fontSpy.count(), 1);
391 QCOMPARE(fontSpy.count(), 1);
393 }
392 }
394
393
395 void tst_QChart::margins_data()
394 void tst_QChart::margins_data()
396 {
395 {
397
396
398 }
397 }
399
398
400 void tst_QChart::margins()
399 void tst_QChart::margins()
401 {
400 {
402 createTestData();
401 createTestData();
403 QRectF rect = m_chart->geometry();
402 QRectF rect = m_chart->geometry();
404
405 QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
403 QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
406 QVERIFY(m_chart->margins().left()+m_chart->margins().right() < rect.width());
404 QVERIFY(m_chart->margins().left()+m_chart->margins().right() < rect.width());
407 }
405 }
408
406
409 void tst_QChart::removeAllSeries_data()
407 void tst_QChart::removeAllSeries_data()
410 {
408 {
411
409
412 }
410 }
413
411
414 void tst_QChart::removeAllSeries()
412 void tst_QChart::removeAllSeries()
415 {
413 {
416 QLineSeries* series0 = new QLineSeries(this);
414 QLineSeries* series0 = new QLineSeries(this);
417 QLineSeries* series1 = new QLineSeries(this);
415 QLineSeries* series1 = new QLineSeries(this);
418 QLineSeries* series2 = new QLineSeries(this);
416 QLineSeries* series2 = new QLineSeries(this);
419 QSignalSpy deleteSpy1(series0, SIGNAL(destroyed()));
417 QSignalSpy deleteSpy1(series0, SIGNAL(destroyed()));
420 QSignalSpy deleteSpy2(series1, SIGNAL(destroyed()));
418 QSignalSpy deleteSpy2(series1, SIGNAL(destroyed()));
421 QSignalSpy deleteSpy3(series2, SIGNAL(destroyed()));
419 QSignalSpy deleteSpy3(series2, SIGNAL(destroyed()));
422
420
423 m_chart->addSeries(series0);
421 m_chart->addSeries(series0);
424 m_chart->addSeries(series1);
422 m_chart->addSeries(series1);
425 m_chart->addSeries(series2);
423 m_chart->addSeries(series2);
426 m_view->show();
424 m_view->show();
427 QTest::qWaitForWindowShown(m_view);
425 QTest::qWaitForWindowShown(m_view);
428
426 m_chart->createDefaultAxes();
429 QVERIFY(m_chart->axisY(series0)!=0);
427 QVERIFY(m_chart->axisY(series0)!=0);
430 QVERIFY(m_chart->axisY(series1)!=0);
428 QVERIFY(m_chart->axisY(series1)!=0);
431 QVERIFY(m_chart->axisY(series2)!=0);
429 QVERIFY(m_chart->axisY(series2)!=0);
432
430
433 m_chart->removeAllSeries();
431 m_chart->removeAllSeries();
434 QVERIFY(m_chart->axisY(series0)==0);
432 QVERIFY(m_chart->axisY(series0)==0);
435 QVERIFY(m_chart->axisY(series1)==0);
433 QVERIFY(m_chart->axisY(series1)==0);
436 QVERIFY(m_chart->axisY(series2)==0);
434 QVERIFY(m_chart->axisY(series2)==0);
437 QCOMPARE(deleteSpy1.count(), 1);
435 QCOMPARE(deleteSpy1.count(), 1);
438 QCOMPARE(deleteSpy2.count(), 1);
436 QCOMPARE(deleteSpy2.count(), 1);
439 QCOMPARE(deleteSpy3.count(), 1);
437 QCOMPARE(deleteSpy3.count(), 1);
440 }
438 }
441
439
442 void tst_QChart::removeSeries_data()
440 void tst_QChart::removeSeries_data()
443 {
441 {
444 addSeries_data();
442 axisX_data();
445 }
443 }
446
444
447 void tst_QChart::removeSeries()
445 void tst_QChart::removeSeries()
448 {
446 {
449 QFETCH(QAbstractSeries *, series);
450 QFETCH(QAbstractAxis *, axis);
447 QFETCH(QAbstractAxis *, axis);
448 QFETCH(QAbstractSeries *, series);
451 QSignalSpy deleteSpy(series, SIGNAL(destroyed()));
449 QSignalSpy deleteSpy(series, SIGNAL(destroyed()));
452 m_view->show();
450 m_view->show();
453 QTest::qWaitForWindowShown(m_view);
451 QTest::qWaitForWindowShown(m_view);
454 if(!axis) axis = m_chart->axisY();
452 if(!axis) axis = m_chart->axisY();
455 m_chart->addSeries(series);
453 m_chart->addSeries(series);
456 m_chart->setAxisY(axis,series);
454 m_chart->setAxisY(axis,series);
457 QCOMPARE(m_chart->axisY(series),axis);
455 QCOMPARE(m_chart->axisY(series),axis);
458 m_chart->removeSeries(series);
456 m_chart->removeSeries(series);
459 QVERIFY(m_chart->axisY(series)==0);
457 QVERIFY(m_chart->axisY(series)==0);
460 QCOMPARE(deleteSpy.count(), 0);
458 QCOMPARE(deleteSpy.count(), 0);
461 }
459 }
462
460
463 void tst_QChart::scroll_data()
461 void tst_QChart::scroll_right_data()
462 {
463 QTest::addColumn<QAbstractSeries *>("series");
464
465 QLineSeries* series0 = new QLineSeries(this);
466 *series0 << QPointF(0, 0) << QPointF(100, 100);
467
468 QLineSeries* series1 = new QLineSeries(this);
469 *series1 << QPointF(0, 0) << QPointF(100, 100);
470
471 QTest::newRow("lineSeries") << (QAbstractSeries*) series0;
472
473
474 }
475
476 void tst_QChart::scroll_right()
464 {
477 {
478 QFETCH(QAbstractSeries *, series);
479 m_chart->addSeries(series);
480 m_chart->createDefaultAxes();
481 m_view->show();
482 QTest::qWaitForWindowShown(m_view);
483 QAbstractAxis * axis = m_chart->axisX();
484 QVERIFY(axis!=0);
465
485
486 switch(axis->type())
487 {
488 case QAbstractAxis::AxisTypeValues:{
489 QValuesAxis* vaxis = qobject_cast<QValuesAxis*>(axis);
490 QVERIFY(vaxis!=0);
491 qreal min = vaxis->min();
492 qreal max = vaxis->max();
493 QVERIFY(max>min);
494 m_chart->scroll(50, 0);
495 QVERIFY(min<vaxis->min());
496 QVERIFY(max<vaxis->max());
497 break;
498 }
499 case QAbstractAxis::AxisTypeCategories:{
500 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
501 QVERIFY(caxis!=0);
502 qreal min = caxis->min().toDouble();
503 qreal max = caxis->max().toDouble();
504 m_chart->scroll(50, 0);
505 QVERIFY(min<caxis->min().toDouble());
506 QVERIFY(max<caxis->max().toDouble());
507 break;
508 }
509 default:
510 qFatal("Unsupported type");
511 break;
512 }
466 }
513 }
467
514
468 void tst_QChart::scroll()
515 void tst_QChart::scroll_left_data()
469 {
516 {
470 qFatal("implement me");
517 scroll_right_data();
471 createTestData();
518 }
472 //TODO qreal min = m_chart->axisY()->min();
519
473 m_chart->scroll(0,0);
520 void tst_QChart::scroll_left()
474 //TODO QVERIFY(m_chart->axisY()->min()<min);
521 {
522 QFETCH(QAbstractSeries *, series);
523 m_chart->addSeries(series);
524 m_chart->createDefaultAxes();
525 m_view->show();
526 QTest::qWaitForWindowShown(m_view);
527 QAbstractAxis * axis = m_chart->axisX();
528 QVERIFY(axis!=0);
529
530 switch(axis->type())
531 {
532 case QAbstractAxis::AxisTypeValues:{
533 QValuesAxis* vaxis = qobject_cast<QValuesAxis*>(axis);
534 QVERIFY(vaxis!=0);
535 qreal min = vaxis->min();
536 qreal max = vaxis->max();
537 m_chart->scroll(-50, 0);
538 QVERIFY(min>vaxis->min());
539 QVERIFY(max>vaxis->max());
540 break;
541 }
542 case QAbstractAxis::AxisTypeCategories:{
543 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
544 QVERIFY(caxis!=0);
545 qreal min = caxis->min().toDouble();
546 qreal max = caxis->max().toDouble();
547 m_chart->scroll(-50, 0);
548 QVERIFY(min>caxis->min().toDouble());
549 QVERIFY(max>caxis->max().toDouble());
550 break;
551 }
552 default:
553 qFatal("Unsupported type");
554 break;
555 }
556 }
557
558 void tst_QChart::scroll_up_data()
559 {
560 scroll_right_data();
561 }
562
563 void tst_QChart::scroll_up()
564 {
565 QFETCH(QAbstractSeries *, series);
566 m_chart->addSeries(series);
567 m_chart->createDefaultAxes();
568 m_view->show();
569 QTest::qWaitForWindowShown(m_view);
570 QAbstractAxis * axis = m_chart->axisY();
571 QVERIFY(axis!=0);
572
573 switch(axis->type())
574 {
575 case QAbstractAxis::AxisTypeValues:{
576 QValuesAxis* vaxis = qobject_cast<QValuesAxis*>(axis);
577 QVERIFY(vaxis!=0);
578 qreal min = vaxis->min();
579 qreal max = vaxis->max();
580 m_chart->scroll(0, 50);
581 QVERIFY(min<vaxis->min());
582 QVERIFY(max<vaxis->max());
583 break;
584 }
585 case QAbstractAxis::AxisTypeCategories:{
586 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
587 QVERIFY(caxis!=0);
588 qreal min = caxis->min().toDouble();
589 qreal max = caxis->max().toDouble();
590 m_chart->scroll(0, 50);
591 QVERIFY(min<caxis->min().toDouble());
592 QVERIFY(max<caxis->max().toDouble());
593 break;
594 }
595 default:
596 qFatal("Unsupported type");
597 break;
598 }
599 }
600
601 void tst_QChart::scroll_down_data()
602 {
603 scroll_right_data();
604 }
605
606 void tst_QChart::scroll_down()
607 {
608 QFETCH(QAbstractSeries *, series);
609 m_chart->addSeries(series);
610 m_chart->createDefaultAxes();
611 m_view->show();
612 QTest::qWaitForWindowShown(m_view);
613 QAbstractAxis * axis = m_chart->axisY();
614 QVERIFY(axis!=0);
615
616 switch(axis->type())
617 {
618 case QAbstractAxis::AxisTypeValues:{
619 QValuesAxis* vaxis = qobject_cast<QValuesAxis*>(axis);
620 QVERIFY(vaxis!=0);
621 qreal min = vaxis->min();
622 qreal max = vaxis->max();
623 m_chart->scroll(0, -50);
624 QVERIFY(min>vaxis->min());
625 QVERIFY(max>vaxis->max());
626 break;
627 }
628 case QAbstractAxis::AxisTypeCategories:{
629 QBarCategoriesAxis* caxis = qobject_cast<QBarCategoriesAxis*>(axis);
630 QVERIFY(caxis!=0);
631 qreal min = caxis->min().toDouble();
632 qreal max = caxis->max().toDouble();
633 m_chart->scroll(0, -50);
634 QVERIFY(min>caxis->min().toDouble());
635 QVERIFY(max>caxis->max().toDouble());
636 break;
637 }
638 default:
639 qFatal("Unsupported type");
640 break;
641 }
475 }
642 }
476
643
477 void tst_QChart::theme_data()
644 void tst_QChart::theme_data()
478 {
645 {
479 QTest::addColumn<QChart::ChartTheme>("theme");
646 QTest::addColumn<QChart::ChartTheme>("theme");
480 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
647 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
481 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
648 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
482 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
649 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
483 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
650 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
484 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
651 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
485 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
652 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
486 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
653 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
487 }
654 }
488
655
489 void tst_QChart::theme()
656 void tst_QChart::theme()
490 {
657 {
491 QFETCH(QChart::ChartTheme, theme);
658 QFETCH(QChart::ChartTheme, theme);
492 createTestData();
659 createTestData();
493 m_chart->setTheme(theme);
660 m_chart->setTheme(theme);
494 QVERIFY(m_chart->theme()==theme);
661 QVERIFY(m_chart->theme()==theme);
495 }
662 }
496
663
497 void tst_QChart::title_data()
664 void tst_QChart::title_data()
498 {
665 {
499 QTest::addColumn<QString>("title");
666 QTest::addColumn<QString>("title");
500 QTest::newRow("null") << QString();
667 QTest::newRow("null") << QString();
501 QTest::newRow("foo") << QString("foo");
668 QTest::newRow("foo") << QString("foo");
502 }
669 }
503
670
504 void tst_QChart::title()
671 void tst_QChart::title()
505 {
672 {
506 QFETCH(QString, title);
673 QFETCH(QString, title);
507 m_chart->setTitle(title);
674 m_chart->setTitle(title);
508 QCOMPARE(m_chart->title(), title);
675 QCOMPARE(m_chart->title(), title);
509 }
676 }
510
677
511 void tst_QChart::titleBrush_data()
678 void tst_QChart::titleBrush_data()
512 {
679 {
513 QTest::addColumn<QBrush>("titleBrush");
680 QTest::addColumn<QBrush>("titleBrush");
514 QTest::newRow("null") << QBrush();
681 QTest::newRow("null") << QBrush();
515 QTest::newRow("blue") << QBrush(Qt::blue);
682 QTest::newRow("blue") << QBrush(Qt::blue);
516 QTest::newRow("white") << QBrush(Qt::white);
683 QTest::newRow("white") << QBrush(Qt::white);
517 QTest::newRow("black") << QBrush(Qt::black);
684 QTest::newRow("black") << QBrush(Qt::black);
518 }
685 }
519
686
520 void tst_QChart::titleBrush()
687 void tst_QChart::titleBrush()
521 {
688 {
522 QFETCH(QBrush, titleBrush);
689 QFETCH(QBrush, titleBrush);
523 m_chart->setTitleBrush(titleBrush);
690 m_chart->setTitleBrush(titleBrush);
524 QCOMPARE(m_chart->titleBrush(), titleBrush);
691 QCOMPARE(m_chart->titleBrush(), titleBrush);
525 }
692 }
526
693
527 void tst_QChart::titleFont_data()
694 void tst_QChart::titleFont_data()
528 {
695 {
529 QTest::addColumn<QFont>("titleFont");
696 QTest::addColumn<QFont>("titleFont");
530 QTest::newRow("null") << QFont();
697 QTest::newRow("null") << QFont();
531 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
698 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
532 }
699 }
533
700
534 void tst_QChart::titleFont()
701 void tst_QChart::titleFont()
535 {
702 {
536 QFETCH(QFont, titleFont);
703 QFETCH(QFont, titleFont);
537 m_chart->setTitleFont(titleFont);
704 m_chart->setTitleFont(titleFont);
538 QCOMPARE(m_chart->titleFont(), titleFont);
705 QCOMPARE(m_chart->titleFont(), titleFont);
539 }
706 }
540
707
541 void tst_QChart::zoomIn_data()
708 void tst_QChart::zoomIn_data()
542 {
709 {
543 QTest::addColumn<QRectF>("rect");
710 QTest::addColumn<QRectF>("rect");
544 QTest::newRow("null") << QRectF();
711 QTest::newRow("null") << QRectF();
545 QTest::newRow("100x100") << QRectF(10,10,100,100);
712 QTest::newRow("100x100") << QRectF(10,10,100,100);
546 QTest::newRow("200x200") << QRectF(10,10,200,200);
713 QTest::newRow("200x200") << QRectF(10,10,200,200);
547 }
714 }
548
715
549
716
550 void tst_QChart::zoomIn()
717 void tst_QChart::zoomIn()
551 {
718 {
552 qFatal("implement me");
719
553 /*
554 QFETCH(QRectF, rect);
720 QFETCH(QRectF, rect);
555 createTestData();
721 createTestData();
722 m_chart->createDefaultAxes();
556 QRectF marigns = m_chart->margins();
723 QRectF marigns = m_chart->margins();
557 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
724 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
558 qreal minX = m_chart->axisX()->min();
725 QValuesAxis* axisX = qobject_cast<QValuesAxis*>(m_chart->axisX());
559 qreal minY = m_chart->axisY()->min();
726 QVERIFY(axisX!=0);
560 qreal maxX = m_chart->axisX()->max();
727 QValuesAxis* axisY = qobject_cast<QValuesAxis*>(m_chart->axisY());
561 qreal maxY = m_chart->axisY()->max();
728 QVERIFY(axisY!=0);
729 qreal minX = axisX->min();
730 qreal minY = axisY->min();
731 qreal maxX = axisX->max();
732 qreal maxY = axisY->max();
562 m_chart->zoomIn(rect);
733 m_chart->zoomIn(rect);
563 if(rect.isValid()){
734 if(rect.isValid()){
564 QVERIFY(minX<m_chart->axisX()->min());
735 QVERIFY(minX<axisX->min());
565 QVERIFY(maxX>m_chart->axisX()->max());
736 QVERIFY(maxX>axisX->max());
566 QVERIFY(minY<m_chart->axisY()->min());
737 QVERIFY(minY<axisY->min());
567 QVERIFY(maxY>m_chart->axisY()->max());
738 QVERIFY(maxY>axisY->max());
568 }
739 }
569 */
740
570 }
741 }
571
742
572 void tst_QChart::zoomOut_data()
743 void tst_QChart::zoomOut_data()
573 {
744 {
574
745
575 }
746 }
576
747
577 void tst_QChart::zoomOut()
748 void tst_QChart::zoomOut()
578 {
749 {
579 qFatal("implement me");
580 createTestData();
750 createTestData();
581 /*
751 m_chart->createDefaultAxes();
582 qreal minX = m_chart->axisX()->min();
752
583 qreal minY = m_chart->axisY()->min();
753 QValuesAxis* axisX = qobject_cast<QValuesAxis*>(m_chart->axisX());
584 qreal maxX = m_chart->axisX()->max();
754 QVERIFY(axisX!=0);
585 qreal maxY = m_chart->axisY()->max();
755 QValuesAxis* axisY = qobject_cast<QValuesAxis*>(m_chart->axisY());
756 QVERIFY(axisY!=0);
757
758 qreal minX = axisX->min();
759 qreal minY = axisY->min();
760 qreal maxX = axisX->max();
761 qreal maxY = axisY->max();
586
762
587 m_chart->zoomIn();
763 m_chart->zoomIn();
588
764
589 QVERIFY(minX < m_chart->axisX()->min());
765 QVERIFY(minX < axisX->min());
590 QVERIFY(maxX > m_chart->axisX()->max());
766 QVERIFY(maxX > axisX->max());
591 QVERIFY(minY < m_chart->axisY()->min());
767 QVERIFY(minY < axisY->min());
592 QVERIFY(maxY > m_chart->axisY()->max());
768 QVERIFY(maxY > axisY->max());
593
769
594 m_chart->zoomOut();
770 m_chart->zoomOut();
595
771
596 // min x may be a zero value
772 // min x may be a zero value
597 if (qFuzzyIsNull(minX))
773 if (qFuzzyIsNull(minX))
598 QVERIFY(qFuzzyIsNull(m_chart->axisX()->min()));
774 QVERIFY(qFuzzyIsNull(axisX->min()));
599 else
775 else
600 QCOMPARE(minX, m_chart->axisX()->min());
776 QCOMPARE(minX, axisX->min());
601
777
602 // min y may be a zero value
778 // min y may be a zero value
603 if (qFuzzyIsNull(minY))
779 if (qFuzzyIsNull(minY))
604 QVERIFY(qFuzzyIsNull(m_chart->axisY()->min()));
780 QVERIFY(qFuzzyIsNull(axisY->min()));
605 else
781 else
606 QCOMPARE(minY, m_chart->axisY()->min());
782 QCOMPARE(minY, axisY->min());
783
784 QVERIFY(maxX == axisX->max());
785 QVERIFY(maxY == axisY->max());
607
786
608 QVERIFY(maxX == m_chart->axisX()->max());
609 QVERIFY(maxY == m_chart->axisY()->max());
610 */
611 }
787 }
612
788
613 QTEST_MAIN(tst_QChart)
789 QTEST_MAIN(tst_QChart)
614 #include "tst_qchart.moc"
790 #include "tst_qchart.moc"
615
791
General Comments 0
You need to be logged in to leave comments. Login now