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

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

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