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

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

Try to make bamboo skip tests that it cannot run
Jani Honkonen -
r2062:ac81d3fe09a3
parent child
Show More
Side by Side Unified
Context file:
r2062:ac81d3fe09a3 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,38 +1,55
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 #ifndef TST_DEFINITIONS_H
21 #ifndef TST_DEFINITIONS_H
22 #define TST_DEFINITIONS_H
22 #define TST_DEFINITIONS_H
23
23
24 #include <QtTest/QtTest>
24 #include <QtTest/QtTest>
25 #include <QPushButton>
25
26
26 #define TRY_COMPARE(actual, expected) { \
27 #define TRY_COMPARE(actual, expected) { \
27 do { \
28 do { \
28 const int timeout(1000); \
29 const int timeout(1000); \
29 const int waitStep(30); \
30 const int waitStep(30); \
30 /* always wait before comparing to catch possible extra signals */ \
31 /* always wait before comparing to catch possible extra signals */ \
31 QTest::qWait(waitStep); \
32 QTest::qWait(waitStep); \
32 for (int time(0); (actual != expected) && (time < timeout); time += waitStep) \
33 for (int time(0); (actual != expected) && (time < timeout); time += waitStep) \
33 QTest::qWait(waitStep); \
34 QTest::qWait(waitStep); \
34 QCOMPARE(actual, expected); \
35 QCOMPARE(actual, expected); \
35 } while (0); \
36 } while (0); \
36 }
37 }
37
38
39 // Some bamboo clients have trouble passing mouse events to the test application.
40 // This can be used to skip those tests so that they don't show up as a failure
41 // in the test report.
42 #define SKIP_IF_CANNOT_TEST_MOUSE_EVENTS() { \
43 do { \
44 QPushButton b; \
45 b.resize(100, 100); \
46 b.show(); \
47 QTest::qWaitForWindowShown(&b); \
48 QSignalSpy spy(&b, SIGNAL(clicked())); \
49 QTest::mouseClick(&b, Qt::LeftButton, 0, b.rect().center()); \
50 if (spy.count() == 0) \
51 QSKIP("Cannot test mouse events in this environment", SkipAll); \
52 } while (0); \
53 }
54
38 #endif // TST_DEFINITIONS_H
55 #endif // TST_DEFINITIONS_H
Show file before | Show file after | Hide comments
@@ -1,638 +1,642
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 <qchart.h>
23 #include <qchart.h>
24 #include <qpieseries.h>
24 #include <qpieseries.h>
25 #include <qpieslice.h>
25 #include <qpieslice.h>
26 #include <qpiemodelmapper.h>
26 #include <qpiemodelmapper.h>
27 #include <QStandardItemModel>
27 #include <QStandardItemModel>
28 #include <tst_definitions.h>
28 #include <tst_definitions.h>
29
29
30 QTCOMMERCIALCHART_USE_NAMESPACE
30 QTCOMMERCIALCHART_USE_NAMESPACE
31
31
32 Q_DECLARE_METATYPE(QPieSlice*)
32 Q_DECLARE_METATYPE(QPieSlice*)
33 Q_DECLARE_METATYPE(QList<QPieSlice*>)
33 Q_DECLARE_METATYPE(QList<QPieSlice*>)
34
34
35 class tst_qpieseries : public QObject
35 class tst_qpieseries : public QObject
36 {
36 {
37 Q_OBJECT
37 Q_OBJECT
38
38
39 public slots:
39 public slots:
40 void initTestCase();
40 void initTestCase();
41 void cleanupTestCase();
41 void cleanupTestCase();
42 void init();
42 void init();
43 void cleanup();
43 void cleanup();
44
44
45 private slots:
45 private slots:
46 void properties();
46 void properties();
47 void append();
47 void append();
48 void appendAnimated();
48 void appendAnimated();
49 void insert();
49 void insert();
50 void insertAnimated();
50 void insertAnimated();
51 void remove();
51 void remove();
52 void removeAnimated();
52 void removeAnimated();
53 void take();
53 void take();
54 void takeAnimated();
54 void takeAnimated();
55 void calculatedValues();
55 void calculatedValues();
56 void clickedSignal();
56 void clickedSignal();
57 void hoverSignal();
57 void hoverSignal();
58 void sliceSeries();
58 void sliceSeries();
59 void destruction();
59 void destruction();
60
60
61 private:
61 private:
62 void verifyCalculatedData(const QPieSeries &series, bool *ok);
62 void verifyCalculatedData(const QPieSeries &series, bool *ok);
63
63
64 private:
64 private:
65 QChartView *m_view;
65 QChartView *m_view;
66 QPieSeries *m_series;
66 QPieSeries *m_series;
67 };
67 };
68
68
69 void tst_qpieseries::initTestCase()
69 void tst_qpieseries::initTestCase()
70 {
70 {
71 qRegisterMetaType<QPieSlice*>("QPieSlice*");
71 qRegisterMetaType<QPieSlice*>("QPieSlice*");
72 qRegisterMetaType<QList<QPieSlice*> >("QList<QPieSlice*>");
72 qRegisterMetaType<QList<QPieSlice*> >("QList<QPieSlice*>");
73 }
73 }
74
74
75 void tst_qpieseries::cleanupTestCase()
75 void tst_qpieseries::cleanupTestCase()
76 {
76 {
77 }
77 }
78
78
79 void tst_qpieseries::init()
79 void tst_qpieseries::init()
80 {
80 {
81 m_view = new QChartView();
81 m_view = new QChartView();
82 m_series = new QPieSeries(m_view);
82 m_series = new QPieSeries(m_view);
83 m_view->show();
83 m_view->show();
84 QTest::qWaitForWindowShown(m_view);
84 QTest::qWaitForWindowShown(m_view);
85
85
86 }
86 }
87
87
88 void tst_qpieseries::cleanup()
88 void tst_qpieseries::cleanup()
89 {
89 {
90 delete m_view;
90 delete m_view;
91 m_view = 0;
91 m_view = 0;
92 m_series = 0;
92 m_series = 0;
93 }
93 }
94
94
95 void tst_qpieseries::properties()
95 void tst_qpieseries::properties()
96 {
96 {
97 QSignalSpy countSpy(m_series, SIGNAL(countChanged()));
97 QSignalSpy countSpy(m_series, SIGNAL(countChanged()));
98 QSignalSpy sumSpy(m_series, SIGNAL(sumChanged()));
98 QSignalSpy sumSpy(m_series, SIGNAL(sumChanged()));
99
99
100 QVERIFY(m_series->type() == QAbstractSeries::SeriesTypePie);
100 QVERIFY(m_series->type() == QAbstractSeries::SeriesTypePie);
101 QVERIFY(m_series->count() == 0);
101 QVERIFY(m_series->count() == 0);
102 QVERIFY(m_series->isEmpty());
102 QVERIFY(m_series->isEmpty());
103 QCOMPARE(m_series->sum(), 0.0);
103 QCOMPARE(m_series->sum(), 0.0);
104 QCOMPARE(m_series->horizontalPosition(), 0.5);
104 QCOMPARE(m_series->horizontalPosition(), 0.5);
105 QCOMPARE(m_series->verticalPosition(), 0.5);
105 QCOMPARE(m_series->verticalPosition(), 0.5);
106 QCOMPARE(m_series->pieSize(), 0.7);
106 QCOMPARE(m_series->pieSize(), 0.7);
107 QCOMPARE(m_series->pieStartAngle(), 0.0);
107 QCOMPARE(m_series->pieStartAngle(), 0.0);
108 QCOMPARE(m_series->pieEndAngle(), 360.0);
108 QCOMPARE(m_series->pieEndAngle(), 360.0);
109
109
110 m_series->append("s1", 1);
110 m_series->append("s1", 1);
111 m_series->append("s2", 1);
111 m_series->append("s2", 1);
112 m_series->append("s3", 1);
112 m_series->append("s3", 1);
113 m_series->insert(1, new QPieSlice("s4", 1));
113 m_series->insert(1, new QPieSlice("s4", 1));
114 m_series->remove(m_series->slices().first());
114 m_series->remove(m_series->slices().first());
115 QCOMPARE(m_series->count(), 3);
115 QCOMPARE(m_series->count(), 3);
116 QCOMPARE(m_series->sum(), 3.0);
116 QCOMPARE(m_series->sum(), 3.0);
117 m_series->clear();
117 m_series->clear();
118 QCOMPARE(m_series->count(), 0);
118 QCOMPARE(m_series->count(), 0);
119 QCOMPARE(m_series->sum(), 0.0);
119 QCOMPARE(m_series->sum(), 0.0);
120 QCOMPARE(countSpy.count(), 6);
120 QCOMPARE(countSpy.count(), 6);
121 QCOMPARE(sumSpy.count(), 6);
121 QCOMPARE(sumSpy.count(), 6);
122
122
123 m_series->setPieSize(-1.0);
123 m_series->setPieSize(-1.0);
124 QCOMPARE(m_series->pieSize(), 0.0);
124 QCOMPARE(m_series->pieSize(), 0.0);
125 m_series->setPieSize(0.0);
125 m_series->setPieSize(0.0);
126 m_series->setPieSize(0.9);
126 m_series->setPieSize(0.9);
127 m_series->setPieSize(2.0);
127 m_series->setPieSize(2.0);
128 QCOMPARE(m_series->pieSize(), 1.0);
128 QCOMPARE(m_series->pieSize(), 1.0);
129
129
130 m_series->setPieSize(0.7);
130 m_series->setPieSize(0.7);
131 QCOMPARE(m_series->pieSize(), 0.7);
131 QCOMPARE(m_series->pieSize(), 0.7);
132
132
133 m_series->setHoleSize(-1.0);
133 m_series->setHoleSize(-1.0);
134 QCOMPARE(m_series->holeSize(), 0.0);
134 QCOMPARE(m_series->holeSize(), 0.0);
135 m_series->setHoleSize(0.5);
135 m_series->setHoleSize(0.5);
136 QCOMPARE(m_series->holeSize(), 0.5);
136 QCOMPARE(m_series->holeSize(), 0.5);
137
137
138 m_series->setHoleSize(0.8);
138 m_series->setHoleSize(0.8);
139 QCOMPARE(m_series->holeSize(), 0.8);
139 QCOMPARE(m_series->holeSize(), 0.8);
140 QCOMPARE(m_series->pieSize(), 0.8);
140 QCOMPARE(m_series->pieSize(), 0.8);
141
141
142 m_series->setPieSize(0.4);
142 m_series->setPieSize(0.4);
143 QCOMPARE(m_series->pieSize(), 0.4);
143 QCOMPARE(m_series->pieSize(), 0.4);
144 QCOMPARE(m_series->holeSize(), 0.4);
144 QCOMPARE(m_series->holeSize(), 0.4);
145
145
146 m_series->setPieStartAngle(0);
146 m_series->setPieStartAngle(0);
147 m_series->setPieStartAngle(-180);
147 m_series->setPieStartAngle(-180);
148 m_series->setPieStartAngle(180);
148 m_series->setPieStartAngle(180);
149 QCOMPARE(m_series->pieStartAngle(), 180.0);
149 QCOMPARE(m_series->pieStartAngle(), 180.0);
150
150
151 m_series->setPieEndAngle(360);
151 m_series->setPieEndAngle(360);
152 m_series->setPieEndAngle(-180);
152 m_series->setPieEndAngle(-180);
153 m_series->setPieEndAngle(180);
153 m_series->setPieEndAngle(180);
154 QCOMPARE(m_series->pieEndAngle(), 180.0);
154 QCOMPARE(m_series->pieEndAngle(), 180.0);
155
155
156 m_series->setHorizontalPosition(0.5);
156 m_series->setHorizontalPosition(0.5);
157 m_series->setHorizontalPosition(-1.0);
157 m_series->setHorizontalPosition(-1.0);
158 QCOMPARE(m_series->horizontalPosition(), 0.0);
158 QCOMPARE(m_series->horizontalPosition(), 0.0);
159 m_series->setHorizontalPosition(1.0);
159 m_series->setHorizontalPosition(1.0);
160 m_series->setHorizontalPosition(2.0);
160 m_series->setHorizontalPosition(2.0);
161 QCOMPARE(m_series->horizontalPosition(), 1.0);
161 QCOMPARE(m_series->horizontalPosition(), 1.0);
162
162
163 m_series->setVerticalPosition(0.5);
163 m_series->setVerticalPosition(0.5);
164 m_series->setVerticalPosition(-1.0);
164 m_series->setVerticalPosition(-1.0);
165 QCOMPARE(m_series->verticalPosition(), 0.0);
165 QCOMPARE(m_series->verticalPosition(), 0.0);
166 m_series->setVerticalPosition(1.0);
166 m_series->setVerticalPosition(1.0);
167 m_series->setVerticalPosition(2.0);
167 m_series->setVerticalPosition(2.0);
168 QCOMPARE(m_series->verticalPosition(), 1.0);
168 QCOMPARE(m_series->verticalPosition(), 1.0);
169 }
169 }
170
170
171 void tst_qpieseries::append()
171 void tst_qpieseries::append()
172 {
172 {
173 m_view->chart()->addSeries(m_series);
173 m_view->chart()->addSeries(m_series);
174 QSignalSpy addedSpy(m_series, SIGNAL(added(QList<QPieSlice*>)));
174 QSignalSpy addedSpy(m_series, SIGNAL(added(QList<QPieSlice*>)));
175
175
176 // append pointer
176 // append pointer
177 QPieSlice *slice1 = 0;
177 QPieSlice *slice1 = 0;
178 QVERIFY(!m_series->append(slice1));
178 QVERIFY(!m_series->append(slice1));
179 slice1 = new QPieSlice("slice 1", 1);
179 slice1 = new QPieSlice("slice 1", 1);
180 QVERIFY(m_series->append(slice1));
180 QVERIFY(m_series->append(slice1));
181 QVERIFY(!m_series->append(slice1));
181 QVERIFY(!m_series->append(slice1));
182 QCOMPARE(m_series->count(), 1);
182 QCOMPARE(m_series->count(), 1);
183 QCOMPARE(addedSpy.count(), 1);
183 QCOMPARE(addedSpy.count(), 1);
184 QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0));
184 QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0));
185 QCOMPARE(added.count(), 1);
185 QCOMPARE(added.count(), 1);
186 QCOMPARE(added.first(), slice1);
186 QCOMPARE(added.first(), slice1);
187
187
188 // try to append same slice to another series
188 // try to append same slice to another series
189 QPieSeries series2;
189 QPieSeries series2;
190 QVERIFY(!series2.append(slice1));
190 QVERIFY(!series2.append(slice1));
191
191
192 // append pointer list
192 // append pointer list
193 QList<QPieSlice *> list;
193 QList<QPieSlice *> list;
194 QVERIFY(!m_series->append(list));
194 QVERIFY(!m_series->append(list));
195 list << (QPieSlice *) 0;
195 list << (QPieSlice *) 0;
196 QVERIFY(!m_series->append(list));
196 QVERIFY(!m_series->append(list));
197 list.clear();
197 list.clear();
198 list << new QPieSlice("slice 2", 2);
198 list << new QPieSlice("slice 2", 2);
199 list << new QPieSlice("slice 3", 3);
199 list << new QPieSlice("slice 3", 3);
200 QVERIFY(m_series->append(list));
200 QVERIFY(m_series->append(list));
201 QVERIFY(!m_series->append(list));
201 QVERIFY(!m_series->append(list));
202 QCOMPARE(m_series->count(), 3);
202 QCOMPARE(m_series->count(), 3);
203 QCOMPARE(addedSpy.count(), 2);
203 QCOMPARE(addedSpy.count(), 2);
204 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0));
204 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0));
205 QCOMPARE(added.count(), 2);
205 QCOMPARE(added.count(), 2);
206 QCOMPARE(added, list);
206 QCOMPARE(added, list);
207
207
208 // append operator
208 // append operator
209 QPieSlice *slice4 = new QPieSlice("slice 4", 4);
209 QPieSlice *slice4 = new QPieSlice("slice 4", 4);
210 *m_series << slice4;
210 *m_series << slice4;
211 *m_series << slice1; // fails because already added
211 *m_series << slice1; // fails because already added
212 QCOMPARE(m_series->count(), 4);
212 QCOMPARE(m_series->count(), 4);
213 QCOMPARE(addedSpy.count(), 3);
213 QCOMPARE(addedSpy.count(), 3);
214 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0));
214 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0));
215 QCOMPARE(added.count(), 1);
215 QCOMPARE(added.count(), 1);
216 QCOMPARE(added.first(), slice4);
216 QCOMPARE(added.first(), slice4);
217
217
218 // append with params
218 // append with params
219 QPieSlice *slice5 = m_series->append("slice 5", 5);
219 QPieSlice *slice5 = m_series->append("slice 5", 5);
220 QVERIFY(slice5 != 0);
220 QVERIFY(slice5 != 0);
221 QCOMPARE(slice5->value(), 5.0);
221 QCOMPARE(slice5->value(), 5.0);
222 QCOMPARE(slice5->label(), QString("slice 5"));
222 QCOMPARE(slice5->label(), QString("slice 5"));
223 QCOMPARE(m_series->count(), 5);
223 QCOMPARE(m_series->count(), 5);
224 QCOMPARE(addedSpy.count(), 4);
224 QCOMPARE(addedSpy.count(), 4);
225 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0));
225 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0));
226 QCOMPARE(added.count(), 1);
226 QCOMPARE(added.count(), 1);
227 QCOMPARE(added.first(), slice5);
227 QCOMPARE(added.first(), slice5);
228
228
229 // check slices
229 // check slices
230 QVERIFY(!m_series->isEmpty());
230 QVERIFY(!m_series->isEmpty());
231 for (int i=0; i<m_series->count(); i++) {
231 for (int i=0; i<m_series->count(); i++) {
232 QCOMPARE(m_series->slices().at(i)->value(), (qreal) i+1);
232 QCOMPARE(m_series->slices().at(i)->value(), (qreal) i+1);
233 QCOMPARE(m_series->slices().at(i)->label(), QString("slice ") + QString::number(i+1));
233 QCOMPARE(m_series->slices().at(i)->label(), QString("slice ") + QString::number(i+1));
234 }
234 }
235 }
235 }
236
236
237 void tst_qpieseries::appendAnimated()
237 void tst_qpieseries::appendAnimated()
238 {
238 {
239 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
239 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
240 append();
240 append();
241 }
241 }
242
242
243 void tst_qpieseries::insert()
243 void tst_qpieseries::insert()
244 {
244 {
245 m_view->chart()->addSeries(m_series);
245 m_view->chart()->addSeries(m_series);
246 QSignalSpy addedSpy(m_series, SIGNAL(added(QList<QPieSlice*>)));
246 QSignalSpy addedSpy(m_series, SIGNAL(added(QList<QPieSlice*>)));
247
247
248 // insert one slice
248 // insert one slice
249 QPieSlice *slice1 = 0;
249 QPieSlice *slice1 = 0;
250 QVERIFY(!m_series->insert(0, slice1));
250 QVERIFY(!m_series->insert(0, slice1));
251 slice1 = new QPieSlice("slice 1", 1);
251 slice1 = new QPieSlice("slice 1", 1);
252 QVERIFY(!m_series->insert(-1, slice1));
252 QVERIFY(!m_series->insert(-1, slice1));
253 QVERIFY(!m_series->insert(5, slice1));
253 QVERIFY(!m_series->insert(5, slice1));
254 QVERIFY(m_series->insert(0, slice1));
254 QVERIFY(m_series->insert(0, slice1));
255 QVERIFY(!m_series->insert(0, slice1));
255 QVERIFY(!m_series->insert(0, slice1));
256 QCOMPARE(m_series->count(), 1);
256 QCOMPARE(m_series->count(), 1);
257 QCOMPARE(addedSpy.count(), 1);
257 QCOMPARE(addedSpy.count(), 1);
258 QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0));
258 QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0));
259 QCOMPARE(added.count(), 1);
259 QCOMPARE(added.count(), 1);
260 QCOMPARE(added.first(), slice1);
260 QCOMPARE(added.first(), slice1);
261
261
262 // try to insert same slice to another series
262 // try to insert same slice to another series
263 QPieSeries series2;
263 QPieSeries series2;
264 QVERIFY(!series2.insert(0, slice1));
264 QVERIFY(!series2.insert(0, slice1));
265
265
266 // add some more slices
266 // add some more slices
267 QPieSlice *slice2 = m_series->append("slice 2", 2);
267 QPieSlice *slice2 = m_series->append("slice 2", 2);
268 QPieSlice *slice4 = m_series->append("slice 4", 4);
268 QPieSlice *slice4 = m_series->append("slice 4", 4);
269 QCOMPARE(m_series->count(), 3);
269 QCOMPARE(m_series->count(), 3);
270 QCOMPARE(addedSpy.count(), 3);
270 QCOMPARE(addedSpy.count(), 3);
271 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0));
271 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0));
272 QCOMPARE(added.count(), 1);
272 QCOMPARE(added.count(), 1);
273 QCOMPARE(added.first(), slice2);
273 QCOMPARE(added.first(), slice2);
274 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0));
274 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0));
275 QCOMPARE(added.count(), 1);
275 QCOMPARE(added.count(), 1);
276 QCOMPARE(added.first(), slice4);
276 QCOMPARE(added.first(), slice4);
277
277
278 // insert between slices
278 // insert between slices
279 QPieSlice *slice3 = new QPieSlice("slice 3", 3);
279 QPieSlice *slice3 = new QPieSlice("slice 3", 3);
280 m_series->insert(2, slice3);
280 m_series->insert(2, slice3);
281 QCOMPARE(m_series->count(), 4);
281 QCOMPARE(m_series->count(), 4);
282 QCOMPARE(addedSpy.count(), 4);
282 QCOMPARE(addedSpy.count(), 4);
283 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0));
283 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0));
284 QCOMPARE(added.count(), 1);
284 QCOMPARE(added.count(), 1);
285 QCOMPARE(added.first(), slice3);
285 QCOMPARE(added.first(), slice3);
286
286
287 // check slices
287 // check slices
288 for (int i=0; i<m_series->count(); i++) {
288 for (int i=0; i<m_series->count(); i++) {
289 QCOMPARE(m_series->slices().at(i)->value(), (qreal) i+1);
289 QCOMPARE(m_series->slices().at(i)->value(), (qreal) i+1);
290 QCOMPARE(m_series->slices().at(i)->label(), QString("slice ") + QString::number(i+1));
290 QCOMPARE(m_series->slices().at(i)->label(), QString("slice ") + QString::number(i+1));
291 QVERIFY(m_series->slices().at(i)->parent() == m_series);
291 QVERIFY(m_series->slices().at(i)->parent() == m_series);
292 }
292 }
293 }
293 }
294
294
295 void tst_qpieseries::insertAnimated()
295 void tst_qpieseries::insertAnimated()
296 {
296 {
297 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
297 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
298 insert();
298 insert();
299 }
299 }
300
300
301 void tst_qpieseries::remove()
301 void tst_qpieseries::remove()
302 {
302 {
303 m_view->chart()->addSeries(m_series);
303 m_view->chart()->addSeries(m_series);
304 QSignalSpy removedSpy(m_series, SIGNAL(removed(QList<QPieSlice*>)));
304 QSignalSpy removedSpy(m_series, SIGNAL(removed(QList<QPieSlice*>)));
305
305
306 // add some slices
306 // add some slices
307 QPieSlice *slice1 = m_series->append("slice 1", 1);
307 QPieSlice *slice1 = m_series->append("slice 1", 1);
308 QPieSlice *slice2 = m_series->append("slice 2", 2);
308 QPieSlice *slice2 = m_series->append("slice 2", 2);
309 QPieSlice *slice3 = m_series->append("slice 3", 3);
309 QPieSlice *slice3 = m_series->append("slice 3", 3);
310 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
310 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
311 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
311 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
312 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
312 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
313 QCOMPARE(m_series->count(), 3);
313 QCOMPARE(m_series->count(), 3);
314
314
315 // null pointer remove
315 // null pointer remove
316 QVERIFY(!m_series->remove(0));
316 QVERIFY(!m_series->remove(0));
317
317
318 // remove first
318 // remove first
319 QVERIFY(m_series->remove(slice1));
319 QVERIFY(m_series->remove(slice1));
320 QVERIFY(!m_series->remove(slice1));
320 QVERIFY(!m_series->remove(slice1));
321 QCOMPARE(m_series->count(), 2);
321 QCOMPARE(m_series->count(), 2);
322 QCOMPARE(m_series->slices().at(0)->label(), slice2->label());
322 QCOMPARE(m_series->slices().at(0)->label(), slice2->label());
323 QCOMPARE(removedSpy.count(), 1);
323 QCOMPARE(removedSpy.count(), 1);
324 QList<QPieSlice*> removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(0).at(0));
324 QList<QPieSlice*> removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(0).at(0));
325 QCOMPARE(removed.count(), 1);
325 QCOMPARE(removed.count(), 1);
326 QCOMPARE(removed.first(), slice1);
326 QCOMPARE(removed.first(), slice1);
327
327
328 // remove all
328 // remove all
329 m_series->clear();
329 m_series->clear();
330 QVERIFY(m_series->isEmpty());
330 QVERIFY(m_series->isEmpty());
331 QVERIFY(m_series->slices().isEmpty());
331 QVERIFY(m_series->slices().isEmpty());
332 QCOMPARE(m_series->count(), 0);
332 QCOMPARE(m_series->count(), 0);
333 QCOMPARE(removedSpy.count(), 2);
333 QCOMPARE(removedSpy.count(), 2);
334 removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(1).at(0));
334 removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(1).at(0));
335 QCOMPARE(removed.count(), 2);
335 QCOMPARE(removed.count(), 2);
336 QCOMPARE(removed.first(), slice2);
336 QCOMPARE(removed.first(), slice2);
337 QCOMPARE(removed.last(), slice3);
337 QCOMPARE(removed.last(), slice3);
338
338
339 // check that slices were actually destroyed
339 // check that slices were actually destroyed
340 TRY_COMPARE(spy1.count(), 1);
340 TRY_COMPARE(spy1.count(), 1);
341 TRY_COMPARE(spy2.count(), 1);
341 TRY_COMPARE(spy2.count(), 1);
342 TRY_COMPARE(spy3.count(), 1);
342 TRY_COMPARE(spy3.count(), 1);
343 }
343 }
344
344
345 void tst_qpieseries::removeAnimated()
345 void tst_qpieseries::removeAnimated()
346 {
346 {
347 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
347 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
348 remove();
348 remove();
349 }
349 }
350
350
351 void tst_qpieseries::take()
351 void tst_qpieseries::take()
352 {
352 {
353 m_view->chart()->addSeries(m_series);
353 m_view->chart()->addSeries(m_series);
354 QSignalSpy removedSpy(m_series, SIGNAL(removed(QList<QPieSlice*>)));
354 QSignalSpy removedSpy(m_series, SIGNAL(removed(QList<QPieSlice*>)));
355
355
356 // add some slices
356 // add some slices
357 QPieSlice *slice1 = m_series->append("slice 1", 1);
357 QPieSlice *slice1 = m_series->append("slice 1", 1);
358 QPieSlice *slice2 = m_series->append("slice 2", 2);
358 QPieSlice *slice2 = m_series->append("slice 2", 2);
359 m_series->append("slice 3", 3);
359 m_series->append("slice 3", 3);
360 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
360 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
361 QCOMPARE(m_series->count(), 3);
361 QCOMPARE(m_series->count(), 3);
362
362
363 // null pointer remove
363 // null pointer remove
364 QVERIFY(!m_series->take(0));
364 QVERIFY(!m_series->take(0));
365
365
366 // take first
366 // take first
367 QVERIFY(m_series->take(slice1));
367 QVERIFY(m_series->take(slice1));
368 TRY_COMPARE(spy1.count(), 0);
368 TRY_COMPARE(spy1.count(), 0);
369 QVERIFY(slice1->parent() == m_series); // series is still the parent object
369 QVERIFY(slice1->parent() == m_series); // series is still the parent object
370 QVERIFY(!m_series->take(slice1));
370 QVERIFY(!m_series->take(slice1));
371 QCOMPARE(m_series->count(), 2);
371 QCOMPARE(m_series->count(), 2);
372 QCOMPARE(m_series->slices().at(0)->label(), slice2->label());
372 QCOMPARE(m_series->slices().at(0)->label(), slice2->label());
373 QCOMPARE(removedSpy.count(), 1);
373 QCOMPARE(removedSpy.count(), 1);
374 QList<QPieSlice*> removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(0).at(0));
374 QList<QPieSlice*> removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(0).at(0));
375 QCOMPARE(removed.count(), 1);
375 QCOMPARE(removed.count(), 1);
376 QCOMPARE(removed.first(), slice1);
376 QCOMPARE(removed.first(), slice1);
377 }
377 }
378
378
379 void tst_qpieseries::takeAnimated()
379 void tst_qpieseries::takeAnimated()
380 {
380 {
381 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
381 m_view->chart()->setAnimationOptions(QChart::AllAnimations);
382 take();
382 take();
383 }
383 }
384
384
385 void tst_qpieseries::calculatedValues()
385 void tst_qpieseries::calculatedValues()
386 {
386 {
387 m_view->chart()->addSeries(m_series);
387 m_view->chart()->addSeries(m_series);
388
388
389 QPieSlice *slice1 = new QPieSlice("slice 1", 1);
389 QPieSlice *slice1 = new QPieSlice("slice 1", 1);
390 QSignalSpy percentageSpy(slice1, SIGNAL(percentageChanged()));
390 QSignalSpy percentageSpy(slice1, SIGNAL(percentageChanged()));
391 QSignalSpy startAngleSpy(slice1, SIGNAL(startAngleChanged()));
391 QSignalSpy startAngleSpy(slice1, SIGNAL(startAngleChanged()));
392 QSignalSpy angleSpanSpy(slice1, SIGNAL(angleSpanChanged()));
392 QSignalSpy angleSpanSpy(slice1, SIGNAL(angleSpanChanged()));
393
393
394 // add a slice
394 // add a slice
395 m_series->append(slice1);
395 m_series->append(slice1);
396 bool ok;
396 bool ok;
397 verifyCalculatedData(*m_series, &ok);
397 verifyCalculatedData(*m_series, &ok);
398 if (!ok)
398 if (!ok)
399 return;
399 return;
400 QCOMPARE(percentageSpy.count(), 1);
400 QCOMPARE(percentageSpy.count(), 1);
401 QCOMPARE(startAngleSpy.count(), 0);
401 QCOMPARE(startAngleSpy.count(), 0);
402 QCOMPARE(angleSpanSpy.count(), 1);
402 QCOMPARE(angleSpanSpy.count(), 1);
403
403
404 // add some more slices
404 // add some more slices
405 QList<QPieSlice *> list;
405 QList<QPieSlice *> list;
406 list << new QPieSlice("slice 2", 2);
406 list << new QPieSlice("slice 2", 2);
407 list << new QPieSlice("slice 3", 3);
407 list << new QPieSlice("slice 3", 3);
408 m_series->append(list);
408 m_series->append(list);
409 verifyCalculatedData(*m_series, &ok);
409 verifyCalculatedData(*m_series, &ok);
410 if (!ok)
410 if (!ok)
411 return;
411 return;
412 QCOMPARE(percentageSpy.count(), 2);
412 QCOMPARE(percentageSpy.count(), 2);
413 QCOMPARE(startAngleSpy.count(), 0);
413 QCOMPARE(startAngleSpy.count(), 0);
414 QCOMPARE(angleSpanSpy.count(), 2);
414 QCOMPARE(angleSpanSpy.count(), 2);
415
415
416 // remove a slice
416 // remove a slice
417 m_series->remove(list.first()); // remove slice 2
417 m_series->remove(list.first()); // remove slice 2
418 verifyCalculatedData(*m_series, &ok);
418 verifyCalculatedData(*m_series, &ok);
419 if (!ok)
419 if (!ok)
420 return;
420 return;
421 QCOMPARE(percentageSpy.count(), 3);
421 QCOMPARE(percentageSpy.count(), 3);
422 QCOMPARE(startAngleSpy.count(), 0);
422 QCOMPARE(startAngleSpy.count(), 0);
423 QCOMPARE(angleSpanSpy.count(), 3);
423 QCOMPARE(angleSpanSpy.count(), 3);
424
424
425 // insert a slice
425 // insert a slice
426 m_series->insert(0, new QPieSlice("Slice 4", 4));
426 m_series->insert(0, new QPieSlice("Slice 4", 4));
427 verifyCalculatedData(*m_series, &ok);
427 verifyCalculatedData(*m_series, &ok);
428 if (!ok)
428 if (!ok)
429 return;
429 return;
430 QCOMPARE(percentageSpy.count(), 4);
430 QCOMPARE(percentageSpy.count(), 4);
431 QCOMPARE(startAngleSpy.count(), 1);
431 QCOMPARE(startAngleSpy.count(), 1);
432 QCOMPARE(angleSpanSpy.count(), 4);
432 QCOMPARE(angleSpanSpy.count(), 4);
433
433
434 // modify pie angles
434 // modify pie angles
435 m_series->setPieStartAngle(-90);
435 m_series->setPieStartAngle(-90);
436 m_series->setPieEndAngle(90);
436 m_series->setPieEndAngle(90);
437 verifyCalculatedData(*m_series, &ok);
437 verifyCalculatedData(*m_series, &ok);
438 if (!ok)
438 if (!ok)
439 return;
439 return;
440 QCOMPARE(percentageSpy.count(), 4);
440 QCOMPARE(percentageSpy.count(), 4);
441 QCOMPARE(startAngleSpy.count(), 3);
441 QCOMPARE(startAngleSpy.count(), 3);
442 QCOMPARE(angleSpanSpy.count(), 6);
442 QCOMPARE(angleSpanSpy.count(), 6);
443
443
444 // clear all
444 // clear all
445 m_series->clear();
445 m_series->clear();
446 verifyCalculatedData(*m_series, &ok);
446 verifyCalculatedData(*m_series, &ok);
447 if (!ok)
447 if (!ok)
448 return;
448 return;
449 QCOMPARE(percentageSpy.count(), 4);
449 QCOMPARE(percentageSpy.count(), 4);
450 QCOMPARE(startAngleSpy.count(), 3);
450 QCOMPARE(startAngleSpy.count(), 3);
451 QCOMPARE(angleSpanSpy.count(), 6);
451 QCOMPARE(angleSpanSpy.count(), 6);
452 }
452 }
453
453
454 void tst_qpieseries::verifyCalculatedData(const QPieSeries &series, bool *ok)
454 void tst_qpieseries::verifyCalculatedData(const QPieSeries &series, bool *ok)
455 {
455 {
456 *ok = false;
456 *ok = false;
457
457
458 qreal sum = 0;
458 qreal sum = 0;
459 foreach (const QPieSlice *slice, series.slices())
459 foreach (const QPieSlice *slice, series.slices())
460 sum += slice->value();
460 sum += slice->value();
461 QCOMPARE(series.sum(), sum);
461 QCOMPARE(series.sum(), sum);
462
462
463 qreal startAngle = series.pieStartAngle();
463 qreal startAngle = series.pieStartAngle();
464 qreal pieAngleSpan = series.pieEndAngle() - series.pieStartAngle();
464 qreal pieAngleSpan = series.pieEndAngle() - series.pieStartAngle();
465 foreach (const QPieSlice *slice, series.slices()) {
465 foreach (const QPieSlice *slice, series.slices()) {
466 qreal ratio = slice->value() / sum;
466 qreal ratio = slice->value() / sum;
467 qreal sliceSpan = pieAngleSpan * ratio;
467 qreal sliceSpan = pieAngleSpan * ratio;
468 QCOMPARE(slice->startAngle(), startAngle);
468 QCOMPARE(slice->startAngle(), startAngle);
469 QCOMPARE(slice->angleSpan(), sliceSpan);
469 QCOMPARE(slice->angleSpan(), sliceSpan);
470 QCOMPARE(slice->percentage(), ratio);
470 QCOMPARE(slice->percentage(), ratio);
471 startAngle += sliceSpan;
471 startAngle += sliceSpan;
472 }
472 }
473
473
474 if (!series.isEmpty())
474 if (!series.isEmpty())
475 QCOMPARE(series.slices().last()->startAngle() + series.slices().last()->angleSpan(), series.pieEndAngle());
475 QCOMPARE(series.slices().last()->startAngle() + series.slices().last()->angleSpan(), series.pieEndAngle());
476
476
477 *ok = true;
477 *ok = true;
478 }
478 }
479
479
480
480
481 void tst_qpieseries::clickedSignal()
481 void tst_qpieseries::clickedSignal()
482 {
482 {
483 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
484
483 // add some slices
485 // add some slices
484 QPieSlice *s1 = m_series->append("slice 1", 1);
486 QPieSlice *s1 = m_series->append("slice 1", 1);
485 QPieSlice *s2 = m_series->append("slice 2", 1);
487 QPieSlice *s2 = m_series->append("slice 2", 1);
486 QPieSlice *s3 = m_series->append("slice 3", 1);
488 QPieSlice *s3 = m_series->append("slice 3", 1);
487 QPieSlice *s4 = m_series->append("slice 4", 1);
489 QPieSlice *s4 = m_series->append("slice 4", 1);
488 QSignalSpy clickSpy(m_series, SIGNAL(clicked(QPieSlice*)));
490 QSignalSpy clickSpy(m_series, SIGNAL(clicked(QPieSlice*)));
489
491
490 // add series to the chart
492 // add series to the chart
491 m_view->chart()->legend()->setVisible(false);
493 m_view->chart()->legend()->setVisible(false);
492 m_view->resize(200, 200);
494 m_view->resize(200, 200);
493 m_view->chart()->addSeries(m_series);
495 m_view->chart()->addSeries(m_series);
494 m_view->show();
496 m_view->show();
495 QTest::qWaitForWindowShown(m_view);
497 QTest::qWaitForWindowShown(m_view);
496
498
497 // if you divide the chart in four equal tiles these
499 // if you divide the chart in four equal tiles these
498 // are the center points of those tiles
500 // are the center points of those tiles
499 QPoint p1(90.25, 90);
501 QPoint p1(90.25, 90);
500 QPoint p2(150, 90);
502 QPoint p2(150, 90);
501 QPoint p3(90, 150);
503 QPoint p3(90, 150);
502 QPoint p4(150, 150);
504 QPoint p4(150, 150);
503
505
504 QPoint center(120, 120);
506 QPoint center(120, 120);
505
507
506 m_series->setPieSize(1.0);
508 m_series->setPieSize(1.0);
507 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
509 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
508 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
510 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
509 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
511 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
510 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
512 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
511 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
513 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
512 TRY_COMPARE(clickSpy.count(), 5); // all hit
514 TRY_COMPARE(clickSpy.count(), 5); // all hit
513 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s4);
515 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s4);
514 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s1);
516 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s1);
515 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
517 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
516 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s2);
518 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s2);
517 clickSpy.clear();
519 clickSpy.clear();
518
520
519 m_series->setPieSize(0.5);
521 m_series->setPieSize(0.5);
520 m_series->setVerticalPosition(0.25);
522 m_series->setVerticalPosition(0.25);
521 m_series->setHorizontalPosition(0.25);
523 m_series->setHorizontalPosition(0.25);
522 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1); // hits
524 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1); // hits
523 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
525 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
524 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
526 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
525 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
527 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
526 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
528 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
527 TRY_COMPARE(clickSpy.count(), 1);
529 TRY_COMPARE(clickSpy.count(), 1);
528 clickSpy.clear();
530 clickSpy.clear();
529
531
530 m_series->setVerticalPosition(0.25);
532 m_series->setVerticalPosition(0.25);
531 m_series->setHorizontalPosition(0.75);
533 m_series->setHorizontalPosition(0.75);
532 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
534 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
533 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2); // hits
535 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2); // hits
534 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
536 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
535 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
537 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
536 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
538 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
537 TRY_COMPARE(clickSpy.count(), 1);
539 TRY_COMPARE(clickSpy.count(), 1);
538 clickSpy.clear();
540 clickSpy.clear();
539
541
540 m_series->setVerticalPosition(0.75);
542 m_series->setVerticalPosition(0.75);
541 m_series->setHorizontalPosition(0.25);
543 m_series->setHorizontalPosition(0.25);
542 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
544 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
543 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
545 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
544 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3); // hits
546 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3); // hits
545 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
547 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4);
546 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
548 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
547 TRY_COMPARE(clickSpy.count(), 1);
549 TRY_COMPARE(clickSpy.count(), 1);
548 clickSpy.clear();
550 clickSpy.clear();
549
551
550 m_series->setVerticalPosition(0.75);
552 m_series->setVerticalPosition(0.75);
551 m_series->setHorizontalPosition(0.75);
553 m_series->setHorizontalPosition(0.75);
552 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
554 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p1);
553 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
555 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p2);
554 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
556 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p3);
555 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4); // hits
557 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, p4); // hits
556 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
558 QTest::mouseClick(m_view->viewport(), Qt::LeftButton, 0, center);
557 TRY_COMPARE(clickSpy.count(), 1);
559 TRY_COMPARE(clickSpy.count(), 1);
558 clickSpy.clear();
560 clickSpy.clear();
559 }
561 }
560
562
561 void tst_qpieseries::hoverSignal()
563 void tst_qpieseries::hoverSignal()
562 {
564 {
565 SKIP_IF_CANNOT_TEST_MOUSE_EVENTS();
566
563 // add some slices
567 // add some slices
564 m_series->setPieSize(1.0);
568 m_series->setPieSize(1.0);
565 QPieSlice *s1 = m_series->append("slice 1", 1);
569 QPieSlice *s1 = m_series->append("slice 1", 1);
566 m_series->append("slice 2", 2);
570 m_series->append("slice 2", 2);
567 m_series->append("slice 3", 3);
571 m_series->append("slice 3", 3);
568
572
569 // add series to the chart
573 // add series to the chart
570 m_view->chart()->legend()->setVisible(false);
574 m_view->chart()->legend()->setVisible(false);
571 m_view->resize(200, 200);
575 m_view->resize(200, 200);
572 m_view->chart()->addSeries(m_series);
576 m_view->chart()->addSeries(m_series);
573 m_view->show();
577 m_view->show();
574 QTest::qWaitForWindowShown(m_view);
578 QTest::qWaitForWindowShown(m_view);
575
579
576 // first move to right top corner
580 // first move to right top corner
577 QTest::mouseMove(m_view->viewport(), QPoint(200, 0));
581 QTest::mouseMove(m_view->viewport(), QPoint(200, 0));
578 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
582 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
579
583
580 // move inside the slice
584 // move inside the slice
581 // pie rectangle: QRectF(60,60 121x121)
585 // pie rectangle: QRectF(60,60 121x121)
582 QSignalSpy hoverSpy(m_series, SIGNAL(hovered(QPieSlice*,bool)));
586 QSignalSpy hoverSpy(m_series, SIGNAL(hovered(QPieSlice*,bool)));
583 QTest::mouseMove(m_view->viewport(), QPoint(139, 85));
587 QTest::mouseMove(m_view->viewport(), QPoint(139, 85));
584 TRY_COMPARE(hoverSpy.count(), 1);
588 TRY_COMPARE(hoverSpy.count(), 1);
585 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(0).at(0)), s1);
589 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(0).at(0)), s1);
586 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(1)), true);
590 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(1)), true);
587
591
588 // move outside the slice
592 // move outside the slice
589 QTest::mouseMove(m_view->viewport(), QPoint(200, 0));
593 QTest::mouseMove(m_view->viewport(), QPoint(200, 0));
590 TRY_COMPARE(hoverSpy.count(), 2);
594 TRY_COMPARE(hoverSpy.count(), 2);
591 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(1).at(0)), s1);
595 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(1).at(0)), s1);
592 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(1)), false);
596 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(1)), false);
593 }
597 }
594
598
595 void tst_qpieseries::sliceSeries()
599 void tst_qpieseries::sliceSeries()
596 {
600 {
597 QPieSlice *slice = new QPieSlice();
601 QPieSlice *slice = new QPieSlice();
598 QVERIFY(!slice->series());
602 QVERIFY(!slice->series());
599 delete slice;
603 delete slice;
600
604
601 slice = new QPieSlice(m_series);
605 slice = new QPieSlice(m_series);
602 QVERIFY(!slice->series());
606 QVERIFY(!slice->series());
603
607
604 m_series->append(slice);
608 m_series->append(slice);
605 QCOMPARE(slice->series(), m_series);
609 QCOMPARE(slice->series(), m_series);
606
610
607 slice = new QPieSlice();
611 slice = new QPieSlice();
608 m_series->insert(0, slice);
612 m_series->insert(0, slice);
609 QCOMPARE(slice->series(), m_series);
613 QCOMPARE(slice->series(), m_series);
610
614
611 m_series->take(slice);
615 m_series->take(slice);
612 QCOMPARE(slice->series(), (QPieSeries*) 0);
616 QCOMPARE(slice->series(), (QPieSeries*) 0);
613 }
617 }
614
618
615 void tst_qpieseries::destruction()
619 void tst_qpieseries::destruction()
616 {
620 {
617 // add some slices
621 // add some slices
618 QPieSlice *slice1 = m_series->append("slice 1", 1);
622 QPieSlice *slice1 = m_series->append("slice 1", 1);
619 QPieSlice *slice2 = m_series->append("slice 2", 2);
623 QPieSlice *slice2 = m_series->append("slice 2", 2);
620 QPieSlice *slice3 = m_series->append("slice 3", 3);
624 QPieSlice *slice3 = m_series->append("slice 3", 3);
621 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
625 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
622 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
626 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
623 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
627 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
624
628
625 // destroy series
629 // destroy series
626 delete m_series;
630 delete m_series;
627 m_series = 0;
631 m_series = 0;
628
632
629 // check that series has destroyed its slices
633 // check that series has destroyed its slices
630 QCOMPARE(spy1.count(), 1);
634 QCOMPARE(spy1.count(), 1);
631 QCOMPARE(spy2.count(), 1);
635 QCOMPARE(spy2.count(), 1);
632 QCOMPARE(spy3.count(), 1);
636 QCOMPARE(spy3.count(), 1);
633 }
637 }
634
638
635 QTEST_MAIN(tst_qpieseries)
639 QTEST_MAIN(tst_qpieseries)
636
640
637 #include "tst_qpieseries.moc"
641 #include "tst_qpieseries.moc"
638
642
General Comments 0
You need to be logged in to leave comments. Login now