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

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

Adds tst_qvaluesaxis stub implementation
Michal Klocek -
r1699:0af2d08df7ac
parent child
Show More
Side by Side Unified
Context file:
r1699:0af2d08df7ac Loading diff...:
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (2120 lines changed) Show them Hide them
@@ -0,0 +1,2120
1 /****************************************************************************
2 **
3 ** Copyright (C) 2012 Digia Plc
4 ** All rights reserved.
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 **
7 ** This file is part of the Qt Commercial Charts Add-on.
8 **
9 ** $QT_BEGIN_LICENSE$
10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 ** accordance with the Qt Commercial License Agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.
14 **
15 ** If you have questions regarding the use of this file, please use
16 ** contact form at http://qt.digia.com
17 ** $QT_END_LICENSE$
18 **
19 ****************************************************************************/
20
21 #include "tst_qabstractaxis.h"
22
23 Q_DECLARE_METATYPE(QPen)
24
25 void tst_QAbstractAxis::initTestCase()
26 {
27 }
28
29 void tst_QAbstractAxis::cleanupTestCase()
30 {
31 }
32
33 void tst_QAbstractAxis::init(QAbstractAxis* axis)
34 {
35 m_axis = axis;
36 m_view = new QChartView(new QChart());
37 m_chart = m_view->chart();
38 }
39
40 void tst_QAbstractAxis::cleanup()
41 {
42
43 delete m_view;
44 m_view = 0;
45 m_chart = 0;
46 m_axis = 0;
47 }
48
49 void tst_QAbstractAxis::qabstractaxis()
50 {
51 QCOMPARE(m_axis->axisPen(), QPen());
52 //TODO QCOMPARE(m_axis->axisPenColor(), QColor());
53 QCOMPARE(m_axis->gridLinePen(), QPen());
54 QCOMPARE(m_axis->isArrowVisible(), true);
55 QCOMPARE(m_axis->isGridLineVisible(), true);
56 QCOMPARE(m_axis->isVisible(), false);
57 QCOMPARE(m_axis->labelsAngle(), 0);
58 QCOMPARE(m_axis->labelsBrush(), QBrush());
59 //TODO QCOMPARE(m_axis->labelsColor(), QColor());
60 QCOMPARE(m_axis->labelsFont(), QFont());
61 QCOMPARE(m_axis->labelsPen(), QPen());
62 QCOMPARE(m_axis->labelsVisible(), true);
63 QCOMPARE(m_axis->orientation(), Qt::Orientation(0));
64 m_axis->setArrowVisible(false);
65 m_axis->setAxisPen(QPen());
66 m_axis->setAxisPenColor(QColor());
67 m_axis->setGridLinePen(QPen());
68 m_axis->setGridLineVisible(false);
69 m_axis->setLabelsAngle(-1);
70 m_axis->setLabelsBrush(QBrush());
71 m_axis->setLabelsColor(QColor());
72 m_axis->setLabelsFont(QFont());
73 m_axis->setLabelsPen(QPen());
74 m_axis->setLabelsVisible(false);
75 m_axis->setMax(QVariant());
76 m_axis->setMin(QVariant());
77 m_axis->setRange(QVariant(), QVariant());
78 m_axis->setShadesBorderColor(QColor());
79 m_axis->setShadesBrush(QBrush());
80 m_axis->setShadesColor(QColor());
81 m_axis->setShadesPen(QPen());
82 m_axis->setShadesVisible(false);
83 m_axis->setVisible(false);
84 //TODO QCOMPARE(m_axis->shadesBorderColor(), QColor());
85 //TODO QCOMPARE(m_axis->shadesBrush(), QBrush());
86 //TODO QCOMPARE(m_axis->shadesColor(), QColor());
87 QCOMPARE(m_axis->shadesPen(), QPen());
88 QCOMPARE(m_axis->shadesVisible(), false);
89 m_axis->show();
90 m_axis->hide();
91 }
92
93 void tst_QAbstractAxis::axisPen_data()
94 {
95 QTest::addColumn<QPen>("axisPen");
96 QTest::newRow("null") << QPen();
97 QTest::newRow("blue") << QPen(Qt::blue);
98 QTest::newRow("black") << QPen(Qt::black);
99 QTest::newRow("red") << QPen(Qt::red);
100 }
101
102 void tst_QAbstractAxis::axisPen()
103 {
104
105 QFETCH(QPen, axisPen);
106
107 QSignalSpy spy0(m_axis, SIGNAL(arrowVisibleChanged(bool)));
108 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
109 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
110 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
111 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
112 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
113 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
114 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
115 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
116
117 m_axis->setAxisPen(axisPen);
118 QCOMPARE(m_axis->axisPen(), axisPen);
119
120 QCOMPARE(spy0.count(), 0);
121 QCOMPARE(spy1.count(), 0);
122 QCOMPARE(spy2.count(), 0);
123 QCOMPARE(spy3.count(), 0);
124 QCOMPARE(spy4.count(), 0);
125 QCOMPARE(spy5.count(), 0);
126 QCOMPARE(spy6.count(), 0);
127 QCOMPARE(spy7.count(), 0);
128 QCOMPARE(spy8.count(), 0);
129
130 }
131
132 void tst_QAbstractAxis::axisPenColor_data()
133 {
134 #if 0
135 QTest::addColumn<QColor>("axisPenColor");
136 QTest::newRow("null") << QColor();
137 #endif
138 }
139
140 void tst_QAbstractAxis::axisPenColor()
141 {
142 #if 0
143 QFETCH(QColor, axisPenColor);
144
145 SubQAbstractAxis axis;
146
147 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
148 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
149 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
150 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
151 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
152 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
153 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
154 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
155 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
156
157 QCOMPARE(axis.axisPenColor(), axisPenColor);
158
159 QCOMPARE(spy0.count(), 0);
160 QCOMPARE(spy1.count(), 0);
161 QCOMPARE(spy2.count(), 0);
162 QCOMPARE(spy3.count(), 0);
163 QCOMPARE(spy4.count(), 0);
164 QCOMPARE(spy5.count(), 0);
165 QCOMPARE(spy6.count(), 0);
166 QCOMPARE(spy7.count(), 0);
167 QCOMPARE(spy8.count(), 0);
168 #endif
169 QSKIP("Test is not implemented.", SkipAll);
170 }
171
172 void tst_QAbstractAxis::gridLinePen_data()
173 {
174
175 QTest::addColumn<QPen>("gridLinePen");
176 QTest::newRow("null") << QPen();
177 QTest::newRow("blue") << QPen(Qt::blue);
178 QTest::newRow("black") << QPen(Qt::black);
179 QTest::newRow("red") << QPen(Qt::red);
180
181 }
182
183 void tst_QAbstractAxis::gridLinePen()
184 {
185 QFETCH(QPen, gridLinePen);
186
187 QSignalSpy spy0(m_axis, SIGNAL(arrowVisibleChanged(bool)));
188 QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
189 QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
190 QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
191 QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
192 QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
193 QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
194 QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
195 QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
196
197 m_axis->setGridLinePen(gridLinePen);
198 QCOMPARE(m_axis->gridLinePen(), gridLinePen);
199
200 QCOMPARE(spy0.count(), 0);
201 QCOMPARE(spy1.count(), 0);
202 QCOMPARE(spy2.count(), 0);
203 QCOMPARE(spy3.count(), 0);
204 QCOMPARE(spy4.count(), 0);
205 QCOMPARE(spy5.count(), 0);
206 QCOMPARE(spy6.count(), 0);
207 QCOMPARE(spy7.count(), 0);
208 QCOMPARE(spy8.count(), 0);
209
210 }
211
212 void tst_QAbstractAxis::hide_data()
213 {
214 QTest::addColumn<int>("foo");
215 QTest::newRow("0") << 0;
216 QTest::newRow("-1") << -1;
217 }
218
219 // public void hide()
220 void tst_QAbstractAxis::hide()
221 {
222 #if 0
223 QFETCH(int, foo);
224
225 SubQAbstractAxis axis;
226
227 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
228 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
229 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
230 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
231 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
232 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
233 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
234 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
235 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
236
237 axis.hide();
238
239 QCOMPARE(spy0.count(), 0);
240 QCOMPARE(spy1.count(), 0);
241 QCOMPARE(spy2.count(), 0);
242 QCOMPARE(spy3.count(), 0);
243 QCOMPARE(spy4.count(), 0);
244 QCOMPARE(spy5.count(), 0);
245 QCOMPARE(spy6.count(), 0);
246 QCOMPARE(spy7.count(), 0);
247 QCOMPARE(spy8.count(), 0);
248 #endif
249 QSKIP("Test is not implemented.", SkipAll);
250 }
251
252 void tst_QAbstractAxis::isArrowVisible_data()
253 {
254 QTest::addColumn<bool>("isArrowVisible");
255 QTest::newRow("true") << true;
256 QTest::newRow("false") << false;
257 }
258
259 // public bool isArrowVisible() const
260 void tst_QAbstractAxis::isArrowVisible()
261 {
262 #if 0
263 QFETCH(bool, isArrowVisible);
264
265 SubQAbstractAxis axis;
266
267 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
268 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
269 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
270 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
271 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
272 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
273 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
274 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
275 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
276
277 QCOMPARE(axis.isArrowVisible(), isArrowVisible);
278
279 QCOMPARE(spy0.count(), 0);
280 QCOMPARE(spy1.count(), 0);
281 QCOMPARE(spy2.count(), 0);
282 QCOMPARE(spy3.count(), 0);
283 QCOMPARE(spy4.count(), 0);
284 QCOMPARE(spy5.count(), 0);
285 QCOMPARE(spy6.count(), 0);
286 QCOMPARE(spy7.count(), 0);
287 QCOMPARE(spy8.count(), 0);
288 #endif
289 QSKIP("Test is not implemented.", SkipAll);
290 }
291
292 void tst_QAbstractAxis::isGridLineVisible_data()
293 {
294 QTest::addColumn<bool>("isGridLineVisible");
295 QTest::newRow("true") << true;
296 QTest::newRow("false") << false;
297 }
298
299 // public bool isGridLineVisible() const
300 void tst_QAbstractAxis::isGridLineVisible()
301 {
302 #if 0
303 QFETCH(bool, isGridLineVisible);
304
305 SubQAbstractAxis axis;
306
307 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
308 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
309 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
310 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
311 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
312 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
313 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
314 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
315 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
316
317 QCOMPARE(axis.isGridLineVisible(), isGridLineVisible);
318
319 QCOMPARE(spy0.count(), 0);
320 QCOMPARE(spy1.count(), 0);
321 QCOMPARE(spy2.count(), 0);
322 QCOMPARE(spy3.count(), 0);
323 QCOMPARE(spy4.count(), 0);
324 QCOMPARE(spy5.count(), 0);
325 QCOMPARE(spy6.count(), 0);
326 QCOMPARE(spy7.count(), 0);
327 QCOMPARE(spy8.count(), 0);
328 #endif
329 QSKIP("Test is not implemented.", SkipAll);
330 }
331
332 void tst_QAbstractAxis::isVisible_data()
333 {
334 QTest::addColumn<bool>("isVisible");
335 QTest::newRow("true") << true;
336 QTest::newRow("false") << false;
337 }
338
339 // public bool isVisible() const
340 void tst_QAbstractAxis::isVisible()
341 {
342 #if 0
343 QFETCH(bool, isVisible);
344
345 SubQAbstractAxis axis;
346
347 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
348 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
349 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
350 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
351 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
352 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
353 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
354 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
355 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
356
357 QCOMPARE(axis.isVisible(), isVisible);
358
359 QCOMPARE(spy0.count(), 0);
360 QCOMPARE(spy1.count(), 0);
361 QCOMPARE(spy2.count(), 0);
362 QCOMPARE(spy3.count(), 0);
363 QCOMPARE(spy4.count(), 0);
364 QCOMPARE(spy5.count(), 0);
365 QCOMPARE(spy6.count(), 0);
366 QCOMPARE(spy7.count(), 0);
367 QCOMPARE(spy8.count(), 0);
368 #endif
369 QSKIP("Test is not implemented.", SkipAll);
370 }
371
372 void tst_QAbstractAxis::labelsAngle_data()
373 {
374 QTest::addColumn<int>("labelsAngle");
375 QTest::newRow("0") << 0;
376 QTest::newRow("-1") << -1;
377 }
378
379 // public int labelsAngle() const
380 void tst_QAbstractAxis::labelsAngle()
381 {
382 #if 0
383 QFETCH(int, labelsAngle);
384
385 SubQAbstractAxis axis;
386
387 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
388 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
389 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
390 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
391 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
392 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
393 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
394 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
395 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
396
397 QCOMPARE(axis.labelsAngle(), labelsAngle);
398
399 QCOMPARE(spy0.count(), 0);
400 QCOMPARE(spy1.count(), 0);
401 QCOMPARE(spy2.count(), 0);
402 QCOMPARE(spy3.count(), 0);
403 QCOMPARE(spy4.count(), 0);
404 QCOMPARE(spy5.count(), 0);
405 QCOMPARE(spy6.count(), 0);
406 QCOMPARE(spy7.count(), 0);
407 QCOMPARE(spy8.count(), 0);
408 #endif
409 QSKIP("Test is not implemented.", SkipAll);
410 }
411
412 Q_DECLARE_METATYPE(QBrush)
413 void tst_QAbstractAxis::labelsBrush_data()
414 {
415 #if 0
416 QTest::addColumn<QBrush>("labelsBrush");
417 QTest::newRow("null") << QBrush();
418 #endif
419 }
420
421 // public QBrush labelsBrush() const
422 void tst_QAbstractAxis::labelsBrush()
423 {
424 #if 0
425 QFETCH(QBrush, labelsBrush);
426
427 SubQAbstractAxis axis;
428
429 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
430 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
431 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
432 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
433 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
434 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
435 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
436 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
437 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
438
439 QCOMPARE(axis.labelsBrush(), labelsBrush);
440
441 QCOMPARE(spy0.count(), 0);
442 QCOMPARE(spy1.count(), 0);
443 QCOMPARE(spy2.count(), 0);
444 QCOMPARE(spy3.count(), 0);
445 QCOMPARE(spy4.count(), 0);
446 QCOMPARE(spy5.count(), 0);
447 QCOMPARE(spy6.count(), 0);
448 QCOMPARE(spy7.count(), 0);
449 QCOMPARE(spy8.count(), 0);
450 #endif
451 QSKIP("Test is not implemented.", SkipAll);
452 }
453
454 void tst_QAbstractAxis::labelsColor_data()
455 {
456 #if 0
457 QTest::addColumn<QColor>("labelsColor");
458 QTest::newRow("null") << QColor();
459 #endif
460 }
461
462 // public QColor labelsColor() const
463 void tst_QAbstractAxis::labelsColor()
464 {
465 #if 0
466 QFETCH(QColor, labelsColor);
467
468 SubQAbstractAxis axis;
469
470 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
471 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
472 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
473 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
474 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
475 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
476 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
477 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
478 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
479
480 QCOMPARE(axis.labelsColor(), labelsColor);
481
482 QCOMPARE(spy0.count(), 0);
483 QCOMPARE(spy1.count(), 0);
484 QCOMPARE(spy2.count(), 0);
485 QCOMPARE(spy3.count(), 0);
486 QCOMPARE(spy4.count(), 0);
487 QCOMPARE(spy5.count(), 0);
488 QCOMPARE(spy6.count(), 0);
489 QCOMPARE(spy7.count(), 0);
490 QCOMPARE(spy8.count(), 0);
491 #endif
492 QSKIP("Test is not implemented.", SkipAll);
493 }
494
495 void tst_QAbstractAxis::labelsFont_data()
496 {
497 QTest::addColumn<QFont>("labelsFont");
498 QTest::newRow("null") << QFont();
499 }
500
501 // public QFont labelsFont() const
502 void tst_QAbstractAxis::labelsFont()
503 {
504 #if 0
505 QFETCH(QFont, labelsFont);
506
507 SubQAbstractAxis axis;
508
509 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
510 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
511 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
512 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
513 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
514 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
515 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
516 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
517 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
518
519 QCOMPARE(axis.labelsFont(), labelsFont);
520
521 QCOMPARE(spy0.count(), 0);
522 QCOMPARE(spy1.count(), 0);
523 QCOMPARE(spy2.count(), 0);
524 QCOMPARE(spy3.count(), 0);
525 QCOMPARE(spy4.count(), 0);
526 QCOMPARE(spy5.count(), 0);
527 QCOMPARE(spy6.count(), 0);
528 QCOMPARE(spy7.count(), 0);
529 QCOMPARE(spy8.count(), 0);
530 #endif
531 QSKIP("Test is not implemented.", SkipAll);
532 }
533
534 void tst_QAbstractAxis::labelsPen_data()
535 {
536 #if 0
537 QTest::addColumn<QPen>("labelsPen");
538 QTest::newRow("null") << QPen();
539 #endif
540 }
541
542 // public QPen labelsPen() const
543 void tst_QAbstractAxis::labelsPen()
544 {
545 #if 0
546 QFETCH(QPen, labelsPen);
547
548 SubQAbstractAxis axis;
549
550 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
551 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
552 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
553 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
554 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
555 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
556 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
557 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
558 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
559
560 QCOMPARE(axis.labelsPen(), labelsPen);
561
562 QCOMPARE(spy0.count(), 0);
563 QCOMPARE(spy1.count(), 0);
564 QCOMPARE(spy2.count(), 0);
565 QCOMPARE(spy3.count(), 0);
566 QCOMPARE(spy4.count(), 0);
567 QCOMPARE(spy5.count(), 0);
568 QCOMPARE(spy6.count(), 0);
569 QCOMPARE(spy7.count(), 0);
570 QCOMPARE(spy8.count(), 0);
571 #endif
572 QSKIP("Test is not implemented.", SkipAll);
573 }
574
575 void tst_QAbstractAxis::labelsVisible_data()
576 {
577 QTest::addColumn<bool>("labelsVisible");
578 QTest::newRow("true") << true;
579 QTest::newRow("false") << false;
580 }
581
582 // public bool labelsVisible() const
583 void tst_QAbstractAxis::labelsVisible()
584 {
585 #if 0
586 QFETCH(bool, labelsVisible);
587
588 SubQAbstractAxis axis;
589
590 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
591 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
592 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
593 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
594 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
595 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
596 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
597 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
598 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
599
600 QCOMPARE(axis.labelsVisible(), labelsVisible);
601
602 QCOMPARE(spy0.count(), 0);
603 QCOMPARE(spy1.count(), 0);
604 QCOMPARE(spy2.count(), 0);
605 QCOMPARE(spy3.count(), 0);
606 QCOMPARE(spy4.count(), 0);
607 QCOMPARE(spy5.count(), 0);
608 QCOMPARE(spy6.count(), 0);
609 QCOMPARE(spy7.count(), 0);
610 QCOMPARE(spy8.count(), 0);
611 #endif
612 QSKIP("Test is not implemented.", SkipAll);
613 }
614
615 Q_DECLARE_METATYPE(Qt::Orientation)
616 void tst_QAbstractAxis::orientation_data()
617 {
618 #if 0
619 QTest::addColumn<Qt::Orientation>("orientation");
620 QTest::newRow("null") << Qt::Orientation();
621 #endif
622 }
623
624 // public Qt::Orientation orientation()
625 void tst_QAbstractAxis::orientation()
626 {
627 #if 0
628 QFETCH(Qt::Orientation, orientation);
629
630 SubQAbstractAxis axis;
631
632 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
633 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
634 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
635 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
636 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
637 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
638 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
639 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
640 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
641
642 QCOMPARE(axis.orientation(), orientation);
643
644 QCOMPARE(spy0.count(), 0);
645 QCOMPARE(spy1.count(), 0);
646 QCOMPARE(spy2.count(), 0);
647 QCOMPARE(spy3.count(), 0);
648 QCOMPARE(spy4.count(), 0);
649 QCOMPARE(spy5.count(), 0);
650 QCOMPARE(spy6.count(), 0);
651 QCOMPARE(spy7.count(), 0);
652 QCOMPARE(spy8.count(), 0);
653 #endif
654 QSKIP("Test is not implemented.", SkipAll);
655 }
656
657 void tst_QAbstractAxis::setArrowVisible_data()
658 {
659 QTest::addColumn<bool>("visible");
660 QTest::newRow("true") << true;
661 QTest::newRow("false") << false;
662 }
663
664 // public void setArrowVisible(bool visible = true)
665 void tst_QAbstractAxis::setArrowVisible()
666 {
667 #if 0
668 QFETCH(bool, visible);
669
670 SubQAbstractAxis axis;
671
672 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
673 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
674 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
675 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
676 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
677 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
678 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
679 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
680 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
681
682 axis.setArrowVisible(visible);
683
684 QCOMPARE(spy0.count(), 0);
685 QCOMPARE(spy1.count(), 0);
686 QCOMPARE(spy2.count(), 0);
687 QCOMPARE(spy3.count(), 0);
688 QCOMPARE(spy4.count(), 0);
689 QCOMPARE(spy5.count(), 0);
690 QCOMPARE(spy6.count(), 0);
691 QCOMPARE(spy7.count(), 0);
692 QCOMPARE(spy8.count(), 0);
693 #endif
694 QSKIP("Test is not implemented.", SkipAll);
695 }
696
697 void tst_QAbstractAxis::setAxisPen_data()
698 {
699 #if 0
700 QTest::addColumn<QPen>("pen");
701 QTest::newRow("null") << QPen();
702 #endif
703 }
704
705 // public void setAxisPen(QPen const& pen)
706 void tst_QAbstractAxis::setAxisPen()
707 {
708 #if 0
709 QFETCH(QPen, pen);
710
711 SubQAbstractAxis axis;
712
713 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
714 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
715 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
716 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
717 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
718 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
719 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
720 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
721 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
722
723 axis.setAxisPen(pen);
724
725 QCOMPARE(spy0.count(), 0);
726 QCOMPARE(spy1.count(), 0);
727 QCOMPARE(spy2.count(), 0);
728 QCOMPARE(spy3.count(), 0);
729 QCOMPARE(spy4.count(), 0);
730 QCOMPARE(spy5.count(), 0);
731 QCOMPARE(spy6.count(), 0);
732 QCOMPARE(spy7.count(), 0);
733 QCOMPARE(spy8.count(), 0);
734 #endif
735 QSKIP("Test is not implemented.", SkipAll);
736 }
737
738 void tst_QAbstractAxis::setAxisPenColor_data()
739 {
740 #if 0
741 QTest::addColumn<QColor>("color");
742 QTest::newRow("null") << QColor();
743 #endif
744 }
745
746 // public void setAxisPenColor(QColor color)
747 void tst_QAbstractAxis::setAxisPenColor()
748 {
749 #if 0
750 QFETCH(QColor, color);
751
752 SubQAbstractAxis axis;
753
754 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
755 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
756 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
757 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
758 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
759 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
760 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
761 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
762 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
763
764 axis.setAxisPenColor(color);
765
766 QCOMPARE(spy0.count(), 0);
767 QCOMPARE(spy1.count(), 0);
768 QCOMPARE(spy2.count(), 0);
769 QCOMPARE(spy3.count(), 0);
770 QCOMPARE(spy4.count(), 0);
771 QCOMPARE(spy5.count(), 0);
772 QCOMPARE(spy6.count(), 0);
773 QCOMPARE(spy7.count(), 0);
774 QCOMPARE(spy8.count(), 0);
775 #endif
776 QSKIP("Test is not implemented.", SkipAll);
777 }
778
779 void tst_QAbstractAxis::setGridLinePen_data()
780 {
781 #if 0
782 QTest::addColumn<QPen>("pen");
783 QTest::newRow("null") << QPen();
784 #endif
785 }
786
787 // public void setGridLinePen(QPen const& pen)
788 void tst_QAbstractAxis::setGridLinePen()
789 {
790 #if 0
791 QFETCH(QPen, pen);
792
793 SubQAbstractAxis axis;
794
795 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
796 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
797 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
798 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
799 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
800 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
801 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
802 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
803 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
804
805 axis.setGridLinePen(pen);
806
807 QCOMPARE(spy0.count(), 0);
808 QCOMPARE(spy1.count(), 0);
809 QCOMPARE(spy2.count(), 0);
810 QCOMPARE(spy3.count(), 0);
811 QCOMPARE(spy4.count(), 0);
812 QCOMPARE(spy5.count(), 0);
813 QCOMPARE(spy6.count(), 0);
814 QCOMPARE(spy7.count(), 0);
815 QCOMPARE(spy8.count(), 0);
816 #endif
817 QSKIP("Test is not implemented.", SkipAll);
818 }
819
820 void tst_QAbstractAxis::setGridLineVisible_data()
821 {
822 QTest::addColumn<bool>("visible");
823 QTest::newRow("true") << true;
824 QTest::newRow("false") << false;
825 }
826
827 // public void setGridLineVisible(bool visible = true)
828 void tst_QAbstractAxis::setGridLineVisible()
829 {
830 #if 0
831 QFETCH(bool, visible);
832
833 SubQAbstractAxis axis;
834
835 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
836 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
837 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
838 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
839 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
840 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
841 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
842 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
843 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
844
845 axis.setGridLineVisible(visible);
846
847 QCOMPARE(spy0.count(), 0);
848 QCOMPARE(spy1.count(), 0);
849 QCOMPARE(spy2.count(), 0);
850 QCOMPARE(spy3.count(), 0);
851 QCOMPARE(spy4.count(), 0);
852 QCOMPARE(spy5.count(), 0);
853 QCOMPARE(spy6.count(), 0);
854 QCOMPARE(spy7.count(), 0);
855 QCOMPARE(spy8.count(), 0);
856 #endif
857 QSKIP("Test is not implemented.", SkipAll);
858 }
859
860 void tst_QAbstractAxis::setLabelsAngle_data()
861 {
862 QTest::addColumn<int>("angle");
863 QTest::newRow("0") << 0;
864 QTest::newRow("-1") << -1;
865 }
866
867 // public void setLabelsAngle(int angle)
868 void tst_QAbstractAxis::setLabelsAngle()
869 {
870 #if 0
871 QFETCH(int, angle);
872
873 SubQAbstractAxis axis;
874
875 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
876 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
877 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
878 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
879 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
880 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
881 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
882 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
883 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
884
885 axis.setLabelsAngle(angle);
886
887 QCOMPARE(spy0.count(), 0);
888 QCOMPARE(spy1.count(), 0);
889 QCOMPARE(spy2.count(), 0);
890 QCOMPARE(spy3.count(), 0);
891 QCOMPARE(spy4.count(), 0);
892 QCOMPARE(spy5.count(), 0);
893 QCOMPARE(spy6.count(), 0);
894 QCOMPARE(spy7.count(), 0);
895 QCOMPARE(spy8.count(), 0);
896 #endif
897 QSKIP("Test is not implemented.", SkipAll);
898 }
899
900 void tst_QAbstractAxis::setLabelsBrush_data()
901 {
902 #if 0
903 QTest::addColumn<QBrush>("brush");
904 QTest::newRow("null") << QBrush();
905 #endif
906 }
907
908 // public void setLabelsBrush(QBrush const& brush)
909 void tst_QAbstractAxis::setLabelsBrush()
910 {
911 #if 0
912 QFETCH(QBrush, brush);
913
914 SubQAbstractAxis axis;
915
916 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
917 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
918 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
919 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
920 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
921 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
922 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
923 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
924 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
925
926 axis.setLabelsBrush(brush);
927
928 QCOMPARE(spy0.count(), 0);
929 QCOMPARE(spy1.count(), 0);
930 QCOMPARE(spy2.count(), 0);
931 QCOMPARE(spy3.count(), 0);
932 QCOMPARE(spy4.count(), 0);
933 QCOMPARE(spy5.count(), 0);
934 QCOMPARE(spy6.count(), 0);
935 QCOMPARE(spy7.count(), 0);
936 QCOMPARE(spy8.count(), 0);
937 #endif
938 QSKIP("Test is not implemented.", SkipAll);
939 }
940
941 void tst_QAbstractAxis::setLabelsColor_data()
942 {
943 #if 0
944 QTest::addColumn<QColor>("color");
945 QTest::newRow("null") << QColor();
946 #endif
947 }
948
949 // public void setLabelsColor(QColor color)
950 void tst_QAbstractAxis::setLabelsColor()
951 {
952 #if 0
953 QFETCH(QColor, color);
954
955 SubQAbstractAxis axis;
956
957 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
958 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
959 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
960 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
961 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
962 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
963 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
964 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
965 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
966
967 axis.setLabelsColor(color);
968
969 QCOMPARE(spy0.count(), 0);
970 QCOMPARE(spy1.count(), 0);
971 QCOMPARE(spy2.count(), 0);
972 QCOMPARE(spy3.count(), 0);
973 QCOMPARE(spy4.count(), 0);
974 QCOMPARE(spy5.count(), 0);
975 QCOMPARE(spy6.count(), 0);
976 QCOMPARE(spy7.count(), 0);
977 QCOMPARE(spy8.count(), 0);
978 #endif
979 QSKIP("Test is not implemented.", SkipAll);
980 }
981
982 void tst_QAbstractAxis::setLabelsFont_data()
983 {
984 QTest::addColumn<QFont>("font");
985 QTest::newRow("null") << QFont();
986 }
987
988 // public void setLabelsFont(QFont const& font)
989 void tst_QAbstractAxis::setLabelsFont()
990 {
991 #if 0
992 QFETCH(QFont, font);
993
994 SubQAbstractAxis axis;
995
996 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
997 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
998 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
999 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1000 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1001 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1002 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1003 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1004 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1005
1006 axis.setLabelsFont(font);
1007
1008 QCOMPARE(spy0.count(), 0);
1009 QCOMPARE(spy1.count(), 0);
1010 QCOMPARE(spy2.count(), 0);
1011 QCOMPARE(spy3.count(), 0);
1012 QCOMPARE(spy4.count(), 0);
1013 QCOMPARE(spy5.count(), 0);
1014 QCOMPARE(spy6.count(), 0);
1015 QCOMPARE(spy7.count(), 0);
1016 QCOMPARE(spy8.count(), 0);
1017 #endif
1018 QSKIP("Test is not implemented.", SkipAll);
1019 }
1020
1021 void tst_QAbstractAxis::setLabelsPen_data()
1022 {
1023 #if 0
1024 QTest::addColumn<QPen>("pen");
1025 QTest::newRow("null") << QPen();
1026 #endif
1027 }
1028
1029 // public void setLabelsPen(QPen const& pen)
1030 void tst_QAbstractAxis::setLabelsPen()
1031 {
1032 #if 0
1033 QFETCH(QPen, pen);
1034
1035 SubQAbstractAxis axis;
1036
1037 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1038 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1039 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1040 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1041 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1042 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1043 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1044 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1045 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1046
1047 axis.setLabelsPen(pen);
1048
1049 QCOMPARE(spy0.count(), 0);
1050 QCOMPARE(spy1.count(), 0);
1051 QCOMPARE(spy2.count(), 0);
1052 QCOMPARE(spy3.count(), 0);
1053 QCOMPARE(spy4.count(), 0);
1054 QCOMPARE(spy5.count(), 0);
1055 QCOMPARE(spy6.count(), 0);
1056 QCOMPARE(spy7.count(), 0);
1057 QCOMPARE(spy8.count(), 0);
1058 #endif
1059 QSKIP("Test is not implemented.", SkipAll);
1060 }
1061
1062 void tst_QAbstractAxis::setLabelsVisible_data()
1063 {
1064 QTest::addColumn<bool>("visible");
1065 QTest::newRow("true") << true;
1066 QTest::newRow("false") << false;
1067 }
1068
1069 // public void setLabelsVisible(bool visible = true)
1070 void tst_QAbstractAxis::setLabelsVisible()
1071 {
1072 #if 0
1073 QFETCH(bool, visible);
1074
1075 SubQAbstractAxis axis;
1076
1077 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1078 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1079 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1080 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1081 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1082 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1083 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1084 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1085 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1086
1087 axis.setLabelsVisible(visible);
1088
1089 QCOMPARE(spy0.count(), 0);
1090 QCOMPARE(spy1.count(), 0);
1091 QCOMPARE(spy2.count(), 0);
1092 QCOMPARE(spy3.count(), 0);
1093 QCOMPARE(spy4.count(), 0);
1094 QCOMPARE(spy5.count(), 0);
1095 QCOMPARE(spy6.count(), 0);
1096 QCOMPARE(spy7.count(), 0);
1097 QCOMPARE(spy8.count(), 0);
1098 #endif
1099 QSKIP("Test is not implemented.", SkipAll);
1100 }
1101
1102 Q_DECLARE_METATYPE(QVariant)
1103 void tst_QAbstractAxis::setMax_data()
1104 {
1105 #if 0
1106 QTest::addColumn<QVariant>("max");
1107 QTest::newRow("null") << QVariant();
1108 #endif
1109 }
1110
1111 // public void setMax(QVariant const& max)
1112 void tst_QAbstractAxis::setMax()
1113 {
1114 #if 0
1115 QFETCH(QVariant, max);
1116
1117 SubQAbstractAxis axis;
1118
1119 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1120 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1121 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1122 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1123 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1124 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1125 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1126 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1127 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1128
1129 axis.setMax(max);
1130
1131 QCOMPARE(spy0.count(), 0);
1132 QCOMPARE(spy1.count(), 0);
1133 QCOMPARE(spy2.count(), 0);
1134 QCOMPARE(spy3.count(), 0);
1135 QCOMPARE(spy4.count(), 0);
1136 QCOMPARE(spy5.count(), 0);
1137 QCOMPARE(spy6.count(), 0);
1138 QCOMPARE(spy7.count(), 0);
1139 QCOMPARE(spy8.count(), 0);
1140 #endif
1141 QSKIP("Test is not implemented.", SkipAll);
1142 }
1143
1144 void tst_QAbstractAxis::setMin_data()
1145 {
1146 #if 0
1147 QTest::addColumn<QVariant>("min");
1148 QTest::newRow("null") << QVariant();
1149 #endif
1150 }
1151
1152 // public void setMin(QVariant const& min)
1153 void tst_QAbstractAxis::setMin()
1154 {
1155 #if 0
1156 QFETCH(QVariant, min);
1157
1158 SubQAbstractAxis axis;
1159
1160 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1161 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1162 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1163 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1164 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1165 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1166 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1167 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1168 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1169
1170 axis.setMin(min);
1171
1172 QCOMPARE(spy0.count(), 0);
1173 QCOMPARE(spy1.count(), 0);
1174 QCOMPARE(spy2.count(), 0);
1175 QCOMPARE(spy3.count(), 0);
1176 QCOMPARE(spy4.count(), 0);
1177 QCOMPARE(spy5.count(), 0);
1178 QCOMPARE(spy6.count(), 0);
1179 QCOMPARE(spy7.count(), 0);
1180 QCOMPARE(spy8.count(), 0);
1181 #endif
1182 QSKIP("Test is not implemented.", SkipAll);
1183 }
1184
1185 void tst_QAbstractAxis::setRange_data()
1186 {
1187 #if 0
1188 QTest::addColumn<QVariant>("min");
1189 QTest::addColumn<QVariant>("max");
1190 QTest::newRow("null") << QVariant() << QVariant();
1191 #endif
1192 }
1193
1194 // public void setRange(QVariant const& min, QVariant const& max)
1195 void tst_QAbstractAxis::setRange()
1196 {
1197 #if 0
1198 QFETCH(QVariant, min);
1199 QFETCH(QVariant, max);
1200
1201 SubQAbstractAxis axis;
1202
1203 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1204 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1205 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1206 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1207 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1208 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1209 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1210 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1211 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1212
1213 axis.setRange(min, max);
1214
1215 QCOMPARE(spy0.count(), 0);
1216 QCOMPARE(spy1.count(), 0);
1217 QCOMPARE(spy2.count(), 0);
1218 QCOMPARE(spy3.count(), 0);
1219 QCOMPARE(spy4.count(), 0);
1220 QCOMPARE(spy5.count(), 0);
1221 QCOMPARE(spy6.count(), 0);
1222 QCOMPARE(spy7.count(), 0);
1223 QCOMPARE(spy8.count(), 0);
1224 #endif
1225 QSKIP("Test is not implemented.", SkipAll);
1226 }
1227
1228 void tst_QAbstractAxis::setShadesBorderColor_data()
1229 {
1230 #if 0
1231 QTest::addColumn<QColor>("color");
1232 QTest::newRow("null") << QColor();
1233 #endif
1234 }
1235
1236 // public void setShadesBorderColor(QColor color)
1237 void tst_QAbstractAxis::setShadesBorderColor()
1238 {
1239 #if 0
1240 QFETCH(QColor, color);
1241
1242 SubQAbstractAxis axis;
1243
1244 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1245 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1246 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1247 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1248 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1249 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1250 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1251 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1252 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1253
1254 axis.setShadesBorderColor(color);
1255
1256 QCOMPARE(spy0.count(), 0);
1257 QCOMPARE(spy1.count(), 0);
1258 QCOMPARE(spy2.count(), 0);
1259 QCOMPARE(spy3.count(), 0);
1260 QCOMPARE(spy4.count(), 0);
1261 QCOMPARE(spy5.count(), 0);
1262 QCOMPARE(spy6.count(), 0);
1263 QCOMPARE(spy7.count(), 0);
1264 QCOMPARE(spy8.count(), 0);
1265 #endif
1266 QSKIP("Test is not implemented.", SkipAll);
1267 }
1268
1269 void tst_QAbstractAxis::setShadesBrush_data()
1270 {
1271 #if 0
1272 QTest::addColumn<QBrush>("brush");
1273 QTest::newRow("null") << QBrush();
1274 #endif
1275 }
1276
1277 // public void setShadesBrush(QBrush const& brush)
1278 void tst_QAbstractAxis::setShadesBrush()
1279 {
1280 #if 0
1281 QFETCH(QBrush, brush);
1282
1283 SubQAbstractAxis axis;
1284
1285 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1286 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1287 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1288 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1289 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1290 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1291 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1292 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1293 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1294
1295 axis.setShadesBrush(brush);
1296
1297 QCOMPARE(spy0.count(), 0);
1298 QCOMPARE(spy1.count(), 0);
1299 QCOMPARE(spy2.count(), 0);
1300 QCOMPARE(spy3.count(), 0);
1301 QCOMPARE(spy4.count(), 0);
1302 QCOMPARE(spy5.count(), 0);
1303 QCOMPARE(spy6.count(), 0);
1304 QCOMPARE(spy7.count(), 0);
1305 QCOMPARE(spy8.count(), 0);
1306 #endif
1307 QSKIP("Test is not implemented.", SkipAll);
1308 }
1309
1310 void tst_QAbstractAxis::setShadesColor_data()
1311 {
1312 #if 0
1313 QTest::addColumn<QColor>("color");
1314 QTest::newRow("null") << QColor();
1315 #endif
1316 }
1317
1318 // public void setShadesColor(QColor color)
1319 void tst_QAbstractAxis::setShadesColor()
1320 {
1321 #if 0
1322 QFETCH(QColor, color);
1323
1324 SubQAbstractAxis axis;
1325
1326 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1327 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1328 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1329 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1330 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1331 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1332 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1333 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1334 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1335
1336 axis.setShadesColor(color);
1337
1338 QCOMPARE(spy0.count(), 0);
1339 QCOMPARE(spy1.count(), 0);
1340 QCOMPARE(spy2.count(), 0);
1341 QCOMPARE(spy3.count(), 0);
1342 QCOMPARE(spy4.count(), 0);
1343 QCOMPARE(spy5.count(), 0);
1344 QCOMPARE(spy6.count(), 0);
1345 QCOMPARE(spy7.count(), 0);
1346 QCOMPARE(spy8.count(), 0);
1347 #endif
1348 QSKIP("Test is not implemented.", SkipAll);
1349 }
1350
1351 void tst_QAbstractAxis::setShadesPen_data()
1352 {
1353 #if 0
1354 QTest::addColumn<QPen>("pen");
1355 QTest::newRow("null") << QPen();
1356 #endif
1357 }
1358
1359 // public void setShadesPen(QPen const& pen)
1360 void tst_QAbstractAxis::setShadesPen()
1361 {
1362 #if 0
1363 QFETCH(QPen, pen);
1364
1365 SubQAbstractAxis axis;
1366
1367 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1368 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1369 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1370 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1371 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1372 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1373 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1374 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1375 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1376
1377 axis.setShadesPen(pen);
1378
1379 QCOMPARE(spy0.count(), 0);
1380 QCOMPARE(spy1.count(), 0);
1381 QCOMPARE(spy2.count(), 0);
1382 QCOMPARE(spy3.count(), 0);
1383 QCOMPARE(spy4.count(), 0);
1384 QCOMPARE(spy5.count(), 0);
1385 QCOMPARE(spy6.count(), 0);
1386 QCOMPARE(spy7.count(), 0);
1387 QCOMPARE(spy8.count(), 0);
1388 #endif
1389 QSKIP("Test is not implemented.", SkipAll);
1390 }
1391
1392 void tst_QAbstractAxis::setShadesVisible_data()
1393 {
1394 QTest::addColumn<bool>("visible");
1395 QTest::newRow("true") << true;
1396 QTest::newRow("false") << false;
1397 }
1398
1399 // public void setShadesVisible(bool visible = true)
1400 void tst_QAbstractAxis::setShadesVisible()
1401 {
1402 #if 0
1403 QFETCH(bool, visible);
1404
1405 SubQAbstractAxis axis;
1406
1407 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1408 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1409 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1410 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1411 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1412 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1413 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1414 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1415 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1416
1417 axis.setShadesVisible(visible);
1418
1419 QCOMPARE(spy0.count(), 0);
1420 QCOMPARE(spy1.count(), 0);
1421 QCOMPARE(spy2.count(), 0);
1422 QCOMPARE(spy3.count(), 0);
1423 QCOMPARE(spy4.count(), 0);
1424 QCOMPARE(spy5.count(), 0);
1425 QCOMPARE(spy6.count(), 0);
1426 QCOMPARE(spy7.count(), 0);
1427 QCOMPARE(spy8.count(), 0);
1428 #endif
1429 QSKIP("Test is not implemented.", SkipAll);
1430 }
1431
1432 void tst_QAbstractAxis::setVisible_data()
1433 {
1434 QTest::addColumn<bool>("visible");
1435 QTest::newRow("true") << true;
1436 QTest::newRow("false") << false;
1437 }
1438
1439 // public void setVisible(bool visible = true)
1440 void tst_QAbstractAxis::setVisible()
1441 {
1442 #if 0
1443 QFETCH(bool, visible);
1444
1445 SubQAbstractAxis axis;
1446
1447 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1448 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1449 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1450 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1451 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1452 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1453 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1454 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1455 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1456
1457 axis.setVisible(visible);
1458
1459 QCOMPARE(spy0.count(), 0);
1460 QCOMPARE(spy1.count(), 0);
1461 QCOMPARE(spy2.count(), 0);
1462 QCOMPARE(spy3.count(), 0);
1463 QCOMPARE(spy4.count(), 0);
1464 QCOMPARE(spy5.count(), 0);
1465 QCOMPARE(spy6.count(), 0);
1466 QCOMPARE(spy7.count(), 0);
1467 QCOMPARE(spy8.count(), 0);
1468 #endif
1469 QSKIP("Test is not implemented.", SkipAll);
1470 }
1471
1472 void tst_QAbstractAxis::shadesBorderColor_data()
1473 {
1474 #if 0
1475 QTest::addColumn<QColor>("shadesBorderColor");
1476 QTest::newRow("null") << QColor();
1477 #endif
1478 }
1479
1480 // public QColor shadesBorderColor() const
1481 void tst_QAbstractAxis::shadesBorderColor()
1482 {
1483 #if 0
1484 QFETCH(QColor, shadesBorderColor);
1485
1486 SubQAbstractAxis axis;
1487
1488 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1489 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1490 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1491 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1492 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1493 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1494 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1495 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1496 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1497
1498 QCOMPARE(axis.shadesBorderColor(), shadesBorderColor);
1499
1500 QCOMPARE(spy0.count(), 0);
1501 QCOMPARE(spy1.count(), 0);
1502 QCOMPARE(spy2.count(), 0);
1503 QCOMPARE(spy3.count(), 0);
1504 QCOMPARE(spy4.count(), 0);
1505 QCOMPARE(spy5.count(), 0);
1506 QCOMPARE(spy6.count(), 0);
1507 QCOMPARE(spy7.count(), 0);
1508 QCOMPARE(spy8.count(), 0);
1509 #endif
1510 QSKIP("Test is not implemented.", SkipAll);
1511 }
1512
1513 void tst_QAbstractAxis::shadesBrush_data()
1514 {
1515 #if 0
1516 QTest::addColumn<QBrush>("shadesBrush");
1517 QTest::newRow("null") << QBrush();
1518 #endif
1519 }
1520
1521 // public QBrush shadesBrush() const
1522 void tst_QAbstractAxis::shadesBrush()
1523 {
1524 #if 0
1525 QFETCH(QBrush, shadesBrush);
1526
1527 SubQAbstractAxis axis;
1528
1529 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1530 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1531 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1532 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1533 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1534 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1535 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1536 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1537 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1538
1539 QCOMPARE(axis.shadesBrush(), shadesBrush);
1540
1541 QCOMPARE(spy0.count(), 0);
1542 QCOMPARE(spy1.count(), 0);
1543 QCOMPARE(spy2.count(), 0);
1544 QCOMPARE(spy3.count(), 0);
1545 QCOMPARE(spy4.count(), 0);
1546 QCOMPARE(spy5.count(), 0);
1547 QCOMPARE(spy6.count(), 0);
1548 QCOMPARE(spy7.count(), 0);
1549 QCOMPARE(spy8.count(), 0);
1550 #endif
1551 QSKIP("Test is not implemented.", SkipAll);
1552 }
1553
1554 void tst_QAbstractAxis::shadesColor_data()
1555 {
1556 #if 0
1557 QTest::addColumn<QColor>("shadesColor");
1558 QTest::newRow("null") << QColor();
1559 #endif
1560 }
1561
1562 // public QColor shadesColor() const
1563 void tst_QAbstractAxis::shadesColor()
1564 {
1565 #if 0
1566 QFETCH(QColor, shadesColor);
1567
1568 SubQAbstractAxis axis;
1569
1570 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1571 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1572 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1573 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1574 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1575 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1576 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1577 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1578 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1579
1580 QCOMPARE(axis.shadesColor(), shadesColor);
1581
1582 QCOMPARE(spy0.count(), 0);
1583 QCOMPARE(spy1.count(), 0);
1584 QCOMPARE(spy2.count(), 0);
1585 QCOMPARE(spy3.count(), 0);
1586 QCOMPARE(spy4.count(), 0);
1587 QCOMPARE(spy5.count(), 0);
1588 QCOMPARE(spy6.count(), 0);
1589 QCOMPARE(spy7.count(), 0);
1590 QCOMPARE(spy8.count(), 0);
1591 #endif
1592 QSKIP("Test is not implemented.", SkipAll);
1593 }
1594
1595 void tst_QAbstractAxis::shadesPen_data()
1596 {
1597 #if 0
1598 QTest::addColumn<QPen>("shadesPen");
1599 QTest::newRow("null") << QPen();
1600 #endif
1601 }
1602
1603 // public QPen shadesPen() const
1604 void tst_QAbstractAxis::shadesPen()
1605 {
1606 #if 0
1607 QFETCH(QPen, shadesPen);
1608
1609 SubQAbstractAxis axis;
1610
1611 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1612 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1613 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1614 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1615 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1616 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1617 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1618 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1619 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1620
1621 QCOMPARE(axis.shadesPen(), shadesPen);
1622
1623 QCOMPARE(spy0.count(), 0);
1624 QCOMPARE(spy1.count(), 0);
1625 QCOMPARE(spy2.count(), 0);
1626 QCOMPARE(spy3.count(), 0);
1627 QCOMPARE(spy4.count(), 0);
1628 QCOMPARE(spy5.count(), 0);
1629 QCOMPARE(spy6.count(), 0);
1630 QCOMPARE(spy7.count(), 0);
1631 QCOMPARE(spy8.count(), 0);
1632 #endif
1633 QSKIP("Test is not implemented.", SkipAll);
1634 }
1635
1636 void tst_QAbstractAxis::shadesVisible_data()
1637 {
1638 QTest::addColumn<bool>("shadesVisible");
1639 QTest::newRow("true") << true;
1640 QTest::newRow("false") << false;
1641 }
1642
1643 // public bool shadesVisible() const
1644 void tst_QAbstractAxis::shadesVisible()
1645 {
1646 #if 0
1647 QFETCH(bool, shadesVisible);
1648
1649 SubQAbstractAxis axis;
1650
1651 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1652 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1653 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1654 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1655 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1656 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1657 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1658 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1659 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1660
1661 QCOMPARE(axis.shadesVisible(), shadesVisible);
1662
1663 QCOMPARE(spy0.count(), 0);
1664 QCOMPARE(spy1.count(), 0);
1665 QCOMPARE(spy2.count(), 0);
1666 QCOMPARE(spy3.count(), 0);
1667 QCOMPARE(spy4.count(), 0);
1668 QCOMPARE(spy5.count(), 0);
1669 QCOMPARE(spy6.count(), 0);
1670 QCOMPARE(spy7.count(), 0);
1671 QCOMPARE(spy8.count(), 0);
1672 #endif
1673 QSKIP("Test is not implemented.", SkipAll);
1674 }
1675
1676 void tst_QAbstractAxis::show_data()
1677 {
1678 QTest::addColumn<int>("foo");
1679 QTest::newRow("0") << 0;
1680 QTest::newRow("-1") << -1;
1681 }
1682
1683 // public void show()
1684 void tst_QAbstractAxis::show()
1685 {
1686 #if 0
1687 QFETCH(int, foo);
1688
1689 SubQAbstractAxis axis;
1690
1691 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1692 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1693 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1694 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1695 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1696 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1697 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1698 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1699 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1700
1701 axis.show();
1702
1703 QCOMPARE(spy0.count(), 0);
1704 QCOMPARE(spy1.count(), 0);
1705 QCOMPARE(spy2.count(), 0);
1706 QCOMPARE(spy3.count(), 0);
1707 QCOMPARE(spy4.count(), 0);
1708 QCOMPARE(spy5.count(), 0);
1709 QCOMPARE(spy6.count(), 0);
1710 QCOMPARE(spy7.count(), 0);
1711 QCOMPARE(spy8.count(), 0);
1712 #endif
1713 QSKIP("Test is not implemented.", SkipAll);
1714 }
1715
1716 Q_DECLARE_METATYPE(QAbstractAxis::AxisType)
1717 void tst_QAbstractAxis::type_data()
1718 {
1719 #if 0
1720 QTest::addColumn<QAbstractAxis::AxisType>("type");
1721 QTest::newRow("null") << QAbstractAxis::AxisType();
1722 #endif
1723 }
1724
1725 // public QAbstractAxis::AxisType type() const
1726 void tst_QAbstractAxis::type()
1727 {
1728 #if 0
1729 QFETCH(QAbstractAxis::AxisType, type);
1730
1731 SubQAbstractAxis axis;
1732
1733 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1734 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1735 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1736 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1737 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1738 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1739 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1740 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1741 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1742
1743 QCOMPARE(axis.type(), type);
1744
1745 QCOMPARE(spy0.count(), 0);
1746 QCOMPARE(spy1.count(), 0);
1747 QCOMPARE(spy2.count(), 0);
1748 QCOMPARE(spy3.count(), 0);
1749 QCOMPARE(spy4.count(), 0);
1750 QCOMPARE(spy5.count(), 0);
1751 QCOMPARE(spy6.count(), 0);
1752 QCOMPARE(spy7.count(), 0);
1753 QCOMPARE(spy8.count(), 0);
1754 #endif
1755 QSKIP("Test is not implemented.", SkipAll);
1756 }
1757
1758 void tst_QAbstractAxis::arrowVisibleChanged_data()
1759 {
1760 QTest::addColumn<bool>("visible");
1761 QTest::newRow("true") << true;
1762 QTest::newRow("false") << false;
1763 }
1764
1765 // protected void arrowVisibleChanged(bool visible)
1766 void tst_QAbstractAxis::arrowVisibleChanged()
1767 {
1768 #if 0
1769 QFETCH(bool, visible);
1770
1771 SubQAbstractAxis axis;
1772
1773 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1774 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1775 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1776 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1777 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1778 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1779 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1780 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1781 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1782
1783 axis.call_arrowVisibleChanged(visible);
1784
1785 QCOMPARE(spy0.count(), 0);
1786 QCOMPARE(spy1.count(), 0);
1787 QCOMPARE(spy2.count(), 0);
1788 QCOMPARE(spy3.count(), 0);
1789 QCOMPARE(spy4.count(), 0);
1790 QCOMPARE(spy5.count(), 0);
1791 QCOMPARE(spy6.count(), 0);
1792 QCOMPARE(spy7.count(), 0);
1793 QCOMPARE(spy8.count(), 0);
1794 #endif
1795 QSKIP("Test is not implemented.", SkipAll);
1796 }
1797
1798 void tst_QAbstractAxis::colorChanged_data()
1799 {
1800 #if 0
1801 QTest::addColumn<QColor>("color");
1802 QTest::newRow("null") << QColor();
1803 #endif
1804 }
1805
1806 // protected void colorChanged(QColor color)
1807 void tst_QAbstractAxis::colorChanged()
1808 {
1809 #if 0
1810 QFETCH(QColor, color);
1811
1812 SubQAbstractAxis axis;
1813
1814 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1815 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1816 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1817 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1818 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1819 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1820 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1821 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1822 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1823
1824 axis.call_colorChanged(color);
1825
1826 QCOMPARE(spy0.count(), 0);
1827 QCOMPARE(spy1.count(), 0);
1828 QCOMPARE(spy2.count(), 0);
1829 QCOMPARE(spy3.count(), 0);
1830 QCOMPARE(spy4.count(), 0);
1831 QCOMPARE(spy5.count(), 0);
1832 QCOMPARE(spy6.count(), 0);
1833 QCOMPARE(spy7.count(), 0);
1834 QCOMPARE(spy8.count(), 0);
1835 #endif
1836 QSKIP("Test is not implemented.", SkipAll);
1837 }
1838
1839 void tst_QAbstractAxis::gridVisibleChanged_data()
1840 {
1841 QTest::addColumn<bool>("visible");
1842 QTest::newRow("true") << true;
1843 QTest::newRow("false") << false;
1844 }
1845
1846 // protected void gridVisibleChanged(bool visible)
1847 void tst_QAbstractAxis::gridVisibleChanged()
1848 {
1849 #if 0
1850 QFETCH(bool, visible);
1851
1852 SubQAbstractAxis axis;
1853
1854 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1855 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1856 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1857 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1858 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1859 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1860 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1861 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1862 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1863
1864 axis.call_gridVisibleChanged(visible);
1865
1866 QCOMPARE(spy0.count(), 0);
1867 QCOMPARE(spy1.count(), 0);
1868 QCOMPARE(spy2.count(), 0);
1869 QCOMPARE(spy3.count(), 0);
1870 QCOMPARE(spy4.count(), 0);
1871 QCOMPARE(spy5.count(), 0);
1872 QCOMPARE(spy6.count(), 0);
1873 QCOMPARE(spy7.count(), 0);
1874 QCOMPARE(spy8.count(), 0);
1875 #endif
1876 QSKIP("Test is not implemented.", SkipAll);
1877 }
1878
1879 void tst_QAbstractAxis::labelsColorChanged_data()
1880 {
1881 #if 0
1882 QTest::addColumn<QColor>("color");
1883 QTest::newRow("null") << QColor();
1884 #endif
1885 }
1886
1887 // protected void labelsColorChanged(QColor color)
1888 void tst_QAbstractAxis::labelsColorChanged()
1889 {
1890 #if 0
1891 QFETCH(QColor, color);
1892
1893 SubQAbstractAxis axis;
1894
1895 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1896 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1897 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1898 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1899 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1900 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1901 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1902 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1903 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1904
1905 axis.call_labelsColorChanged(color);
1906
1907 QCOMPARE(spy0.count(), 0);
1908 QCOMPARE(spy1.count(), 0);
1909 QCOMPARE(spy2.count(), 0);
1910 QCOMPARE(spy3.count(), 0);
1911 QCOMPARE(spy4.count(), 0);
1912 QCOMPARE(spy5.count(), 0);
1913 QCOMPARE(spy6.count(), 0);
1914 QCOMPARE(spy7.count(), 0);
1915 QCOMPARE(spy8.count(), 0);
1916 #endif
1917 QSKIP("Test is not implemented.", SkipAll);
1918 }
1919
1920 void tst_QAbstractAxis::labelsVisibleChanged_data()
1921 {
1922 QTest::addColumn<bool>("visible");
1923 QTest::newRow("true") << true;
1924 QTest::newRow("false") << false;
1925 }
1926
1927 // protected void labelsVisibleChanged(bool visible)
1928 void tst_QAbstractAxis::labelsVisibleChanged()
1929 {
1930 #if 0
1931 QFETCH(bool, visible);
1932
1933 SubQAbstractAxis axis;
1934
1935 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1936 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1937 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1938 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1939 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1940 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1941 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1942 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1943 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1944
1945 axis.call_labelsVisibleChanged(visible);
1946
1947 QCOMPARE(spy0.count(), 0);
1948 QCOMPARE(spy1.count(), 0);
1949 QCOMPARE(spy2.count(), 0);
1950 QCOMPARE(spy3.count(), 0);
1951 QCOMPARE(spy4.count(), 0);
1952 QCOMPARE(spy5.count(), 0);
1953 QCOMPARE(spy6.count(), 0);
1954 QCOMPARE(spy7.count(), 0);
1955 QCOMPARE(spy8.count(), 0);
1956 #endif
1957 QSKIP("Test is not implemented.", SkipAll);
1958 }
1959
1960 void tst_QAbstractAxis::shadesBorderColorChanged_data()
1961 {
1962 #if 0
1963 QTest::addColumn<QColor>("color");
1964 QTest::newRow("null") << QColor();
1965 #endif
1966 }
1967
1968 // protected void shadesBorderColorChanged(QColor color)
1969 void tst_QAbstractAxis::shadesBorderColorChanged()
1970 {
1971 #if 0
1972 QFETCH(QColor, color);
1973
1974 SubQAbstractAxis axis;
1975
1976 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
1977 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
1978 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
1979 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
1980 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
1981 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
1982 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
1983 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
1984 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
1985
1986 axis.call_shadesBorderColorChanged(color);
1987
1988 QCOMPARE(spy0.count(), 0);
1989 QCOMPARE(spy1.count(), 0);
1990 QCOMPARE(spy2.count(), 0);
1991 QCOMPARE(spy3.count(), 0);
1992 QCOMPARE(spy4.count(), 0);
1993 QCOMPARE(spy5.count(), 0);
1994 QCOMPARE(spy6.count(), 0);
1995 QCOMPARE(spy7.count(), 0);
1996 QCOMPARE(spy8.count(), 0);
1997 #endif
1998 QSKIP("Test is not implemented.", SkipAll);
1999 }
2000
2001 void tst_QAbstractAxis::shadesColorChanged_data()
2002 {
2003 #if 0
2004 QTest::addColumn<QColor>("color");
2005 QTest::newRow("null") << QColor();
2006 #endif
2007 }
2008
2009 // protected void shadesColorChanged(QColor color)
2010 void tst_QAbstractAxis::shadesColorChanged()
2011 {
2012 #if 0
2013 QFETCH(QColor, color);
2014
2015 SubQAbstractAxis axis;
2016
2017 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
2018 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
2019 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
2020 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
2021 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
2022 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
2023 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
2024 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
2025 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
2026
2027 axis.call_shadesColorChanged(color);
2028
2029 QCOMPARE(spy0.count(), 0);
2030 QCOMPARE(spy1.count(), 0);
2031 QCOMPARE(spy2.count(), 0);
2032 QCOMPARE(spy3.count(), 0);
2033 QCOMPARE(spy4.count(), 0);
2034 QCOMPARE(spy5.count(), 0);
2035 QCOMPARE(spy6.count(), 0);
2036 QCOMPARE(spy7.count(), 0);
2037 QCOMPARE(spy8.count(), 0);
2038 #endif
2039 QSKIP("Test is not implemented.", SkipAll);
2040 }
2041
2042 void tst_QAbstractAxis::shadesVisibleChanged_data()
2043 {
2044 QTest::addColumn<bool>("visible");
2045 QTest::newRow("true") << true;
2046 QTest::newRow("false") << false;
2047 }
2048
2049 // protected void shadesVisibleChanged(bool visible)
2050 void tst_QAbstractAxis::shadesVisibleChanged()
2051 {
2052 #if 0
2053 QFETCH(bool, visible);
2054
2055 SubQAbstractAxis axis;
2056
2057 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
2058 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
2059 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
2060 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
2061 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
2062 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
2063 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
2064 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
2065 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
2066
2067 axis.call_shadesVisibleChanged(visible);
2068
2069 QCOMPARE(spy0.count(), 0);
2070 QCOMPARE(spy1.count(), 0);
2071 QCOMPARE(spy2.count(), 0);
2072 QCOMPARE(spy3.count(), 0);
2073 QCOMPARE(spy4.count(), 0);
2074 QCOMPARE(spy5.count(), 0);
2075 QCOMPARE(spy6.count(), 0);
2076 QCOMPARE(spy7.count(), 0);
2077 QCOMPARE(spy8.count(), 0);
2078 #endif
2079 QSKIP("Test is not implemented.", SkipAll);
2080 }
2081
2082 void tst_QAbstractAxis::visibleChanged_data()
2083 {
2084 QTest::addColumn<bool>("visible");
2085 QTest::newRow("true") << true;
2086 QTest::newRow("false") << false;
2087 }
2088
2089 // protected void visibleChanged(bool visible)
2090 void tst_QAbstractAxis::visibleChanged()
2091 {
2092 #if 0
2093 QFETCH(bool, visible);
2094
2095 SubQAbstractAxis axis;
2096
2097 QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
2098 QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
2099 QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
2100 QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
2101 QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
2102 QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
2103 QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
2104 QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
2105 QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
2106
2107 axis.call_visibleChanged(visible);
2108
2109 QCOMPARE(spy0.count(), 0);
2110 QCOMPARE(spy1.count(), 0);
2111 QCOMPARE(spy2.count(), 0);
2112 QCOMPARE(spy3.count(), 0);
2113 QCOMPARE(spy4.count(), 0);
2114 QCOMPARE(spy5.count(), 0);
2115 QCOMPARE(spy6.count(), 0);
2116 QCOMPARE(spy7.count(), 0);
2117 QCOMPARE(spy8.count(), 0);
2118 #endif
2119 QSKIP("Test is not implemented.", SkipAll);
2120 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,151
1 /****************************************************************************
2 **
3 ** Copyright (C) 2012 Digia Plc
4 ** All rights reserved.
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 **
7 ** This file is part of the Qt Commercial Charts Add-on.
8 **
9 ** $QT_BEGIN_LICENSE$
10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 ** accordance with the Qt Commercial License Agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.
14 **
15 ** If you have questions regarding the use of this file, please use
16 ** contact form at http://qt.digia.com
17 ** $QT_END_LICENSE$
18 **
19 ****************************************************************************/
20
21 #ifndef TST_QABSTRACTSERIES_H
22 #define TST_QABSTRACTSERIES_H
23
24 #include <QtTest/QtTest>
25 #include <tst_definitions.h>
26 #include <qabstractaxis.h>
27 #include <qchartview.h>
28
29 QTCOMMERCIALCHART_USE_NAMESPACE
30
31 class tst_QAbstractAxis : public QObject
32 {
33 Q_OBJECT
34
35 public slots:
36 virtual void initTestCase();
37 virtual void cleanupTestCase();
38 virtual void init(QAbstractAxis* axis);
39 virtual void cleanup();
40
41 private slots:
42 void axisPen_data();
43 void axisPen();
44 void axisPenColor_data();
45 void axisPenColor();
46 void gridLinePen_data();
47 void gridLinePen();
48 void hide_data();
49 void hide();
50 void isArrowVisible_data();
51 void isArrowVisible();
52 void isGridLineVisible_data();
53 void isGridLineVisible();
54 void isVisible_data();
55 void isVisible();
56 void labelsAngle_data();
57 void labelsAngle();
58 void labelsBrush_data();
59 void labelsBrush();
60 void labelsColor_data();
61 void labelsColor();
62 void labelsFont_data();
63 void labelsFont();
64 void labelsPen_data();
65 void labelsPen();
66 void labelsVisible_data();
67 void labelsVisible();
68 void orientation_data();
69 void orientation();
70 void setArrowVisible_data();
71 void setArrowVisible();
72 void setAxisPen_data();
73 void setAxisPen();
74 void setAxisPenColor_data();
75 void setAxisPenColor();
76 void setGridLinePen_data();
77 void setGridLinePen();
78 void setGridLineVisible_data();
79 void setGridLineVisible();
80 void setLabelsAngle_data();
81 void setLabelsAngle();
82 void setLabelsBrush_data();
83 void setLabelsBrush();
84 void setLabelsColor_data();
85 void setLabelsColor();
86 void setLabelsFont_data();
87 void setLabelsFont();
88 void setLabelsPen_data();
89 void setLabelsPen();
90 void setLabelsVisible_data();
91 void setLabelsVisible();
92 void setMax_data();
93 void setMax();
94 void setMin_data();
95 void setMin();
96 void setRange_data();
97 void setRange();
98 void setShadesBorderColor_data();
99 void setShadesBorderColor();
100 void setShadesBrush_data();
101 void setShadesBrush();
102 void setShadesColor_data();
103 void setShadesColor();
104 void setShadesPen_data();
105 void setShadesPen();
106 void setShadesVisible_data();
107 void setShadesVisible();
108 void setVisible_data();
109 void setVisible();
110 void shadesBorderColor_data();
111 void shadesBorderColor();
112 void shadesBrush_data();
113 void shadesBrush();
114 void shadesColor_data();
115 void shadesColor();
116 void shadesPen_data();
117 void shadesPen();
118 void shadesVisible_data();
119 void shadesVisible();
120 void show_data();
121 void show();
122 void type_data();
123 void type();
124 void arrowVisibleChanged_data();
125 void arrowVisibleChanged();
126 void colorChanged_data();
127 void colorChanged();
128 void gridVisibleChanged_data();
129 void gridVisibleChanged();
130 void labelsColorChanged_data();
131 void labelsColorChanged();
132 void labelsVisibleChanged_data();
133 void labelsVisibleChanged();
134 void shadesBorderColorChanged_data();
135 void shadesBorderColorChanged();
136 void shadesColorChanged_data();
137 void shadesColorChanged();
138 void shadesVisibleChanged_data();
139 void shadesVisibleChanged();
140 void visibleChanged_data();
141 void visibleChanged();
142
143 protected:
144 void qabstractaxis();
145 protected:
146 QChartView* m_view;
147 QChart* m_chart;
148 QAbstractAxis* m_axis;
149 };
150
151 #endif
Show file before | Show file after | Hide comments
@@ -0,0 +1,5
1 !include( ../auto.pri ) {
2 error( "Couldn't find the auto.pri file!" )
3 }
4 HEADERS += ../qabstractaxis/tst_qabstractaxis.h
5 SOURCES += tst_qvaluesaxis.cpp ../qabstractaxis/tst_qabstractaxis.cpp
Show file before | Show file after | Hide comments
@@ -0,0 +1,432
1 /****************************************************************************
2 **
3 ** Copyright (C) 2012 Digia Plc
4 ** All rights reserved.
5 ** For any questions to Digia, please use contact form at http://qt.digia.com
6 **
7 ** This file is part of the Qt Commercial Charts Add-on.
8 **
9 ** $QT_BEGIN_LICENSE$
10 ** Licensees holding valid Qt Commercial licenses may use this file in
11 ** accordance with the Qt Commercial License Agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.
14 **
15 ** If you have questions regarding the use of this file, please use
16 ** contact form at http://qt.digia.com
17 ** $QT_END_LICENSE$
18 **
19 ****************************************************************************/
20
21 #include "../qabstractaxis/tst_qabstractaxis.h"
22 #include "qvaluesaxis.h"
23 #include <qlineseries.h>
24
25 class tst_QValuesAxis : public tst_QAbstractAxis
26 {
27 Q_OBJECT
28
29 public slots:
30 void initTestCase();
31 void cleanupTestCase();
32 void init();
33 void cleanup();
34
35 private slots:
36 void qvaluesaxis_data();
37 void qvaluesaxis();
38
39 void max_data();
40 void max();
41 void min_data();
42 void min();
43 void niceNumbersEnabled_data();
44 void niceNumbersEnabled();
45 void setNiceNumbersEnabled_data();
46 void setNiceNumbersEnabled();
47 void setRange_data();
48 void setRange();
49 void setTicksCount_data();
50 void setTicksCount();
51 void ticksCount_data();
52 void ticksCount();
53 void type_data();
54 void type();
55 void maxChanged_data();
56 void maxChanged();
57 void minChanged_data();
58 void minChanged();
59 void rangeChanged_data();
60 void rangeChanged();
61
62 private:
63 QValuesAxis* m_valuesaxis;
64 QLineSeries* m_series;
65 };
66
67
68 void tst_QValuesAxis::initTestCase()
69 {
70 }
71
72
73 void tst_QValuesAxis::cleanupTestCase()
74 {
75 }
76
77
78 void tst_QValuesAxis::init()
79 {
80 m_valuesaxis = new QValuesAxis();
81 tst_QAbstractAxis::init(m_valuesaxis);
82 m_series = new QLineSeries();
83 *m_series << QPointF(-100,-100) << QPointF(0,0) << QPointF(100,100);
84 m_chart->addSeries(m_series);
85 m_chart->createDefaultAxes();
86 }
87
88 void tst_QValuesAxis::cleanup()
89 {
90 delete m_series;
91 delete m_valuesaxis;
92 m_series = 0;
93 m_valuesaxis = 0 ;
94 tst_QAbstractAxis::cleanup();
95 }
96
97 void tst_QValuesAxis::qvaluesaxis_data()
98 {
99 }
100
101 void tst_QValuesAxis::qvaluesaxis()
102 {
103 qabstractaxis();
104
105 QVERIFY(qFuzzyIsNull(m_valuesaxis->max()));
106 QVERIFY(qFuzzyIsNull(m_valuesaxis->min()));
107 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
108 QCOMPARE(m_valuesaxis->ticksCount(), 5);
109 QCOMPARE(m_valuesaxis->type(), QAbstractAxis::AxisTypeValues);
110
111 m_chart->setAxisX(m_valuesaxis,m_series);
112 m_view->show();
113 QTest::qWaitForWindowShown(m_view);
114
115 QVERIFY(!qFuzzyIsNull(m_valuesaxis->max()));
116 QVERIFY(!qFuzzyIsNull(m_valuesaxis->min()));
117 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
118 QCOMPARE(m_valuesaxis->ticksCount(), 5);
119 }
120
121 void tst_QValuesAxis::max_data()
122 {
123 QTest::addColumn<qreal>("max");
124 QTest::newRow("null") << 0.0;
125 }
126
127 // public qreal max() const
128 void tst_QValuesAxis::max()
129 {
130 #if 0
131 QFETCH(qreal, max);
132
133 SubQValuesAxis axis;
134
135 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
136 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
137 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
138
139 QCOMPARE(axis.max(), max);
140
141 QCOMPARE(spy0.count(), 0);
142 QCOMPARE(spy1.count(), 0);
143 QCOMPARE(spy2.count(), 0);
144 #endif
145 QSKIP("Test is not implemented.", SkipAll);
146 }
147
148 void tst_QValuesAxis::min_data()
149 {
150 QTest::addColumn<qreal>("min");
151 QTest::newRow("null") << 0.0;
152 }
153
154 // public qreal min() const
155 void tst_QValuesAxis::min()
156 {
157 #if 0
158 QFETCH(qreal, min);
159
160 SubQValuesAxis axis;
161
162 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
163 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
164 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
165
166 QCOMPARE(axis.min(), min);
167
168 QCOMPARE(spy0.count(), 0);
169 QCOMPARE(spy1.count(), 0);
170 QCOMPARE(spy2.count(), 0);
171 #endif
172 QSKIP("Test is not implemented.", SkipAll);
173 }
174
175 void tst_QValuesAxis::niceNumbersEnabled_data()
176 {
177 QTest::addColumn<bool>("niceNumbersEnabled");
178 QTest::newRow("true") << true;
179 QTest::newRow("false") << false;
180 }
181
182 // public bool niceNumbersEnabled() const
183 void tst_QValuesAxis::niceNumbersEnabled()
184 {
185 #if 0
186 QFETCH(bool, niceNumbersEnabled);
187
188 SubQValuesAxis axis;
189
190 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
191 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
192 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
193
194 QCOMPARE(axis.niceNumbersEnabled(), niceNumbersEnabled);
195
196 QCOMPARE(spy0.count(), 0);
197 QCOMPARE(spy1.count(), 0);
198 QCOMPARE(spy2.count(), 0);
199 #endif
200 QSKIP("Test is not implemented.", SkipAll);
201 }
202
203
204 void tst_QValuesAxis::setNiceNumbersEnabled_data()
205 {
206 QTest::addColumn<bool>("enable");
207 QTest::newRow("true") << true;
208 QTest::newRow("false") << false;
209 }
210
211 // public void setNiceNumbersEnabled(bool enable = true)
212 void tst_QValuesAxis::setNiceNumbersEnabled()
213 {
214 #if 0
215 QFETCH(bool, enable);
216
217 SubQValuesAxis axis;
218
219 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
220 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
221 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
222
223 axis.setNiceNumbersEnabled(enable);
224
225 QCOMPARE(spy0.count(), 0);
226 QCOMPARE(spy1.count(), 0);
227 QCOMPARE(spy2.count(), 0);
228 #endif
229 QSKIP("Test is not implemented.", SkipAll);
230 }
231
232 void tst_QValuesAxis::setRange_data()
233 {
234 QTest::addColumn<qreal>("min");
235 QTest::addColumn<qreal>("max");
236 QTest::newRow("null") << 0.0 << 0.0;
237 }
238
239 // public void setRange(qreal min, qreal max)
240 void tst_QValuesAxis::setRange()
241 {
242 #if 0
243 QFETCH(qreal, min);
244 QFETCH(qreal, max);
245
246 SubQValuesAxis axis;
247
248 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
249 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
250 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
251
252 axis.setRange(min, max);
253
254 QCOMPARE(spy0.count(), 0);
255 QCOMPARE(spy1.count(), 0);
256 QCOMPARE(spy2.count(), 0);
257 #endif
258 QSKIP("Test is not implemented.", SkipAll);
259 }
260
261 void tst_QValuesAxis::setTicksCount_data()
262 {
263 QTest::addColumn<int>("count");
264 QTest::newRow("0") << 0;
265 QTest::newRow("-1") << -1;
266 }
267
268 // public void setTicksCount(int count)
269 void tst_QValuesAxis::setTicksCount()
270 {
271 #if 0
272 QFETCH(int, count);
273
274 SubQValuesAxis axis;
275
276 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
277 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
278 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
279
280 axis.setTicksCount(count);
281
282 QCOMPARE(spy0.count(), 0);
283 QCOMPARE(spy1.count(), 0);
284 QCOMPARE(spy2.count(), 0);
285 #endif
286 QSKIP("Test is not implemented.", SkipAll);
287 }
288
289 void tst_QValuesAxis::ticksCount_data()
290 {
291 QTest::addColumn<int>("ticksCount");
292 QTest::newRow("0") << 0;
293 QTest::newRow("-1") << -1;
294 }
295
296 // public int ticksCount() const
297 void tst_QValuesAxis::ticksCount()
298 {
299 #if 0
300 QFETCH(int, ticksCount);
301
302 SubQValuesAxis axis;
303
304 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
305 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
306 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
307
308 QCOMPARE(axis.ticksCount(), ticksCount);
309
310 QCOMPARE(spy0.count(), 0);
311 QCOMPARE(spy1.count(), 0);
312 QCOMPARE(spy2.count(), 0);
313 #endif
314 QSKIP("Test is not implemented.", SkipAll);
315 }
316
317 Q_DECLARE_METATYPE(QAbstractAxis::AxisType)
318 void tst_QValuesAxis::type_data()
319 {
320 #if 0
321 QTest::addColumn<AxisType>("type");
322 QTest::newRow("null") << AxisType();
323 #endif
324 }
325
326 // public AxisType type() const
327 void tst_QValuesAxis::type()
328 {
329 #if 0
330 QFETCH(AxisType, type);
331
332 SubQValuesAxis axis;
333
334 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
335 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
336 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
337
338 QCOMPARE(axis.type(), type);
339
340 QCOMPARE(spy0.count(), 0);
341 QCOMPARE(spy1.count(), 0);
342 QCOMPARE(spy2.count(), 0);
343 #endif
344 QSKIP("Test is not implemented.", SkipAll);
345 }
346
347 void tst_QValuesAxis::maxChanged_data()
348 {
349 QTest::addColumn<qreal>("max");
350 QTest::newRow("null") << 0.0;
351 }
352
353 // protected void maxChanged(qreal max)
354 void tst_QValuesAxis::maxChanged()
355 {
356 #if 0
357 QFETCH(qreal, max);
358
359 SubQValuesAxis axis;
360
361 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
362 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
363 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
364
365 axis.call_maxChanged(max);
366
367 QCOMPARE(spy0.count(), 0);
368 QCOMPARE(spy1.count(), 0);
369 QCOMPARE(spy2.count(), 0);
370 #endif
371 QSKIP("Test is not implemented.", SkipAll);
372 }
373
374 void tst_QValuesAxis::minChanged_data()
375 {
376 QTest::addColumn<qreal>("min");
377 QTest::newRow("null") << 0.0;
378 }
379
380 // protected void minChanged(qreal min)
381 void tst_QValuesAxis::minChanged()
382 {
383 #if 0
384 QFETCH(qreal, min);
385
386 SubQValuesAxis axis;
387
388 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
389 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
390 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
391
392 axis.call_minChanged(min);
393
394 QCOMPARE(spy0.count(), 0);
395 QCOMPARE(spy1.count(), 0);
396 QCOMPARE(spy2.count(), 0);
397 #endif
398 QSKIP("Test is not implemented.", SkipAll);
399 }
400
401 void tst_QValuesAxis::rangeChanged_data()
402 {
403 QTest::addColumn<qreal>("min");
404 QTest::addColumn<qreal>("max");
405 QTest::newRow("null") << 0.0 << 0.0;
406 }
407
408 // protected void rangeChanged(qreal min, qreal max)
409 void tst_QValuesAxis::rangeChanged()
410 {
411 #if 0
412 QFETCH(qreal, min);
413 QFETCH(qreal, max);
414
415 SubQValuesAxis axis;
416
417 QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
418 QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
419 QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
420
421 axis.call_rangeChanged(min, max);
422
423 QCOMPARE(spy0.count(), 0);
424 QCOMPARE(spy1.count(), 0);
425 QCOMPARE(spy2.count(), 0);
426 #endif
427 QSKIP("Test is not implemented.", SkipAll);
428 }
429
430 QTEST_MAIN(tst_QValuesAxis)
431 #include "tst_qvaluesaxis.moc"
432
Show file before | Show file after | Hide comments
@@ -1,429 +1,434
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 "chartdataset_p.h"
21 #include "chartdataset_p.h"
22 #include "qchart.h"
22 #include "qchart.h"
23 #include "qvaluesaxis.h"
23 #include "qvaluesaxis.h"
24 #include "qbarcategoriesaxis.h"
24 #include "qbarcategoriesaxis.h"
25 #include "qvaluesaxis_p.h"
25 #include "qvaluesaxis_p.h"
26 #include "qabstractseries_p.h"
26 #include "qabstractseries_p.h"
27 #include "qabstractbarseries.h"
27 #include "qabstractbarseries.h"
28 #include "qstackedbarseries.h"
28 #include "qstackedbarseries.h"
29 #include "qpercentbarseries.h"
29 #include "qpercentbarseries.h"
30 #include "qpieseries.h"
30 #include "qpieseries.h"
31
31
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
32 QTCOMMERCIALCHART_BEGIN_NAMESPACE
33
33
34 ChartDataSet::ChartDataSet(QChart *parent):QObject(parent)
34 ChartDataSet::ChartDataSet(QChart *parent):QObject(parent)
35 {
35 {
36
36
37 }
37 }
38
38
39 ChartDataSet::~ChartDataSet()
39 ChartDataSet::~ChartDataSet()
40 {
40 {
41 removeAllSeries();
41 removeAllSeries();
42 }
42 }
43
43
44 void ChartDataSet::addSeries(QAbstractSeries* series)
44 void ChartDataSet::addSeries(QAbstractSeries* series)
45 {
45 {
46 Domain* domain = m_seriesDomainMap.value(series);
46 Domain* domain = m_seriesDomainMap.value(series);
47
47
48 if(domain) {
48 if(domain) {
49 qWarning() << "Can not add series. Series already on the chart";
49 qWarning() << "Can not add series. Series already on the chart";
50 return;
50 return;
51 }
51 }
52
52
53 domain = new Domain(series);
53 domain = new Domain(series);
54 m_seriesDomainMap.insert(series,domain);
54 m_seriesDomainMap.insert(series,domain);
55 series->d_ptr->scaleDomain(*domain);
55 series->d_ptr->scaleDomain(*domain);
56
56
57 createSeriesIndex(series);
57 createSeriesIndex(series);
58
58
59 series->setParent(this); // take ownership
59 series->setParent(this); // take ownership
60 series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
60 series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
61 series->d_ptr->m_dataset = this;
61 series->d_ptr->m_dataset = this;
62
62
63 emit seriesAdded(series,domain);
63 emit seriesAdded(series,domain);
64
64
65 }
65 }
66
66
67 void ChartDataSet::removeSeries(QAbstractSeries* series)
67 void ChartDataSet::removeSeries(QAbstractSeries* series)
68 {
68 {
69
69
70 if(!m_seriesDomainMap.contains(series)) {
70 if(!m_seriesDomainMap.contains(series)) {
71 qWarning()<<"Can not remove series. Series not found on the chart.";
71 qWarning()<<"Can not remove series. Series not found on the chart.";
72 return;
72 return;
73 }
73 }
74
74
75 emit seriesRemoved(series);
75 emit seriesRemoved(series);
76
76
77 Domain* domain = m_seriesDomainMap.take(series);
77 Domain* domain = m_seriesDomainMap.take(series);
78 delete domain;
78 delete domain;
79 domain = 0;
79 domain = 0;
80
80
81 removeSeriesIndex(series);
81 removeSeriesIndex(series);
82
82
83 series->setParent(0);
83 series->setParent(0);
84 series->d_ptr->m_chart = 0;
84 series->d_ptr->m_chart = 0;
85 series->d_ptr->m_dataset = 0;
85 series->d_ptr->m_dataset = 0;
86
86
87 removeAxes(series);
87 removeAxes(series);
88 }
88 }
89
89
90
90
91
91
92 void ChartDataSet::createSeriesIndex(QAbstractSeries* series)
92 void ChartDataSet::createSeriesIndex(QAbstractSeries* series)
93 {
93 {
94 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
94 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
95
95
96 int key=0;
96 int key=0;
97 while (i.hasNext()) {
97 while (i.hasNext()) {
98 i.next();
98 i.next();
99 if(i.key()!=key) {
99 if(i.key()!=key) {
100 break;
100 break;
101 }
101 }
102 key++;
102 key++;
103 }
103 }
104
104
105 m_indexSeriesMap.insert(key,series);
105 m_indexSeriesMap.insert(key,series);
106 }
106 }
107
107
108 void ChartDataSet::removeSeriesIndex(QAbstractSeries* series)
108 void ChartDataSet::removeSeriesIndex(QAbstractSeries* series)
109 {
109 {
110 int key = seriesIndex(series);
110 int key = seriesIndex(series);
111 Q_ASSERT(key!=-1);
111 Q_ASSERT(key!=-1);
112 m_indexSeriesMap.remove(key);
112 m_indexSeriesMap.remove(key);
113 }
113 }
114
114
115 void ChartDataSet::createDefaultAxes()
115 void ChartDataSet::createDefaultAxes()
116 {
116 {
117
117
118 if(m_seriesDomainMap.isEmpty()) return;
118 if(m_seriesDomainMap.isEmpty()) return;
119
119
120 QAbstractAxis::AxisTypes typeX(0);
120 QAbstractAxis::AxisTypes typeX(0);
121 QAbstractAxis::AxisTypes typeY(0);
121 QAbstractAxis::AxisTypes typeY(0);
122
122
123 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
123 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
124 while (i.hasNext()) {
124 while (i.hasNext()) {
125 i.next();
125 i.next();
126 removeAxes(i.key());
126 removeAxes(i.key());
127 }
127 }
128
128
129 i.toFront();
129 i.toFront();
130
130
131 while (i.hasNext()) {
131 while (i.hasNext()) {
132 i.next();
132 i.next();
133 QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
133 QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
134 QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
134 QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
135 if(axisX) typeX&=axisX->type();
135 if(axisX) typeX&=axisX->type();
136 else typeX|=i.key()->d_ptr->defaultAxisType(Qt::Horizontal);
136 else typeX|=i.key()->d_ptr->defaultAxisType(Qt::Horizontal);
137 if(axisY) typeY&=axisY->type();
137 if(axisY) typeY&=axisY->type();
138 else typeY|=i.key()->d_ptr->defaultAxisType(Qt::Vertical);
138 else typeY|=i.key()->d_ptr->defaultAxisType(Qt::Vertical);
139 }
139 }
140
140
141 createAxes(typeX,Qt::Horizontal);
141 createAxes(typeX,Qt::Horizontal);
142 createAxes(typeY,Qt::Vertical);
142 createAxes(typeY,Qt::Vertical);
143 }
143 }
144
144
145 void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type,Qt::Orientation orientation)
145 void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type,Qt::Orientation orientation)
146 {
146 {
147 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
147 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
148
148
149 if(type.testFlag(QAbstractAxis::AxisTypeValues) && type.testFlag(QAbstractAxis::AxisTypeCategories))
149 if(type.testFlag(QAbstractAxis::AxisTypeValues) && type.testFlag(QAbstractAxis::AxisTypeCategories))
150 {
150 {
151 while (i.hasNext()) {
151 while (i.hasNext()) {
152 i.next();
152 i.next();
153 QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation),orientation);
153 QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation),orientation);
154 if(!axis) continue;
154 if(!axis) continue;
155 initializeAxis(axis,i.key());
155 initializeAxis(axis,i.key());
156 emit axisAdded(axis,i.value());
156 emit axisAdded(axis,i.value());
157 }
157 }
158
158
159 }
159 }
160 else if(!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
160 else if(!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
161 QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(type)),orientation);
161 QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(type)),orientation);
162 i.toFront();
162 i.toFront();
163 while (i.hasNext()) {
163 while (i.hasNext()) {
164 i.next();
164 i.next();
165 initializeAxis(axis,i.key());
165 initializeAxis(axis,i.key());
166 }
166 }
167 emit axisAdded(axis,i.value());
167 emit axisAdded(axis,i.value());
168 }
168 }
169 }
169 }
170
170
171
171
172 QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type,Qt::Orientation orientation)
172 QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type,Qt::Orientation orientation)
173 {
173 {
174 QAbstractAxis* axis =0;
174 QAbstractAxis* axis =0;
175
175
176 switch(type) {
176 switch(type) {
177 case QAbstractAxis::AxisTypeValues:
177 case QAbstractAxis::AxisTypeValues:
178 axis = new QValuesAxis(this);
178 axis = new QValuesAxis(this);
179 break;
179 break;
180 case QAbstractAxis::AxisTypeCategories:
180 case QAbstractAxis::AxisTypeCategories:
181 axis = new QBarCategoriesAxis(this);
181 axis = new QBarCategoriesAxis(this);
182 break;
182 break;
183 default:
183 default:
184 axis = 0;
184 axis = 0;
185 break;
185 break;
186 }
186 }
187
187
188 if(axis)
188 if(axis)
189 axis->d_ptr->setOrientation(orientation);
189 axis->d_ptr->setOrientation(orientation);
190
190
191 return axis;
191 return axis;
192 }
192 }
193
193
194 void ChartDataSet::initializeAxis(QAbstractAxis* axis,QAbstractSeries* series)
194 void ChartDataSet::initializeAxis(QAbstractAxis* axis,QAbstractSeries* series)
195 {
195 {
196 Domain* domain = m_seriesDomainMap.value(series);
196 Domain* domain = m_seriesDomainMap.value(series);
197 axis->d_ptr->intializeDomain(domain);
197 axis->d_ptr->intializeDomain(domain);
198 series->d_ptr->initializeAxis(axis);
198 series->d_ptr->initializeAxis(axis);
199 if(axis->orientation()==Qt::Horizontal) {
199 if(axis->orientation()==Qt::Horizontal) {
200 QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
200 QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
201 QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
201 QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
202 m_seriesAxisXMap.insert(series,axis);
202 m_seriesAxisXMap.insert(series,axis);
203 }
203 }
204 else {
204 else {
205 QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
205 QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
206 QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
206 QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
207 m_seriesAxisYMap.insert(series,axis);
207 m_seriesAxisYMap.insert(series,axis);
208 }
208 }
209 axis->d_ptr->emitUpdated();
209 axis->d_ptr->emitUpdated();
210 }
210 }
211
211
212 void ChartDataSet::removeAxes(QAbstractSeries* series)
212 void ChartDataSet::removeAxes(QAbstractSeries* series)
213 {
213 {
214 QAbstractAxis* axisX = m_seriesAxisXMap.take(series);
214 QAbstractAxis* axisX = m_seriesAxisXMap.take(series);
215
215
216 if(axisX) {
216 if(axisX) {
217 QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
217 QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
218 int x = axesX.indexOf(axisX);
218 int x = axesX.indexOf(axisX);
219
219
220 if(x==-1) {
220 if(x==-1) {
221 emit axisRemoved(axisX);
221 emit axisRemoved(axisX);
222 axisX->deleteLater();
222 axisX->deleteLater();
223 }
223 }
224 }
224 }
225
225
226 QAbstractAxis* axisY = m_seriesAxisYMap.take(series);
226 QAbstractAxis* axisY = m_seriesAxisYMap.take(series);
227
227
228 if(axisY) {
228 if(axisY) {
229 QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
229 QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
230
230
231 int y = axesY.indexOf(axisY);
231 int y = axesY.indexOf(axisY);
232
232
233 if(y==-1) {
233 if(y==-1) {
234 emit axisRemoved(axisY);
234 emit axisRemoved(axisY);
235 axisY->deleteLater();
235 axisY->deleteLater();
236 }
236 }
237 }
237 }
238 }
238 }
239
239
240 void ChartDataSet::removeAllSeries()
240 void ChartDataSet::removeAllSeries()
241 {
241 {
242 QList<QAbstractSeries*> series = m_seriesDomainMap.keys();
242 QList<QAbstractSeries*> series = m_seriesDomainMap.keys();
243 foreach(QAbstractSeries *s , series) {
243 foreach(QAbstractSeries *s , series) {
244 removeSeries(s);
244 removeSeries(s);
245 }
245 }
246
246
247 Q_ASSERT(m_seriesAxisXMap.count()==0);
247 Q_ASSERT(m_seriesAxisXMap.count()==0);
248 Q_ASSERT(m_seriesAxisXMap.count()==0);
248 Q_ASSERT(m_seriesAxisXMap.count()==0);
249 Q_ASSERT(m_seriesDomainMap.count()==0);
249 Q_ASSERT(m_seriesDomainMap.count()==0);
250
250
251 qDeleteAll(series);
251 qDeleteAll(series);
252 }
252 }
253
253
254 void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
254 void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
255 {
255 {
256 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
256 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
257
257
258
258
259 blockAxisSignals(true);
259 blockAxisSignals(true);
260
260
261 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
261 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
262
262
263 while (i.hasNext()) {
263 while (i.hasNext()) {
264 i.next();
264 i.next();
265 i.value()->zoomIn(rect,size);
265 i.value()->zoomIn(rect,size);
266 }
266 }
267
267
268 blockAxisSignals(false);
268 blockAxisSignals(false);
269
269
270 }
270 }
271
271
272 void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
272 void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
273 {
273 {
274 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
274 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
275
275
276 blockAxisSignals(true);
276 blockAxisSignals(true);
277
277
278 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
278 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
279
279
280 while (i.hasNext()) {
280 while (i.hasNext()) {
281 i.next();
281 i.next();
282 i.value()->zoomOut(rect,size);
282 i.value()->zoomOut(rect,size);
283 }
283 }
284
284
285 blockAxisSignals(false);
285 blockAxisSignals(false);
286 }
286 }
287
287
288 void ChartDataSet::blockAxisSignals(bool enabled)
288 void ChartDataSet::blockAxisSignals(bool enabled)
289 {
289 {
290 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
290 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
291 while (i.hasNext()) {
291 while (i.hasNext()) {
292 i.next();
292 i.next();
293 QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
293 QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
294 QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
294 QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
295 if(axisX) axisX->d_ptr->blockSignals(enabled);
295 if(axisX) axisX->d_ptr->blockSignals(enabled);
296 if(axisY) axisY->d_ptr->blockSignals(enabled);
296 if(axisY) axisY->d_ptr->blockSignals(enabled);
297 }
297 }
298 }
298 }
299
299
300 int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
300 int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
301 {
301 {
302 int count=0;
302 int count=0;
303 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
303 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
304 while (i.hasNext()) {
304 while (i.hasNext()) {
305 i.next();
305 i.next();
306 if(i.key()->type()==type) count++;
306 if(i.key()->type()==type) count++;
307 }
307 }
308 return count;
308 return count;
309 }
309 }
310
310
311 int ChartDataSet::seriesIndex(QAbstractSeries *series)
311 int ChartDataSet::seriesIndex(QAbstractSeries *series)
312 {
312 {
313 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
313 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
314 while (i.hasNext()) {
314 while (i.hasNext()) {
315 i.next();
315 i.next();
316 if (i.value() == series)
316 if (i.value() == series)
317 return i.key();
317 return i.key();
318 }
318 }
319 return -1;
319 return -1;
320 }
320 }
321
321
322 QAbstractAxis* ChartDataSet::axisX(QAbstractSeries *series) const
322 QAbstractAxis* ChartDataSet::axisX(QAbstractSeries *series) const
323 {
323 {
324 if(series == 0) {
324 if(series == 0) {
325
325
326 QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisXMap);
326 QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisXMap);
327
327
328 while (i.hasNext()) {
328 while (i.hasNext()) {
329 i.next();
329 i.next();
330 if(i.value()->isVisible()) return i.value();
330 if(i.value()->isVisible()) return i.value();
331 }
331 }
332 return 0;
332 return 0;
333 }
333 }
334 return m_seriesAxisXMap.value(series);
334 return m_seriesAxisXMap.value(series);
335 }
335 }
336
336
337 QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
337 QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
338 {
338 {
339 if(series == 0) {
339 if(series == 0) {
340 QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisYMap);
340 QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisYMap);
341
341
342 while (i.hasNext()) {
342 while (i.hasNext()) {
343 i.next();
343 i.next();
344 if(i.value()->isVisible()) return i.value();
344 if(i.value()->isVisible()) return i.value();
345 }
345 }
346 return 0;
346 return 0;
347 }
347 }
348 return m_seriesAxisYMap.value(series);
348 return m_seriesAxisYMap.value(series);
349 }
349 }
350
350
351 void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation)
351 void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation)
352 {
352 {
353 Q_ASSERT(axis);
353 Q_ASSERT(axis);
354
354
355 if(!series) {
356 qWarning() << "Series not found on the chart.";
357 return;
358 }
359
355 Domain* domain = m_seriesDomainMap.value(series);
360 Domain* domain = m_seriesDomainMap.value(series);
356
361
357 if(!domain) {
362 if(!domain) {
358 qWarning() << "Series not found on the chart.";
363 qWarning() << "Series not found on the chart.";
359 return;
364 return;
360 }
365 }
361
366
362 if(orientation==Qt::Horizontal && axis->orientation()==Qt::Vertical) {
367 if(orientation==Qt::Horizontal && axis->orientation()==Qt::Vertical) {
363 qWarning()<<"Axis already defined as axis Y";
368 qWarning()<<"Axis already defined as axis Y";
364 return;
369 return;
365 }
370 }
366
371
367 if(orientation==Qt::Vertical && axis->orientation()==Qt::Horizontal) {
372 if(orientation==Qt::Vertical && axis->orientation()==Qt::Horizontal) {
368 qWarning()<<"Axis already defined as axis X";
373 qWarning()<<"Axis already defined as axis X";
369 return;
374 return;
370 }
375 }
371
376
372 axis->d_ptr->setOrientation(orientation);
377 axis->d_ptr->setOrientation(orientation);
373
378
374 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
379 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
375
380
376 if(orientation==Qt::Vertical) {
381 if(orientation==Qt::Vertical) {
377 seriesAxisMap= &m_seriesAxisYMap;
382 seriesAxisMap= &m_seriesAxisYMap;
378
383
379 }else{
384 }else{
380 seriesAxisMap= &m_seriesAxisXMap;
385 seriesAxisMap= &m_seriesAxisXMap;
381 }
386 }
382
387
383 QAbstractAxis *oldAxis = seriesAxisMap->take(series);
388 QAbstractAxis *oldAxis = seriesAxisMap->take(series);
384 QList<QAbstractAxis*> axes = seriesAxisMap->values();
389 QList<QAbstractAxis*> axes = seriesAxisMap->values();
385
390
386 if(oldAxis) {
391 if(oldAxis) {
387 if(axes.indexOf(oldAxis)==-1) {
392 if(axes.indexOf(oldAxis)==-1) {
388 emit axisRemoved(oldAxis);
393 emit axisRemoved(oldAxis);
389 oldAxis->deleteLater();
394 oldAxis->deleteLater();
390 }
395 }
391 }
396 }
392
397
393 if(axes.indexOf(axis)==-1) {
398 if(axes.indexOf(axis)==-1) {
394 initializeAxis(axis,series);
399 initializeAxis(axis,series);
395 emit axisAdded(axis,domain);
400 emit axisAdded(axis,domain);
396 }else{
401 }else{
397 initializeAxis(axis,series);
402 initializeAxis(axis,series);
398 }
403 }
399 }
404 }
400
405
401 Domain* ChartDataSet::domain(QAbstractSeries *series) const
406 Domain* ChartDataSet::domain(QAbstractSeries *series) const
402 {
407 {
403 return m_seriesDomainMap.value(series);
408 return m_seriesDomainMap.value(series);
404 }
409 }
405
410
406 void ChartDataSet::scrollDomain(qreal dx,qreal dy,const QSizeF& size)
411 void ChartDataSet::scrollDomain(qreal dx,qreal dy,const QSizeF& size)
407 {
412 {
408 blockAxisSignals(true);
413 blockAxisSignals(true);
409 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
414 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
410 while (i.hasNext()) {
415 while (i.hasNext()) {
411 i.next();
416 i.next();
412 i.value()->move(dx,dy,size);
417 i.value()->move(dx,dy,size);
413 }
418 }
414 blockAxisSignals(false);
419 blockAxisSignals(false);
415 }
420 }
416
421
417 QList<QAbstractSeries*> ChartDataSet::series() const
422 QList<QAbstractSeries*> ChartDataSet::series() const
418 {
423 {
419 return m_seriesDomainMap.keys();
424 return m_seriesDomainMap.keys();
420 }
425 }
421
426
422 void ChartDataSet::updateSeries(QAbstractSeries *series)
427 void ChartDataSet::updateSeries(QAbstractSeries *series)
423 {
428 {
424 emit seriesUpdated(series);
429 emit seriesUpdated(series);
425 }
430 }
426
431
427 #include "moc_chartdataset_p.cpp"
432 #include "moc_chartdataset_p.cpp"
428
433
429 QTCOMMERCIALCHART_END_NAMESPACE
434 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,10 +1,27
1 !include( ../tests.pri ) {
1 !include( ../tests.pri ) {
2 error( "Couldn't find the tests.pri file!" )
2 error( "Couldn't find the tests.pri file!" )
3 }
3 }
4
4
5 TEMPLATE = subdirs
5 TEMPLATE = subdirs
6 SUBDIRS += qchartview qchart qlineseries qbarset qbarseries qstackedbarseries qpercentbarseries qpieslice qpieseries qpiemodelmapper qsplineseries qscatterseries qxymodelmapper qbarmodelmapper qhorizontalbarseries qhorizontalstackedbarseries qhorizontalpercentbarseries
6 SUBDIRS += \
7 qchartview \
8 qchart \
9 qlineseries \
10 qbarset \
11 qbarseries \
12 qstackedbarseries \
13 qpercentbarseries \
14 qpieslice qpieseries \
15 qpiemodelmapper \
16 qsplineseries \
17 qscatterseries \
18 qxymodelmapper \
19 qbarmodelmapper \
20 qhorizontalbarseries \
21 qhorizontalstackedbarseries \
22 qhorizontalpercentbarseries \
23 qvaluesaxis
7
24
8 test_private:{
25 test_private:{
9 SUBDIRS += domain chartdataset
26 SUBDIRS += domain chartdataset
10 }
27 }
Show file before | Show file after | Hide comments
@@ -1,101 +1,102
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 "../qxyseries/tst_qxyseries.h"
21 #include "../qxyseries/tst_qxyseries.h"
22 #include <qlineseries.h>
22 #include <qlineseries.h>
23
23
24
24
25 Q_DECLARE_METATYPE(QList<QPointF>)
25 Q_DECLARE_METATYPE(QList<QPointF>)
26
26
27 class tst_QLineSeries : public tst_QXYSeries
27 class tst_QLineSeries : public tst_QXYSeries
28 {
28 {
29 Q_OBJECT
29 Q_OBJECT
30
30
31 public slots:
31 public slots:
32 void initTestCase();
32 void initTestCase();
33 void cleanupTestCase();
33 void cleanupTestCase();
34 void init();
34 void init();
35 void cleanup();
35 void cleanup();
36 private slots:
36 private slots:
37 void qlineseries_data();
37 void qlineseries_data();
38 void qlineseries();
38 void qlineseries();
39 protected:
39 protected:
40 void pointsVisible_data();
40 void pointsVisible_data();
41 };
41 };
42
42
43 void tst_QLineSeries::initTestCase()
43 void tst_QLineSeries::initTestCase()
44 {
44 {
45 }
45 }
46
46
47 void tst_QLineSeries::cleanupTestCase()
47 void tst_QLineSeries::cleanupTestCase()
48 {
48 {
49 }
49 }
50
50
51 void tst_QLineSeries::init()
51 void tst_QLineSeries::init()
52 {
52 {
53 tst_QXYSeries::init();
53 tst_QXYSeries::init();
54 m_series = new QLineSeries();
54 m_series = new QLineSeries();
55 }
55 }
56
56
57 void tst_QLineSeries::cleanup()
57 void tst_QLineSeries::cleanup()
58 {
58 {
59 delete m_series;
59 delete m_series;
60 m_series=0;
60 tst_QXYSeries::cleanup();
61 tst_QXYSeries::cleanup();
61 }
62 }
62
63
63 void tst_QLineSeries::qlineseries_data()
64 void tst_QLineSeries::qlineseries_data()
64 {
65 {
65
66
66 }
67 }
67
68
68 void tst_QLineSeries::qlineseries()
69 void tst_QLineSeries::qlineseries()
69 {
70 {
70 QLineSeries series;
71 QLineSeries series;
71
72
72 QCOMPARE(series.count(),0);
73 QCOMPARE(series.count(),0);
73 QCOMPARE(series.brush(), QBrush());
74 QCOMPARE(series.brush(), QBrush());
74 QCOMPARE(series.points(), QList<QPointF>());
75 QCOMPARE(series.points(), QList<QPointF>());
75 QCOMPARE(series.pen(), QPen());
76 QCOMPARE(series.pen(), QPen());
76 QCOMPARE(series.pointsVisible(), false);
77 QCOMPARE(series.pointsVisible(), false);
77
78
78 series.append(QList<QPointF>());
79 series.append(QList<QPointF>());
79 series.append(0.0,0.0);
80 series.append(0.0,0.0);
80 series.append(QPointF());
81 series.append(QPointF());
81
82
82 series.remove(0.0,0.0);
83 series.remove(0.0,0.0);
83 series.remove(QPointF());
84 series.remove(QPointF());
84 series.clear();
85 series.clear();
85
86
86 series.replace(QPointF(),QPointF());
87 series.replace(QPointF(),QPointF());
87 series.replace(0,0,0,0);
88 series.replace(0,0,0,0);
88 series.setBrush(QBrush());
89 series.setBrush(QBrush());
89
90
90 series.setPen(QPen());
91 series.setPen(QPen());
91 series.setPointsVisible(false);
92 series.setPointsVisible(false);
92
93
93 m_chart->addSeries(&series);
94 m_chart->addSeries(&series);
94 m_view->show();
95 m_view->show();
95 QTest::qWaitForWindowShown(m_view);
96 QTest::qWaitForWindowShown(m_view);
96 }
97 }
97
98
98 QTEST_MAIN(tst_QLineSeries)
99 QTEST_MAIN(tst_QLineSeries)
99
100
100 #include "tst_qlineseries.moc"
101 #include "tst_qlineseries.moc"
101
102
General Comments 0
You need to be logged in to leave comments. Login now