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

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

tst_qpieseries: check added/removed signals
Jani Honkonen -
r1291:eefcc7931b49
parent child
Show More
Side by Side Unified
Context file:
r1291:eefcc7931b49 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,472 +1,519
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2012 Digia Plc
4 4 ** All rights reserved.
5 5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 6 **
7 7 ** This file is part of the Qt Commercial Charts Add-on.
8 8 **
9 9 ** $QT_BEGIN_LICENSE$
10 10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 11 ** accordance with the Qt Commercial License Agreement provided with the
12 12 ** Software or, alternatively, in accordance with the terms contained in
13 13 ** a written agreement between you and Digia.
14 14 **
15 15 ** If you have questions regarding the use of this file, please use
16 16 ** contact form at http://qt.digia.com
17 17 ** $QT_END_LICENSE$
18 18 **
19 19 ****************************************************************************/
20 20
21 21 #include <QtTest/QtTest>
22 22 #include <qchartview.h>
23 23 #include <qchart.h>
24 24 #include <qpieseries.h>
25 25 #include <qpieslice.h>
26 26 #include <qpiemodelmapper.h>
27 27 #include <QStandardItemModel>
28 28 #include <tst_definitions.h>
29 29
30 30 QTCOMMERCIALCHART_USE_NAMESPACE
31 31
32 32 Q_DECLARE_METATYPE(QPieSlice*)
33 Q_DECLARE_METATYPE(QList<QPieSlice*>)
33 34
34 35 class tst_qpieseries : public QObject
35 36 {
36 37 Q_OBJECT
37 38
38 39 public slots:
39 40 void initTestCase();
40 41 void cleanupTestCase();
41 42 void init();
42 43 void cleanup();
43 44
44 45 private slots:
45 46 void properties();
46 47 void append();
47 48 void insert();
48 49 void remove();
49 50 void calculatedValues();
50 51 void clickedSignal();
51 52 void hoverSignal();
52 53
53 54 private:
54 55 void verifyCalculatedData(const QPieSeries &series, bool *ok);
55 56
56 57 private:
57 58
58 59 };
59 60
60 61 void tst_qpieseries::initTestCase()
61 62 {
62 63 qRegisterMetaType<QPieSlice*>("QPieSlice*");
64 qRegisterMetaType<QList<QPieSlice*> >("QList<QPieSlice*>");
63 65 }
64 66
65 67 void tst_qpieseries::cleanupTestCase()
66 68 {
67 69 }
68 70
69 71 void tst_qpieseries::init()
70 72 {
71 73
72 74 }
73 75
74 76 void tst_qpieseries::cleanup()
75 77 {
76 78
77 79 }
78 80
79 81 void tst_qpieseries::properties()
80 82 {
81 83 QPieSeries s;
82 84
83 85 QSignalSpy countSpy(&s, SIGNAL(countChanged()));
84 86 QSignalSpy sumSpy(&s, SIGNAL(sumChanged()));
85 87 QSignalSpy sizeSpy(&s, SIGNAL(pieSizeChanged()));
86 88 QSignalSpy startAngleSpy(&s, SIGNAL(pieStartAngleChanged()));
87 89 QSignalSpy endAngleSpy(&s, SIGNAL(pieEndAngleChanged()));
88 90 QSignalSpy horPosSpy(&s, SIGNAL(horizontalPositionChanged()));
89 91 QSignalSpy verPosSpy(&s, SIGNAL(verticalPositionChanged()));
90 92
91 93 QVERIFY(s.type() == QAbstractSeries::SeriesTypePie);
92 94 QVERIFY(s.count() == 0);
93 95 QVERIFY(s.isEmpty());
94 96 QCOMPARE(s.sum(), 0.0);
95 97 QCOMPARE(s.horizontalPosition(), 0.5);
96 98 QCOMPARE(s.verticalPosition(), 0.5);
97 99 QCOMPARE(s.pieSize(), 0.7);
98 100 QCOMPARE(s.pieStartAngle(), 0.0);
99 101 QCOMPARE(s.pieEndAngle(), 360.0);
100 102
101 103 s.append("s1", 1);
102 104 s.append("s2", 1);
103 105 s.append("s3", 1);
104 106 s.insert(1, new QPieSlice("s4", 1));
105 107 s.remove(s.slices().first());
106 108 QCOMPARE(s.count(), 3);
107 109 QCOMPARE(s.sum(), 3.0);
108 110 s.clear();
109 111 QCOMPARE(s.count(), 0);
110 112 QCOMPARE(s.sum(), 0.0);
111 113 QCOMPARE(countSpy.count(), 6);
112 114 QCOMPARE(sumSpy.count(), 6);
113 115
114 116 s.setPieSize(-1.0);
115 117 QCOMPARE(s.pieSize(), 0.0);
116 118 s.setPieSize(0.0);
117 119 s.setPieSize(0.9);
118 120 s.setPieSize(2.0);
119 121 QCOMPARE(s.pieSize(), 1.0);
120 122 QCOMPARE(sizeSpy.count(), 3);
121 123
122 124 s.setPieStartAngle(0);
123 125 s.setPieStartAngle(-180);
124 126 s.setPieStartAngle(180);
125 127 QCOMPARE(startAngleSpy.count(), 2);
126 128
127 129 s.setPieEndAngle(360);
128 130 s.setPieEndAngle(-180);
129 131 s.setPieEndAngle(180);
130 132 QCOMPARE(endAngleSpy.count(), 2);
131 133
132 134 s.setHorizontalPosition(0.5);
133 135 s.setHorizontalPosition(-1.0);
134 136 QCOMPARE(s.horizontalPosition(), 0.0);
135 137 s.setHorizontalPosition(1.0);
136 138 s.setHorizontalPosition(2.0);
137 139 QCOMPARE(s.horizontalPosition(), 1.0);
138 140 QCOMPARE(horPosSpy.count(), 2);
139 141
140 142 s.setVerticalPosition(0.5);
141 143 s.setVerticalPosition(-1.0);
142 144 QCOMPARE(s.verticalPosition(), 0.0);
143 145 s.setVerticalPosition(1.0);
144 146 s.setVerticalPosition(2.0);
145 147 QCOMPARE(s.verticalPosition(), 1.0);
146 148 QCOMPARE(verPosSpy.count(), 2);
147 149 }
148 150
149 151 void tst_qpieseries::append()
150 152 {
151 153 QPieSeries s;
154 QSignalSpy addedSpy(&s, SIGNAL(added(QList<QPieSlice*>)));
152 155
153 156 // append pointer
154 157 QPieSlice *slice1 = 0;
155 158 QVERIFY(!s.append(slice1));
156 159 slice1 = new QPieSlice("slice 1", 1);
157 160 QVERIFY(s.append(slice1));
158 161 QVERIFY(!s.append(slice1));
159 162 QCOMPARE(s.count(), 1);
163 QCOMPARE(addedSpy.count(), 1);
164 QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0));
165 QCOMPARE(added.count(), 1);
166 QCOMPARE(added.first(), slice1);
160 167
161 168 // append pointer list
162 169 QList<QPieSlice *> list;
163 170 QVERIFY(!s.append(list));
164 171 list << (QPieSlice *) 0;
165 172 QVERIFY(!s.append(list));
166 173 list.clear();
167 174 list << new QPieSlice("slice 2", 2);
168 175 list << new QPieSlice("slice 3", 3);
169 176 QVERIFY(s.append(list));
170 177 QVERIFY(!s.append(list));
171 178 QCOMPARE(s.count(), 3);
179 QCOMPARE(addedSpy.count(), 2);
180 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0));
181 QCOMPARE(added.count(), 2);
182 QCOMPARE(added, list);
172 183
173 184 // append operator
174 s << new QPieSlice("slice 4", 4);
185 QPieSlice *slice4 = new QPieSlice("slice 4", 4);
186 s << slice4;
175 187 s << slice1; // fails because already added
176 188 QCOMPARE(s.count(), 4);
189 QCOMPARE(addedSpy.count(), 3);
190 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0));
191 QCOMPARE(added.count(), 1);
192 QCOMPARE(added.first(), slice4);
177 193
178 194 // append with params
179 195 QPieSlice *slice5 = s.append("slice 5", 5);
180 196 QVERIFY(slice5 != 0);
181 197 QCOMPARE(slice5->value(), 5.0);
182 198 QCOMPARE(slice5->label(), QString("slice 5"));
183 199 QCOMPARE(s.count(), 5);
200 QCOMPARE(addedSpy.count(), 4);
201 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0));
202 QCOMPARE(added.count(), 1);
203 QCOMPARE(added.first(), slice5);
184 204
185 205 // check slices
186 206 QVERIFY(!s.isEmpty());
187 207 for (int i=0; i<s.count(); i++) {
188 208 QCOMPARE(s.slices().at(i)->value(), (qreal) i+1);
189 209 QCOMPARE(s.slices().at(i)->label(), QString("slice ") + QString::number(i+1));
190 210 }
191 211 }
192 212
193 213 void tst_qpieseries::insert()
194 214 {
195 215 QPieSeries s;
216 QSignalSpy addedSpy(&s, SIGNAL(added(QList<QPieSlice*>)));
196 217
197 218 // insert one slice
198 219 QPieSlice *slice1 = 0;
199 220 QVERIFY(!s.insert(0, slice1));
200 221 slice1 = new QPieSlice("slice 1", 1);
201 222 QVERIFY(!s.insert(-1, slice1));
202 223 QVERIFY(!s.insert(5, slice1));
203 224 QVERIFY(s.insert(0, slice1));
204 225 QVERIFY(!s.insert(0, slice1));
205 226 QCOMPARE(s.count(), 1);
227 QCOMPARE(addedSpy.count(), 1);
228 QList<QPieSlice*> added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(0).at(0));
229 QCOMPARE(added.count(), 1);
230 QCOMPARE(added.first(), slice1);
206 231
207 232 // add some more slices
208 s.append("slice 2", 2);
209 s.append("slice 4", 4);
233 QPieSlice *slice2 = s.append("slice 2", 2);
234 QPieSlice *slice4 = s.append("slice 4", 4);
210 235 QCOMPARE(s.count(), 3);
236 QCOMPARE(addedSpy.count(), 3);
237 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(1).at(0));
238 QCOMPARE(added.count(), 1);
239 QCOMPARE(added.first(), slice2);
240 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(2).at(0));
241 QCOMPARE(added.count(), 1);
242 QCOMPARE(added.first(), slice4);
211 243
212 244 // insert between slices
213 s.insert(2, new QPieSlice("slice 3", 3));
245 QPieSlice *slice3 = new QPieSlice("slice 3", 3);
246 s.insert(2, slice3);
214 247 QCOMPARE(s.count(), 4);
248 QCOMPARE(addedSpy.count(), 4);
249 added = qvariant_cast<QList<QPieSlice*> >(addedSpy.at(3).at(0));
250 QCOMPARE(added.count(), 1);
251 QCOMPARE(added.first(), slice3);
215 252
216 253 // check slices
217 254 for (int i=0; i<s.count(); i++) {
218 255 QCOMPARE(s.slices().at(i)->value(), (qreal) i+1);
219 256 QCOMPARE(s.slices().at(i)->label(), QString("slice ") + QString::number(i+1));
220 257 }
221 258 }
222 259
223 260 void tst_qpieseries::remove()
224 261 {
225 262 QPieSeries s;
263 QSignalSpy removedSpy(&s, SIGNAL(removed(QList<QPieSlice*>)));
226 264
227 265 // add some slices
228 266 QPieSlice *slice1 = s.append("slice 1", 1);
229 267 QPieSlice *slice2 = s.append("slice 2", 2);
230 268 QPieSlice *slice3 = s.append("slice 3", 3);
231 269 QSignalSpy spy1(slice1, SIGNAL(destroyed()));
232 270 QSignalSpy spy2(slice2, SIGNAL(destroyed()));
233 271 QSignalSpy spy3(slice3, SIGNAL(destroyed()));
234 272 QCOMPARE(s.count(), 3);
235 273
236 274 // null pointer remove
237 275 QVERIFY(!s.remove(0));
238 276
239 277 // remove first
240 278 QVERIFY(s.remove(slice1));
241 279 QVERIFY(!s.remove(slice1));
242 280 QCOMPARE(s.count(), 2);
243 281 QCOMPARE(s.slices().at(0)->label(), slice2->label());
282 QCOMPARE(removedSpy.count(), 1);
283 QList<QPieSlice*> removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(0).at(0));
284 QCOMPARE(removed.count(), 1);
285 QCOMPARE(removed.first(), slice1);
244 286
245 287 // remove all
246 288 s.clear();
247 289 QVERIFY(s.isEmpty());
248 290 QVERIFY(s.slices().isEmpty());
249 291 QCOMPARE(s.count(), 0);
292 QCOMPARE(removedSpy.count(), 2);
293 removed = qvariant_cast<QList<QPieSlice*> >(removedSpy.at(1).at(0));
294 QCOMPARE(removed.count(), 2);
295 QCOMPARE(removed.first(), slice2);
296 QCOMPARE(removed.last(), slice3);
250 297
251 298 // check that slices were actually destroyed
252 299 TRY_COMPARE(spy1.count(), 1);
253 300 TRY_COMPARE(spy2.count(), 1);
254 301 TRY_COMPARE(spy3.count(), 1);
255 302 }
256 303
257 304 void tst_qpieseries::calculatedValues()
258 305 {
259 306 bool ok;
260 307 QPieSeries s;
261 308
262 309 QPieSlice *slice1 = new QPieSlice("slice 1", 1);
263 310 QSignalSpy percentageSpy(slice1, SIGNAL(percentageChanged()));
264 311 QSignalSpy startAngleSpy(slice1, SIGNAL(startAngleChanged()));
265 312 QSignalSpy angleSpanSpy(slice1, SIGNAL(angleSpanChanged()));
266 313
267 314 // add a slice
268 315 s.append(slice1);
269 316 verifyCalculatedData(s, &ok);
270 317 if (!ok)
271 318 return;
272 319 QCOMPARE(percentageSpy.count(), 1);
273 320 QCOMPARE(startAngleSpy.count(), 0);
274 321 QCOMPARE(angleSpanSpy.count(), 1);
275 322
276 323 // add some more slices
277 324 QList<QPieSlice *> list;
278 325 list << new QPieSlice("slice 2", 2);
279 326 list << new QPieSlice("slice 3", 3);
280 327 s.append(list);
281 328 verifyCalculatedData(s, &ok);
282 329 if (!ok)
283 330 return;
284 331 QCOMPARE(percentageSpy.count(), 2);
285 332 QCOMPARE(startAngleSpy.count(), 0);
286 333 QCOMPARE(angleSpanSpy.count(), 2);
287 334
288 335 // remove a slice
289 336 s.remove(list.first()); // remove slice 2
290 337 verifyCalculatedData(s, &ok);
291 338 if (!ok)
292 339 return;
293 340 QCOMPARE(percentageSpy.count(), 3);
294 341 QCOMPARE(startAngleSpy.count(), 0);
295 342 QCOMPARE(angleSpanSpy.count(), 3);
296 343
297 344 // insert a slice
298 345 s.insert(0, new QPieSlice("Slice 4", 4));
299 346 verifyCalculatedData(s, &ok);
300 347 if (!ok)
301 348 return;
302 349 QCOMPARE(percentageSpy.count(), 4);
303 350 QCOMPARE(startAngleSpy.count(), 1);
304 351 QCOMPARE(angleSpanSpy.count(), 4);
305 352
306 353 // modify pie angles
307 354 s.setPieStartAngle(-90);
308 355 s.setPieEndAngle(90);
309 356 verifyCalculatedData(s, &ok);
310 357 if (!ok)
311 358 return;
312 359 QCOMPARE(percentageSpy.count(), 4);
313 360 QCOMPARE(startAngleSpy.count(), 3);
314 361 QCOMPARE(angleSpanSpy.count(), 6);
315 362
316 363 // clear all
317 364 s.clear();
318 365 verifyCalculatedData(s, &ok);
319 366 QCOMPARE(percentageSpy.count(), 4);
320 367 QCOMPARE(startAngleSpy.count(), 3);
321 368 QCOMPARE(angleSpanSpy.count(), 6);
322 369 }
323 370
324 371 void tst_qpieseries::verifyCalculatedData(const QPieSeries &series, bool *ok)
325 372 {
326 373 *ok = false;
327 374
328 375 qreal sum = 0;
329 376 foreach (const QPieSlice *slice, series.slices())
330 377 sum += slice->value();
331 378 QCOMPARE(series.sum(), sum);
332 379
333 380 qreal startAngle = series.pieStartAngle();
334 381 qreal pieAngleSpan = series.pieEndAngle() - series.pieStartAngle();
335 382 foreach (const QPieSlice *slice, series.slices()) {
336 383 qreal ratio = slice->value() / sum;
337 384 qreal sliceSpan = pieAngleSpan * ratio;
338 385 QCOMPARE(slice->startAngle(), startAngle);
339 386 QCOMPARE(slice->angleSpan(), sliceSpan);
340 387 QCOMPARE(slice->percentage(), ratio);
341 388 startAngle += sliceSpan;
342 389 }
343 390
344 391 if (!series.isEmpty())
345 392 QCOMPARE(series.slices().last()->startAngle() + series.slices().last()->angleSpan(), series.pieEndAngle());
346 393
347 394 *ok = true;
348 395 }
349 396
350 397
351 398 void tst_qpieseries::clickedSignal()
352 399 {
353 400 // create a pie series
354 401 QPieSeries *series = new QPieSeries();
355 402 QPieSlice *s1 = series->append("slice 1", 1);
356 403 QPieSlice *s2 = series->append("slice 2", 1);
357 404 QPieSlice *s3 = series->append("slice 3", 1);
358 405 QPieSlice *s4 = series->append("slice 4", 1);
359 406 QSignalSpy clickSpy(series, SIGNAL(clicked(QPieSlice*)));
360 407
361 408 // add series to the chart
362 409 QChartView view(new QChart());
363 410 view.chart()->legend()->setVisible(false);
364 411 view.resize(200, 200);
365 412 view.chart()->addSeries(series);
366 413 view.show();
367 414 QTest::qWaitForWindowShown(&view);
368 415
369 416 // if you devide the chart in four equal tiles these
370 417 // are the center points of those tiles
371 418 QPoint p1(90.25, 90);
372 419 QPoint p2(150, 90);
373 420 QPoint p3(90, 150);
374 421 QPoint p4(150, 150);
375 422
376 423 QPoint center(120, 120);
377 424
378 425 series->setPieSize(1.0);
379 426 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p1);
380 427 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p2);
381 428 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p3);
382 429 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p4);
383 430 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, center);
384 431 TRY_COMPARE(clickSpy.count(), 5); // all hit
385 432 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(0).at(0)), s4);
386 433 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(1).at(0)), s1);
387 434 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(2).at(0)), s3);
388 435 QCOMPARE(qvariant_cast<QPieSlice*>(clickSpy.at(3).at(0)), s2);
389 436 clickSpy.clear();
390 437
391 438 series->setPieSize(0.5);
392 439 series->setVerticalPosition(0.25);
393 440 series->setHorizontalPosition(0.25);
394 441 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p1); // hits
395 442 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p2);
396 443 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p3);
397 444 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p4);
398 445 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, center);
399 446 TRY_COMPARE(clickSpy.count(), 1);
400 447 clickSpy.clear();
401 448
402 449 series->setVerticalPosition(0.25);
403 450 series->setHorizontalPosition(0.75);
404 451 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p1);
405 452 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p2); // hits
406 453 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p3);
407 454 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p4);
408 455 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, center);
409 456 TRY_COMPARE(clickSpy.count(), 1);
410 457 clickSpy.clear();
411 458
412 459 series->setVerticalPosition(0.75);
413 460 series->setHorizontalPosition(0.25);
414 461 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p1);
415 462 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p2);
416 463 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p3); // hits
417 464 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p4);
418 465 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, center);
419 466 TRY_COMPARE(clickSpy.count(), 1);
420 467 clickSpy.clear();
421 468
422 469 series->setVerticalPosition(0.75);
423 470 series->setHorizontalPosition(0.75);
424 471 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p1);
425 472 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p2);
426 473 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p3);
427 474 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, p4); // hits
428 475 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0, center);
429 476 TRY_COMPARE(clickSpy.count(), 1);
430 477 clickSpy.clear();
431 478 }
432 479
433 480 void tst_qpieseries::hoverSignal()
434 481 {
435 482 // create a pie series
436 483 QPieSeries *series = new QPieSeries();
437 484 series->setPieSize(1.0);
438 485 QPieSlice *s1 = series->append("slice 1", 1);
439 486 series->append("slice 2", 2);
440 487 series->append("slice 3", 3);
441 488
442 489 // add series to the chart
443 490 QChartView view(new QChart());
444 491 view.chart()->legend()->setVisible(false);
445 492 view.resize(200, 200);
446 493 view.chart()->addSeries(series);
447 494 view.show();
448 495 QTest::qWaitForWindowShown(&view);
449 496
450 497 // first move to right top corner
451 498 QTest::mouseMove(view.viewport(), QPoint(200, 0));
452 499 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
453 500
454 501 // move inside the slice
455 502 // pie rectangle: QRectF(60,60 121x121)
456 503 QSignalSpy hoverSpy(series, SIGNAL(hovered(QPieSlice*,bool)));
457 504 QTest::mouseMove(view.viewport(), QPoint(139, 85));
458 505 TRY_COMPARE(hoverSpy.count(), 1);
459 506 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(0).at(0)), s1);
460 507 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(1)), true);
461 508
462 509 // move outside the slice
463 510 QTest::mouseMove(view.viewport(), QPoint(200, 0));
464 511 TRY_COMPARE(hoverSpy.count(), 2);
465 512 QCOMPARE(qvariant_cast<QPieSlice*>(hoverSpy.at(1).at(0)), s1);
466 513 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(1)), false);
467 514 }
468 515
469 516 QTEST_MAIN(tst_qpieseries)
470 517
471 518 #include "tst_qpieseries.moc"
472 519
General Comments 0
You need to be logged in to leave comments. Login now