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

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

Adds tst_qchartview draft
Michal Klocek -
r774:de60163b4c1f
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,4
1 !include( ../../test.pri ) {
2 error( "Couldn't find the test.pri file!" )
3 }
4 SOURCES += tst_qchartview.cpp No newline at end of file
Show file before | Show file after | Hide comments
@@ -0,0 +1,117
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
22 #include <QtTest/QtTest>
23 #include <qchartview.h>
24
25 QTCOMMERCIALCHART_USE_NAMESPACE
26
27
28 Q_DECLARE_METATYPE(QChart*)
29 Q_DECLARE_METATYPE(QChartView::RubberBands)
30
31 class tst_QChartView : public QObject
32 {
33 Q_OBJECT
34
35 public Q_SLOTS:
36 void initTestCase();
37 void cleanupTestCase();
38 void init();
39 void cleanup();
40
41 private Q_SLOTS:
42 void qchartview_data();
43 void qchartview();
44
45 void chart_data();
46 void chart();
47 void rubberBand_data();
48 void rubberBand();
49
50 private:
51 QChartView* m_view;
52 };
53
54 void tst_QChartView::initTestCase()
55 {
56 }
57
58 void tst_QChartView::cleanupTestCase()
59 {
60 }
61
62 void tst_QChartView::init()
63 {
64 m_view = new QChartView(new QChart());
65 }
66
67 void tst_QChartView::cleanup()
68 {
69 delete m_view;
70 m_view =0;
71 }
72
73 void tst_QChartView::qchartview_data()
74 {
75
76 }
77
78 void tst_QChartView::qchartview()
79 {
80 QVERIFY(m_view->chart());
81 QCOMPARE(m_view->rubberBand(), QChartView::NoRubberBand);
82 QTest::qWaitForWindowShown(m_view);
83 }
84
85 void tst_QChartView::chart_data()
86 {
87
88 QTest::addColumn<QChart*>("chart");
89 QTest::newRow("qchart") << new QChart();
90 }
91
92 void tst_QChartView::chart()
93 {
94 QFETCH(QChart*, chart);
95 QChartView* view = new QChartView(chart);
96 QCOMPARE(view->chart(), chart);
97 delete view;
98 }
99
100 void tst_QChartView::rubberBand_data()
101 {
102 QTest::addColumn<QChartView::RubberBands>("rubberBand");
103 QTest::newRow("HorizonalRubberBand") << QChartView::RubberBands(QChartView::HorizonalRubberBand);
104 QTest::newRow("VerticalRubberBand") << QChartView::RubberBands(QChartView::VerticalRubberBand);
105 QTest::newRow("RectangleRubberBand") << QChartView::RubberBands(QChartView::RectangleRubberBand);
106 }
107
108 void tst_QChartView::rubberBand()
109 {
110 QFETCH(QChartView::RubberBands, rubberBand);
111 m_view->setRubberBand(rubberBand);
112 QCOMPARE(m_view->rubberBand(), rubberBand);
113 }
114
115 QTEST_MAIN(tst_QChartView)
116 #include "tst_qchartview.moc"
117
Show file before | Show file after | Hide comments
@@ -1,2 +1,2
1 TEMPLATE = subdirs
1 TEMPLATE = subdirs
2 SUBDIRS += chartdataset domain No newline at end of file
2 SUBDIRS += chartdataset domain qchartview No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,692 +1,712
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
1 #include <QtTest/QtTest>
21 #include <QtTest/QtTest>
2 #include <private/domain_p.h>
22 #include <private/domain_p.h>
3 #include <qchartaxis.h>
23 #include <qchartaxis.h>
4
24
5 QTCOMMERCIALCHART_USE_NAMESPACE
25 QTCOMMERCIALCHART_USE_NAMESPACE
6
26
7 Q_DECLARE_METATYPE(Domain*)
27 Q_DECLARE_METATYPE(Domain*)
8 Q_DECLARE_METATYPE(QSizeF)
28 Q_DECLARE_METATYPE(QSizeF)
9
29
10 class tst_Domain: public QObject
30 class tst_Domain: public QObject
11 {
31 {
12 Q_OBJECT
32 Q_OBJECT
13
33
14 public slots:
34 public Q_SLOTS:
15 void initTestCase();
35 void initTestCase();
16 void cleanupTestCase();
36 void cleanupTestCase();
17 void init();
37 void init();
18 void cleanup();
38 void cleanup();
19
39
20 private slots:
40 private Q_SLOTS:
21 void domain();
41 void domain();
22 void handleAxisRangeXChanged_data();
42 void handleAxisRangeXChanged_data();
23 void handleAxisRangeXChanged();
43 void handleAxisRangeXChanged();
24 void handleAxisRangeYChanged_data();
44 void handleAxisRangeYChanged_data();
25 void handleAxisRangeYChanged();
45 void handleAxisRangeYChanged();
26 void isEmpty_data();
46 void isEmpty_data();
27 void isEmpty();
47 void isEmpty();
28 void maxX_data();
48 void maxX_data();
29 void maxX();
49 void maxX();
30 void maxY_data();
50 void maxY_data();
31 void maxY();
51 void maxY();
32 void minX_data();
52 void minX_data();
33 void minX();
53 void minX();
34 void minY_data();
54 void minY_data();
35 void minY();
55 void minY();
36 void operatorEquals_data();
56 void operatorEquals_data();
37 void operatorEquals();
57 void operatorEquals();
38 void setRange_data();
58 void setRange_data();
39 void setRange();
59 void setRange();
40 void setRangeX_data();
60 void setRangeX_data();
41 void setRangeX();
61 void setRangeX();
42 void setRangeY_data();
62 void setRangeY_data();
43 void setRangeY();
63 void setRangeY();
44 void spanX_data();
64 void spanX_data();
45 void spanX();
65 void spanX();
46 void spanY_data();
66 void spanY_data();
47 void spanY();
67 void spanY();
48 void zoom_data();
68 void zoom_data();
49 void zoom();
69 void zoom();
50 void move_data();
70 void move_data();
51 void move();
71 void move();
52 void handleAxisXChanged_data();
72 void handleAxisXChanged_data();
53 void handleAxisXChanged();
73 void handleAxisXChanged();
54 void handleAxisYChanged_data();
74 void handleAxisYChanged_data();
55 void handleAxisYChanged();
75 void handleAxisYChanged();
56 };
76 };
57
77
58 void tst_Domain::initTestCase()
78 void tst_Domain::initTestCase()
59 {
79 {
60 }
80 }
61
81
62 void tst_Domain::cleanupTestCase()
82 void tst_Domain::cleanupTestCase()
63 {
83 {
64 }
84 }
65
85
66 void tst_Domain::init()
86 void tst_Domain::init()
67 {
87 {
68 }
88 }
69
89
70 void tst_Domain::cleanup()
90 void tst_Domain::cleanup()
71 {
91 {
72 }
92 }
73
93
74 void tst_Domain::domain()
94 void tst_Domain::domain()
75 {
95 {
76 Domain domain;
96 Domain domain;
77
97
78 QCOMPARE(domain.isEmpty(), true);
98 QCOMPARE(domain.isEmpty(), true);
79 QCOMPARE(domain.maxX(), 0.0);
99 QCOMPARE(domain.maxX(), 0.0);
80 QCOMPARE(domain.maxY(), 0.0);
100 QCOMPARE(domain.maxY(), 0.0);
81 QCOMPARE(domain.minX(), 0.0);
101 QCOMPARE(domain.minX(), 0.0);
82 QCOMPARE(domain.minY(), 0.0);
102 QCOMPARE(domain.minY(), 0.0);
83 }
103 }
84
104
85 void tst_Domain::handleAxisRangeXChanged_data()
105 void tst_Domain::handleAxisRangeXChanged_data()
86 {
106 {
87 QTest::addColumn<qreal>("min");
107 QTest::addColumn<qreal>("min");
88 QTest::addColumn<qreal>("max");
108 QTest::addColumn<qreal>("max");
89 QTest::newRow("-1 1") << -1.0 << 1.0;
109 QTest::newRow("-1 1") << -1.0 << 1.0;
90 QTest::newRow("0 1") << 0.0 << 1.0;
110 QTest::newRow("0 1") << 0.0 << 1.0;
91 QTest::newRow("-1 0") << -1.0 << 0.0;
111 QTest::newRow("-1 0") << -1.0 << 0.0;
92 }
112 }
93
113
94 void tst_Domain::handleAxisRangeXChanged()
114 void tst_Domain::handleAxisRangeXChanged()
95 {
115 {
96 QFETCH(qreal, min);
116 QFETCH(qreal, min);
97 QFETCH(qreal, max);
117 QFETCH(qreal, max);
98
118
99 Domain domain;
119 Domain domain;
100
120
101 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
121 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
102 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
122 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
103 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
123 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
104
124
105 domain.handleAxisXChanged(min, max);
125 domain.handleAxisXChanged(min, max);
106
126
107 QList<QVariant> arg0 = spy0.first();
127 QList<QVariant> arg0 = spy0.first();
108 QVERIFY(qFuzzyIsNull(arg0.at(0).toReal() - min));
128 QVERIFY(qFuzzyIsNull(arg0.at(0).toReal() - min));
109 QVERIFY(qFuzzyIsNull(arg0.at(1).toReal() - max));
129 QVERIFY(qFuzzyIsNull(arg0.at(1).toReal() - max));
110
130
111 QList<QVariant> arg1 = spy1.first();
131 QList<QVariant> arg1 = spy1.first();
112 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
132 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
113 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
133 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
114
134
115 QCOMPARE(spy0.count(), 1);
135 QCOMPARE(spy0.count(), 1);
116 QCOMPARE(spy1.count(), 1);
136 QCOMPARE(spy1.count(), 1);
117 QCOMPARE(spy2.count(), 0);
137 QCOMPARE(spy2.count(), 0);
118
138
119 }
139 }
120
140
121 void tst_Domain::handleAxisRangeYChanged_data()
141 void tst_Domain::handleAxisRangeYChanged_data()
122 {
142 {
123 QTest::addColumn<qreal>("min");
143 QTest::addColumn<qreal>("min");
124 QTest::addColumn<qreal>("max");
144 QTest::addColumn<qreal>("max");
125 QTest::newRow("-1 1") << -1.0 << 1.0;
145 QTest::newRow("-1 1") << -1.0 << 1.0;
126 QTest::newRow("0 1") << 0.0 << 1.0;
146 QTest::newRow("0 1") << 0.0 << 1.0;
127 QTest::newRow("-1 0") << -1.0 << 0.0;
147 QTest::newRow("-1 0") << -1.0 << 0.0;
128 }
148 }
129
149
130 void tst_Domain::handleAxisRangeYChanged()
150 void tst_Domain::handleAxisRangeYChanged()
131 {
151 {
132 QFETCH(qreal, min);
152 QFETCH(qreal, min);
133 QFETCH(qreal, max);
153 QFETCH(qreal, max);
134
154
135 Domain domain;
155 Domain domain;
136
156
137 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
157 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
138 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
158 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
139 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
159 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
140
160
141 domain.handleAxisYChanged(min, max, 5);
161 domain.handleAxisYChanged(min, max, 5);
142
162
143 QList<QVariant> arg0 = spy0.first();
163 QList<QVariant> arg0 = spy0.first();
144 QVERIFY(qFuzzyIsNull(arg0.at(2).toReal() - min));
164 QVERIFY(qFuzzyIsNull(arg0.at(2).toReal() - min));
145 QVERIFY(qFuzzyIsNull(arg0.at(3).toReal() - max));
165 QVERIFY(qFuzzyIsNull(arg0.at(3).toReal() - max));
146
166
147 QList<QVariant> arg1 = spy2.first();
167 QList<QVariant> arg1 = spy2.first();
148 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
168 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
149 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
169 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
150
170
151 QCOMPARE(spy0.count(), 1);
171 QCOMPARE(spy0.count(), 1);
152 QCOMPARE(spy1.count(), 0);
172 QCOMPARE(spy1.count(), 0);
153 QCOMPARE(spy2.count(), 1);
173 QCOMPARE(spy2.count(), 1);
154 }
174 }
155
175
156 void tst_Domain::isEmpty_data()
176 void tst_Domain::isEmpty_data()
157 {
177 {
158 QTest::addColumn<qreal>("minX");
178 QTest::addColumn<qreal>("minX");
159 QTest::addColumn<qreal>("maxX");
179 QTest::addColumn<qreal>("maxX");
160 QTest::addColumn<qreal>("minY");
180 QTest::addColumn<qreal>("minY");
161 QTest::addColumn<qreal>("maxY");
181 QTest::addColumn<qreal>("maxY");
162 QTest::addColumn<bool>("isEmpty");
182 QTest::addColumn<bool>("isEmpty");
163 QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << true;
183 QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << true;
164 QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << true;
184 QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << true;
165 QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << true;
185 QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << true;
166 QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << false;
186 QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << false;
167 }
187 }
168
188
169 void tst_Domain::isEmpty()
189 void tst_Domain::isEmpty()
170 {
190 {
171 QFETCH(qreal, minX);
191 QFETCH(qreal, minX);
172 QFETCH(qreal, maxX);
192 QFETCH(qreal, maxX);
173 QFETCH(qreal, minY);
193 QFETCH(qreal, minY);
174 QFETCH(qreal, maxY);
194 QFETCH(qreal, maxY);
175 QFETCH(bool, isEmpty);
195 QFETCH(bool, isEmpty);
176
196
177 Domain domain;
197 Domain domain;
178 domain.setRange(minX, maxX, minY, maxY);
198 domain.setRange(minX, maxX, minY, maxY);
179 QCOMPARE(domain.isEmpty(), isEmpty);
199 QCOMPARE(domain.isEmpty(), isEmpty);
180 }
200 }
181
201
182 void tst_Domain::maxX_data()
202 void tst_Domain::maxX_data()
183 {
203 {
184 QTest::addColumn<qreal>("maxX1");
204 QTest::addColumn<qreal>("maxX1");
185 QTest::addColumn<qreal>("maxX2");
205 QTest::addColumn<qreal>("maxX2");
186 QTest::addColumn<int>("count");
206 QTest::addColumn<int>("count");
187 QTest::newRow("1") << 0.0 << 1.0 << 1;
207 QTest::newRow("1") << 0.0 << 1.0 << 1;
188 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
208 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
189 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
209 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
190 }
210 }
191
211
192 void tst_Domain::maxX()
212 void tst_Domain::maxX()
193 {
213 {
194 QFETCH(qreal, maxX1);
214 QFETCH(qreal, maxX1);
195 QFETCH(qreal, maxX2);
215 QFETCH(qreal, maxX2);
196 QFETCH(int, count);
216 QFETCH(int, count);
197
217
198 Domain domain;
218 Domain domain;
199
219
200 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
220 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
201 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
221 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
202 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
222 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
203
223
204 domain.setMaxX(maxX1);
224 domain.setMaxX(maxX1);
205 QCOMPARE(domain.maxX(), maxX1);
225 QCOMPARE(domain.maxX(), maxX1);
206 domain.setMaxX(maxX2);
226 domain.setMaxX(maxX2);
207 QCOMPARE(domain.maxX(), maxX2);
227 QCOMPARE(domain.maxX(), maxX2);
208
228
209 QCOMPARE(spy0.count(), count);
229 QCOMPARE(spy0.count(), count);
210 QCOMPARE(spy1.count(), count);
230 QCOMPARE(spy1.count(), count);
211 QCOMPARE(spy2.count(), 0);
231 QCOMPARE(spy2.count(), 0);
212
232
213 }
233 }
214
234
215 void tst_Domain::maxY_data()
235 void tst_Domain::maxY_data()
216 {
236 {
217 QTest::addColumn<qreal>("maxY1");
237 QTest::addColumn<qreal>("maxY1");
218 QTest::addColumn<qreal>("maxY2");
238 QTest::addColumn<qreal>("maxY2");
219 QTest::addColumn<int>("count");
239 QTest::addColumn<int>("count");
220 QTest::newRow("1") << 0.0 << 1.0 << 1;
240 QTest::newRow("1") << 0.0 << 1.0 << 1;
221 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
241 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
222 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
242 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
223 }
243 }
224
244
225 void tst_Domain::maxY()
245 void tst_Domain::maxY()
226 {
246 {
227 QFETCH(qreal, maxY1);
247 QFETCH(qreal, maxY1);
228 QFETCH(qreal, maxY2);
248 QFETCH(qreal, maxY2);
229 QFETCH(int, count);
249 QFETCH(int, count);
230
250
231 Domain domain;
251 Domain domain;
232
252
233 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
253 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
234 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
254 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
235 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
255 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
236
256
237 domain.setMaxY(maxY1);
257 domain.setMaxY(maxY1);
238 QCOMPARE(domain.maxY(), maxY1);
258 QCOMPARE(domain.maxY(), maxY1);
239 domain.setMaxY(maxY2);
259 domain.setMaxY(maxY2);
240 QCOMPARE(domain.maxY(), maxY2);
260 QCOMPARE(domain.maxY(), maxY2);
241
261
242 QCOMPARE(spy0.count(), count);
262 QCOMPARE(spy0.count(), count);
243 QCOMPARE(spy1.count(), 0);
263 QCOMPARE(spy1.count(), 0);
244 QCOMPARE(spy2.count(), count);
264 QCOMPARE(spy2.count(), count);
245 }
265 }
246
266
247 void tst_Domain::minX_data()
267 void tst_Domain::minX_data()
248 {
268 {
249 QTest::addColumn<qreal>("minX1");
269 QTest::addColumn<qreal>("minX1");
250 QTest::addColumn<qreal>("minX2");
270 QTest::addColumn<qreal>("minX2");
251 QTest::addColumn<int>("count");
271 QTest::addColumn<int>("count");
252 QTest::newRow("1") << 0.0 << 1.0 << 1;
272 QTest::newRow("1") << 0.0 << 1.0 << 1;
253 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
273 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
254 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
274 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
255 }
275 }
256
276
257 void tst_Domain::minX()
277 void tst_Domain::minX()
258 {
278 {
259 QFETCH(qreal, minX1);
279 QFETCH(qreal, minX1);
260 QFETCH(qreal, minX2);
280 QFETCH(qreal, minX2);
261 QFETCH(int, count);
281 QFETCH(int, count);
262
282
263 Domain domain;
283 Domain domain;
264
284
265 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
285 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
266 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
286 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
267 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
287 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
268
288
269 domain.setMinX(minX1);
289 domain.setMinX(minX1);
270 QCOMPARE(domain.minX(), minX1);
290 QCOMPARE(domain.minX(), minX1);
271 domain.setMinX(minX2);
291 domain.setMinX(minX2);
272 QCOMPARE(domain.minX(), minX2);
292 QCOMPARE(domain.minX(), minX2);
273
293
274 QCOMPARE(spy0.count(), count);
294 QCOMPARE(spy0.count(), count);
275 QCOMPARE(spy1.count(), count);
295 QCOMPARE(spy1.count(), count);
276 QCOMPARE(spy2.count(), 0);
296 QCOMPARE(spy2.count(), 0);
277 }
297 }
278
298
279 void tst_Domain::minY_data()
299 void tst_Domain::minY_data()
280 {
300 {
281 QTest::addColumn<qreal>("minY1");
301 QTest::addColumn<qreal>("minY1");
282 QTest::addColumn<qreal>("minY2");
302 QTest::addColumn<qreal>("minY2");
283 QTest::addColumn<int>("count");
303 QTest::addColumn<int>("count");
284 QTest::newRow("1") << 0.0 << 1.0 << 1;
304 QTest::newRow("1") << 0.0 << 1.0 << 1;
285 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
305 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
286 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
306 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
287 }
307 }
288
308
289 void tst_Domain::minY()
309 void tst_Domain::minY()
290 {
310 {
291 QFETCH(qreal, minY1);
311 QFETCH(qreal, minY1);
292 QFETCH(qreal, minY2);
312 QFETCH(qreal, minY2);
293 QFETCH(int, count);
313 QFETCH(int, count);
294
314
295 Domain domain;
315 Domain domain;
296
316
297 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
317 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
298 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
318 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
299 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
319 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
300
320
301 domain.setMinY(minY1);
321 domain.setMinY(minY1);
302 QCOMPARE(domain.minY(), minY1);
322 QCOMPARE(domain.minY(), minY1);
303 domain.setMinY(minY2);
323 domain.setMinY(minY2);
304 QCOMPARE(domain.minY(), minY2);
324 QCOMPARE(domain.minY(), minY2);
305
325
306 QCOMPARE(spy0.count(), count);
326 QCOMPARE(spy0.count(), count);
307 QCOMPARE(spy1.count(), 0);
327 QCOMPARE(spy1.count(), 0);
308 QCOMPARE(spy2.count(), count);
328 QCOMPARE(spy2.count(), count);
309 }
329 }
310
330
311 void tst_Domain::operatorEquals_data()
331 void tst_Domain::operatorEquals_data()
312 {
332 {
313
333
314 QTest::addColumn<Domain*>("domain1");
334 QTest::addColumn<Domain*>("domain1");
315 QTest::addColumn<Domain*>("domain2");
335 QTest::addColumn<Domain*>("domain2");
316 QTest::addColumn<bool>("equals");
336 QTest::addColumn<bool>("equals");
317 QTest::addColumn<bool>("notEquals");
337 QTest::addColumn<bool>("notEquals");
318 Domain* a;
338 Domain* a;
319 Domain* b;
339 Domain* b;
320 a = new Domain();
340 a = new Domain();
321 a->setRange(0, 100, 0, 100);
341 a->setRange(0, 100, 0, 100);
322 b = new Domain();
342 b = new Domain();
323 b->setRange(0, 100, 0, 100);
343 b->setRange(0, 100, 0, 100);
324 QTest::newRow("equals") << a << b << true << false;
344 QTest::newRow("equals") << a << b << true << false;
325 a = new Domain();
345 a = new Domain();
326 a->setRange(0, 100, 0, 100);
346 a->setRange(0, 100, 0, 100);
327 b = new Domain();
347 b = new Domain();
328 b->setRange(0, 100, 0, 1);
348 b->setRange(0, 100, 0, 1);
329 QTest::newRow("equals") << a << b << false << true;
349 QTest::newRow("equals") << a << b << false << true;
330 a = new Domain();
350 a = new Domain();
331 a->setRange(0, 100, 0, 100);
351 a->setRange(0, 100, 0, 100);
332 b = new Domain();
352 b = new Domain();
333 b->setRange(0, 1, 0, 100);
353 b->setRange(0, 1, 0, 100);
334 QTest::newRow("equals") << a << b << false << true;
354 QTest::newRow("equals") << a << b << false << true;
335
355
336 }
356 }
337
357
338 void tst_Domain::operatorEquals()
358 void tst_Domain::operatorEquals()
339 {
359 {
340 QFETCH(Domain*, domain1);
360 QFETCH(Domain*, domain1);
341 QFETCH(Domain*, domain2);
361 QFETCH(Domain*, domain2);
342 QFETCH(bool, equals);
362 QFETCH(bool, equals);
343 QFETCH(bool, notEquals);
363 QFETCH(bool, notEquals);
344
364
345 Domain domain;
365 Domain domain;
346
366
347 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
367 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
348 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
368 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
349 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
369 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
350
370
351 QCOMPARE(*domain1==*domain2, equals);
371 QCOMPARE(*domain1==*domain2, equals);
352 QCOMPARE(*domain1!=*domain2, notEquals);
372 QCOMPARE(*domain1!=*domain2, notEquals);
353
373
354 QCOMPARE(spy0.count(), 0);
374 QCOMPARE(spy0.count(), 0);
355 QCOMPARE(spy1.count(), 0);
375 QCOMPARE(spy1.count(), 0);
356 QCOMPARE(spy2.count(), 0);
376 QCOMPARE(spy2.count(), 0);
357 }
377 }
358
378
359 void tst_Domain::setRange_data()
379 void tst_Domain::setRange_data()
360 {
380 {
361 QTest::addColumn<qreal>("minX");
381 QTest::addColumn<qreal>("minX");
362 QTest::addColumn<qreal>("maxX");
382 QTest::addColumn<qreal>("maxX");
363 QTest::addColumn<qreal>("minY");
383 QTest::addColumn<qreal>("minY");
364 QTest::addColumn<qreal>("maxY");
384 QTest::addColumn<qreal>("maxY");
365 QTest::newRow("1,2,1,2") << 1.0 << 2.0 << 1.0 << 2.0;
385 QTest::newRow("1,2,1,2") << 1.0 << 2.0 << 1.0 << 2.0;
366 QTest::newRow("1,3,1,3") << 1.0 << 3.0 << 1.0 << 3.0;
386 QTest::newRow("1,3,1,3") << 1.0 << 3.0 << 1.0 << 3.0;
367 QTest::newRow("-1,5,-2,-1") << -1.0 << 5.0 << -2.0 << -1.0;
387 QTest::newRow("-1,5,-2,-1") << -1.0 << 5.0 << -2.0 << -1.0;
368 }
388 }
369
389
370 void tst_Domain::setRange()
390 void tst_Domain::setRange()
371 {
391 {
372 QFETCH(qreal, minX);
392 QFETCH(qreal, minX);
373 QFETCH(qreal, maxX);
393 QFETCH(qreal, maxX);
374 QFETCH(qreal, minY);
394 QFETCH(qreal, minY);
375 QFETCH(qreal, maxY);
395 QFETCH(qreal, maxY);
376
396
377 Domain domain;
397 Domain domain;
378
398
379 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
399 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
380 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
400 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
381 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
401 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
382
402
383 domain.setRange(minX, maxX, minY, maxY);
403 domain.setRange(minX, maxX, minY, maxY);
384
404
385 QCOMPARE(domain.minX(), minX);
405 QCOMPARE(domain.minX(), minX);
386 QCOMPARE(domain.maxX(), maxX);
406 QCOMPARE(domain.maxX(), maxX);
387 QCOMPARE(domain.minY(), minY);
407 QCOMPARE(domain.minY(), minY);
388 QCOMPARE(domain.maxY(), maxY);
408 QCOMPARE(domain.maxY(), maxY);
389
409
390 QCOMPARE(spy0.count(), 1);
410 QCOMPARE(spy0.count(), 1);
391 QCOMPARE(spy1.count(), 1);
411 QCOMPARE(spy1.count(), 1);
392 QCOMPARE(spy2.count(), 1);
412 QCOMPARE(spy2.count(), 1);
393
413
394 }
414 }
395
415
396 void tst_Domain::setRangeX_data()
416 void tst_Domain::setRangeX_data()
397 {
417 {
398 QTest::addColumn<qreal>("min");
418 QTest::addColumn<qreal>("min");
399 QTest::addColumn<qreal>("max");
419 QTest::addColumn<qreal>("max");
400 QTest::newRow("-1 1") << -1.0 << 1.0;
420 QTest::newRow("-1 1") << -1.0 << 1.0;
401 QTest::newRow("0 1") << 0.0 << 1.0;
421 QTest::newRow("0 1") << 0.0 << 1.0;
402 QTest::newRow("-1 0") << -1.0 << 0.0;
422 QTest::newRow("-1 0") << -1.0 << 0.0;
403 }
423 }
404
424
405 void tst_Domain::setRangeX()
425 void tst_Domain::setRangeX()
406 {
426 {
407 QFETCH(qreal, min);
427 QFETCH(qreal, min);
408 QFETCH(qreal, max);
428 QFETCH(qreal, max);
409
429
410 Domain domain;
430 Domain domain;
411
431
412 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
432 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
413 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
433 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
414 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
434 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
415
435
416 domain.setRangeX(min, max);
436 domain.setRangeX(min, max);
417
437
418 QList<QVariant> arg0 = spy0.first();
438 QList<QVariant> arg0 = spy0.first();
419 QVERIFY(qFuzzyIsNull(arg0.at(0).toReal() - min));
439 QVERIFY(qFuzzyIsNull(arg0.at(0).toReal() - min));
420 QVERIFY(qFuzzyIsNull(arg0.at(1).toReal() - max));
440 QVERIFY(qFuzzyIsNull(arg0.at(1).toReal() - max));
421
441
422 QList<QVariant> arg1 = spy1.first();
442 QList<QVariant> arg1 = spy1.first();
423 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
443 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
424 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
444 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
425
445
426 QCOMPARE(spy0.count(), 1);
446 QCOMPARE(spy0.count(), 1);
427 QCOMPARE(spy1.count(), 1);
447 QCOMPARE(spy1.count(), 1);
428 QCOMPARE(spy2.count(), 0);
448 QCOMPARE(spy2.count(), 0);
429 }
449 }
430
450
431 void tst_Domain::setRangeY_data()
451 void tst_Domain::setRangeY_data()
432 {
452 {
433 QTest::addColumn<qreal>("min");
453 QTest::addColumn<qreal>("min");
434 QTest::addColumn<qreal>("max");
454 QTest::addColumn<qreal>("max");
435 QTest::newRow("-1 1") << -1.0 << 1.0;
455 QTest::newRow("-1 1") << -1.0 << 1.0;
436 QTest::newRow("0 1") << 0.0 << 1.0;
456 QTest::newRow("0 1") << 0.0 << 1.0;
437 QTest::newRow("-1 0") << -1.0 << 0.0;
457 QTest::newRow("-1 0") << -1.0 << 0.0;
438 }
458 }
439
459
440 void tst_Domain::setRangeY()
460 void tst_Domain::setRangeY()
441 {
461 {
442 QFETCH(qreal, min);
462 QFETCH(qreal, min);
443 QFETCH(qreal, max);
463 QFETCH(qreal, max);
444
464
445 Domain domain;
465 Domain domain;
446
466
447 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
467 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
448 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
468 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
449 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
469 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
450
470
451 domain.setRangeY(min, max);
471 domain.setRangeY(min, max);
452
472
453 QList<QVariant> arg0 = spy0.first();
473 QList<QVariant> arg0 = spy0.first();
454 QVERIFY(qFuzzyIsNull(arg0.at(2).toReal() - min));
474 QVERIFY(qFuzzyIsNull(arg0.at(2).toReal() - min));
455 QVERIFY(qFuzzyIsNull(arg0.at(3).toReal() - max));
475 QVERIFY(qFuzzyIsNull(arg0.at(3).toReal() - max));
456
476
457 QList<QVariant> arg1 = spy2.first();
477 QList<QVariant> arg1 = spy2.first();
458 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
478 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
459 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
479 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
460
480
461 QCOMPARE(spy0.count(), 1);
481 QCOMPARE(spy0.count(), 1);
462 QCOMPARE(spy1.count(), 0);
482 QCOMPARE(spy1.count(), 0);
463 QCOMPARE(spy2.count(), 1);
483 QCOMPARE(spy2.count(), 1);
464 }
484 }
465
485
466 void tst_Domain::spanX_data()
486 void tst_Domain::spanX_data()
467 {
487 {
468 QTest::addColumn<qreal>("minX");
488 QTest::addColumn<qreal>("minX");
469 QTest::addColumn<qreal>("maxX");
489 QTest::addColumn<qreal>("maxX");
470 QTest::addColumn<qreal>("spanX");
490 QTest::addColumn<qreal>("spanX");
471 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
491 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
472 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
492 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
473 }
493 }
474
494
475 void tst_Domain::spanX()
495 void tst_Domain::spanX()
476 {
496 {
477 QFETCH(qreal, minX);
497 QFETCH(qreal, minX);
478 QFETCH(qreal, maxX);
498 QFETCH(qreal, maxX);
479 QFETCH(qreal, spanX);
499 QFETCH(qreal, spanX);
480
500
481 Domain domain;
501 Domain domain;
482
502
483 domain.setRangeX(minX, maxX);
503 domain.setRangeX(minX, maxX);
484
504
485 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
505 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
486 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
506 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
487 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
507 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
488
508
489 QCOMPARE(domain.spanX(), spanX);
509 QCOMPARE(domain.spanX(), spanX);
490
510
491 QCOMPARE(spy0.count(), 0);
511 QCOMPARE(spy0.count(), 0);
492 QCOMPARE(spy1.count(), 0);
512 QCOMPARE(spy1.count(), 0);
493 QCOMPARE(spy2.count(), 0);
513 QCOMPARE(spy2.count(), 0);
494 }
514 }
495
515
496 void tst_Domain::spanY_data()
516 void tst_Domain::spanY_data()
497 {
517 {
498 QTest::addColumn<qreal>("minY");
518 QTest::addColumn<qreal>("minY");
499 QTest::addColumn<qreal>("maxY");
519 QTest::addColumn<qreal>("maxY");
500 QTest::addColumn<qreal>("spanY");
520 QTest::addColumn<qreal>("spanY");
501 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
521 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
502 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
522 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
503 }
523 }
504
524
505 void tst_Domain::spanY()
525 void tst_Domain::spanY()
506 {
526 {
507 QFETCH(qreal, minY);
527 QFETCH(qreal, minY);
508 QFETCH(qreal, maxY);
528 QFETCH(qreal, maxY);
509 QFETCH(qreal, spanY);
529 QFETCH(qreal, spanY);
510
530
511 Domain domain;
531 Domain domain;
512
532
513 domain.setRangeY(minY, maxY);
533 domain.setRangeY(minY, maxY);
514
534
515 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
535 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
516 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
536 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
517 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
537 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
518
538
519 QCOMPARE(domain.spanY(), spanY);
539 QCOMPARE(domain.spanY(), spanY);
520
540
521 QCOMPARE(spy0.count(), 0);
541 QCOMPARE(spy0.count(), 0);
522 QCOMPARE(spy1.count(), 0);
542 QCOMPARE(spy1.count(), 0);
523 QCOMPARE(spy2.count(), 0);
543 QCOMPARE(spy2.count(), 0);
524 }
544 }
525
545
526 void tst_Domain::zoom_data()
546 void tst_Domain::zoom_data()
527 {
547 {
528 QTest::addColumn<QRectF>("rect0");
548 QTest::addColumn<QRectF>("rect0");
529 QTest::addColumn<QSizeF>("size0");
549 QTest::addColumn<QSizeF>("size0");
530 QTest::addColumn<QRectF>("rect1");
550 QTest::addColumn<QRectF>("rect1");
531 QTest::addColumn<QSizeF>("size1");
551 QTest::addColumn<QSizeF>("size1");
532 QTest::addColumn<QRectF>("rect2");
552 QTest::addColumn<QRectF>("rect2");
533 QTest::addColumn<QSizeF>("size2");
553 QTest::addColumn<QSizeF>("size2");
534 QTest::newRow("first") << QRectF(10, 10, 100, 100) << QSizeF(1000, 1000)
554 QTest::newRow("first") << QRectF(10, 10, 100, 100) << QSizeF(1000, 1000)
535 << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
555 << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
536 << QSizeF(1000, 1000);
556 << QSizeF(1000, 1000);
537 QTest::newRow("scound") << QRectF(10, 10, 50, 50) << QSizeF(1000, 1000)
557 QTest::newRow("scound") << QRectF(10, 10, 50, 50) << QSizeF(1000, 1000)
538 << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
558 << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
539 << QSizeF(1000, 1000);
559 << QSizeF(1000, 1000);
540 QTest::newRow("third") << QRectF(10, 10, 10, 10) << QSizeF(100, 100) << QRectF(20, 20, 20, 20)
560 QTest::newRow("third") << QRectF(10, 10, 10, 10) << QSizeF(100, 100) << QRectF(20, 20, 20, 20)
541 << QSizeF(100, 100) << QRectF(50, 50, 50, 50) << QSizeF(100, 100);
561 << QSizeF(100, 100) << QRectF(50, 50, 50, 50) << QSizeF(100, 100);
542 }
562 }
543
563
544 void tst_Domain::zoom()
564 void tst_Domain::zoom()
545 {
565 {
546 QFETCH(QRectF, rect0);
566 QFETCH(QRectF, rect0);
547 QFETCH(QSizeF, size0);
567 QFETCH(QSizeF, size0);
548 QFETCH(QRectF, rect1);
568 QFETCH(QRectF, rect1);
549 QFETCH(QSizeF, size1);
569 QFETCH(QSizeF, size1);
550 QFETCH(QRectF, rect2);
570 QFETCH(QRectF, rect2);
551 QFETCH(QSizeF, size2);
571 QFETCH(QSizeF, size2);
552
572
553 Domain domain;
573 Domain domain;
554
574
555 domain.setRange(0, 1000, 0, 1000);
575 domain.setRange(0, 1000, 0, 1000);
556
576
557 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
577 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
558 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
578 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
559 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
579 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
560
580
561 Domain domain0;
581 Domain domain0;
562 domain0.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
582 domain0.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
563 domain.zoomIn(rect0, size0);
583 domain.zoomIn(rect0, size0);
564 Domain domain1;
584 Domain domain1;
565 domain1.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
585 domain1.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
566 domain.zoomIn(rect1, size1);
586 domain.zoomIn(rect1, size1);
567 Domain domain2;
587 Domain domain2;
568 domain2.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
588 domain2.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
569 domain.zoomIn(rect2, size2);
589 domain.zoomIn(rect2, size2);
570 domain.zoomOut(rect2, size2);
590 domain.zoomOut(rect2, size2);
571 QCOMPARE(domain == domain2, true);
591 QCOMPARE(domain == domain2, true);
572 domain.zoomOut(rect1, size1);
592 domain.zoomOut(rect1, size1);
573 QCOMPARE(domain == domain1, true);
593 QCOMPARE(domain == domain1, true);
574 domain.zoomOut(rect0, size0);
594 domain.zoomOut(rect0, size0);
575 QCOMPARE(domain == domain0, true);
595 QCOMPARE(domain == domain0, true);
576 QCOMPARE(spy0.count(), 6);
596 QCOMPARE(spy0.count(), 6);
577 QCOMPARE(spy1.count(), 6);
597 QCOMPARE(spy1.count(), 6);
578 QCOMPARE(spy2.count(), 6);
598 QCOMPARE(spy2.count(), 6);
579
599
580 }
600 }
581
601
582 void tst_Domain::move_data()
602 void tst_Domain::move_data()
583 {
603 {
584 QTest::addColumn<int>("dx");
604 QTest::addColumn<int>("dx");
585 QTest::addColumn<int>("dy");
605 QTest::addColumn<int>("dy");
586 QTest::addColumn<QSizeF>("size");
606 QTest::addColumn<QSizeF>("size");
587 QTest::newRow("dx 100, dy 0, size 1000x1000") << 100 << 0 << QSizeF(1000, 1000);
607 QTest::newRow("dx 100, dy 0, size 1000x1000") << 100 << 0 << QSizeF(1000, 1000);
588 QTest::newRow("dx 0, dy 100, size 1000x1000") << 0 << 100 << QSizeF(1000, 1000);
608 QTest::newRow("dx 0, dy 100, size 1000x1000") << 0 << 100 << QSizeF(1000, 1000);
589 QTest::newRow("dx -100, dy 0, size 1000x1000") << -100 << 0 << QSizeF(1000, 1000);
609 QTest::newRow("dx -100, dy 0, size 1000x1000") << -100 << 0 << QSizeF(1000, 1000);
590 QTest::newRow("dx 0, dy -100, size 1000x1000") << 0 << -100 << QSizeF(1000, 1000);
610 QTest::newRow("dx 0, dy -100, size 1000x1000") << 0 << -100 << QSizeF(1000, 1000);
591 QTest::newRow("dx 100, dy 100, size 1000x1000") << 100 << 100 << QSizeF(1000, 1000);
611 QTest::newRow("dx 100, dy 100, size 1000x1000") << 100 << 100 << QSizeF(1000, 1000);
592 QTest::newRow("dx 100, dy 50, size 1000x1000") << 100 << 50 << QSizeF(1000, 1000);
612 QTest::newRow("dx 100, dy 50, size 1000x1000") << 100 << 50 << QSizeF(1000, 1000);
593 }
613 }
594
614
595 void tst_Domain::move()
615 void tst_Domain::move()
596 {
616 {
597 QFETCH(int, dx);
617 QFETCH(int, dx);
598 QFETCH(int, dy);
618 QFETCH(int, dy);
599 QFETCH(QSizeF, size);
619 QFETCH(QSizeF, size);
600 Domain domain;
620 Domain domain;
601
621
602 domain.setRange(0, size.width(), 0, size.height());
622 domain.setRange(0, size.width(), 0, size.height());
603
623
604 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
624 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
605 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
625 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
606 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
626 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
607
627
608 domain.move(dx, dy, size);
628 domain.move(dx, dy, size);
609
629
610 Domain result;
630 Domain result;
611 result.setRange(dx, size.width() + dx, dy, size.height() + dy);
631 result.setRange(dx, size.width() + dx, dy, size.height() + dy);
612
632
613 QCOMPARE(domain == result, true);
633 QCOMPARE(domain == result, true);
614 QCOMPARE(spy0.count(), 1);
634 QCOMPARE(spy0.count(), 1);
615 QCOMPARE(spy1.count(), dx!=0?1:0);
635 QCOMPARE(spy1.count(), dx!=0?1:0);
616 QCOMPARE(spy2.count(), dy!=0?1:0);
636 QCOMPARE(spy2.count(), dy!=0?1:0);
617 }
637 }
618
638
619 void tst_Domain::handleAxisXChanged_data()
639 void tst_Domain::handleAxisXChanged_data()
620 {
640 {
621 QTest::addColumn<qreal>("min");
641 QTest::addColumn<qreal>("min");
622 QTest::addColumn<qreal>("max");
642 QTest::addColumn<qreal>("max");
623 QTest::addColumn<int>("tickCount");
643 QTest::addColumn<int>("tickCount");
624 QTest::addColumn<bool>("niceNumbers");
644 QTest::addColumn<bool>("niceNumbers");
625 QTest::addColumn<qreal>("resultMin");
645 QTest::addColumn<qreal>("resultMin");
626 QTest::addColumn<qreal>("resultMax");
646 QTest::addColumn<qreal>("resultMax");
627 QTest::addColumn<int>("resultTickCount");
647 QTest::addColumn<int>("resultTickCount");
628 QTest::newRow("0,100,5,false") << 0.0 << 100.0 << 5 << false << 0.0 << 100.0 << 5;
648 QTest::newRow("0,100,5,false") << 0.0 << 100.0 << 5 << false << 0.0 << 100.0 << 5;
629 QTest::newRow("0,100,5,true") << 0.0 << 100.0 << 5 << true << 0.0 << 100.0 << 6;
649 QTest::newRow("0,100,5,true") << 0.0 << 100.0 << 5 << true << 0.0 << 100.0 << 6;
630 QTest::newRow("0.1,99,5,true") << 0.1 << 99.0 << 5 << true << 0.0 << 100.0 << 6;
650 QTest::newRow("0.1,99,5,true") << 0.1 << 99.0 << 5 << true << 0.0 << 100.0 << 6;
631 QTest::newRow("5,93.5,true") << 5.0 << 93.5 << 5 << true << 0.0 << 100.0 << 6;
651 QTest::newRow("5,93.5,true") << 5.0 << 93.5 << 5 << true << 0.0 << 100.0 << 6;
632 }
652 }
633
653
634 void tst_Domain::handleAxisXChanged()
654 void tst_Domain::handleAxisXChanged()
635 {
655 {
636 QFETCH(qreal, min);
656 QFETCH(qreal, min);
637 QFETCH(qreal, max);
657 QFETCH(qreal, max);
638 QFETCH(int, tickCount);
658 QFETCH(int, tickCount);
639 QFETCH(bool, niceNumbers);
659 QFETCH(bool, niceNumbers);
640 QFETCH(qreal, resultMin);
660 QFETCH(qreal, resultMin);
641 QFETCH(qreal, resultMax);
661 QFETCH(qreal, resultMax);
642 QFETCH(int, resultTickCount);
662 QFETCH(int, resultTickCount);
643
663
644 Domain domain;
664 Domain domain;
645 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
665 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
646 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
666 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
647 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
667 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
648
668
649 domain.handleAxisXChanged(min, max, tickCount, niceNumbers);
669 domain.handleAxisXChanged(min, max, tickCount, niceNumbers);
650
670
651 QCOMPARE(resultMin, domain.minX());
671 QCOMPARE(resultMin, domain.minX());
652 QCOMPARE(resultMax, domain.maxX());
672 QCOMPARE(resultMax, domain.maxX());
653 QCOMPARE(resultTickCount, domain.tickXCount());
673 QCOMPARE(resultTickCount, domain.tickXCount());
654 QCOMPARE(spy0.count(), 1);
674 QCOMPARE(spy0.count(), 1);
655 QCOMPARE(spy1.count(), 1);
675 QCOMPARE(spy1.count(), 1);
656 QCOMPARE(spy2.count(), 0);
676 QCOMPARE(spy2.count(), 0);
657
677
658 }
678 }
659
679
660 void tst_Domain::handleAxisYChanged_data()
680 void tst_Domain::handleAxisYChanged_data()
661 {
681 {
662 handleAxisXChanged_data();
682 handleAxisXChanged_data();
663 }
683 }
664
684
665 void tst_Domain::handleAxisYChanged()
685 void tst_Domain::handleAxisYChanged()
666 {
686 {
667 QFETCH(qreal, min);
687 QFETCH(qreal, min);
668 QFETCH(qreal, max);
688 QFETCH(qreal, max);
669 QFETCH(int, tickCount);
689 QFETCH(int, tickCount);
670 QFETCH(bool, niceNumbers);
690 QFETCH(bool, niceNumbers);
671 QFETCH(qreal, resultMin);
691 QFETCH(qreal, resultMin);
672 QFETCH(qreal, resultMax);
692 QFETCH(qreal, resultMax);
673 QFETCH(int, resultTickCount);
693 QFETCH(int, resultTickCount);
674
694
675 Domain domain;
695 Domain domain;
676 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
696 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal, qreal, qreal, qreal)));
677 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
697 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal, qreal,int )));
678 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
698 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal, qreal,int )));
679
699
680 domain.handleAxisYChanged(min, max, tickCount, niceNumbers);
700 domain.handleAxisYChanged(min, max, tickCount, niceNumbers);
681
701
682 QCOMPARE(resultMin, domain.minY());
702 QCOMPARE(resultMin, domain.minY());
683 QCOMPARE(resultMax, domain.maxY());
703 QCOMPARE(resultMax, domain.maxY());
684 QCOMPARE(resultTickCount, domain.tickYCount());
704 QCOMPARE(resultTickCount, domain.tickYCount());
685 QCOMPARE(spy0.count(), 1);
705 QCOMPARE(spy0.count(), 1);
686 QCOMPARE(spy1.count(), 0);
706 QCOMPARE(spy1.count(), 0);
687 QCOMPARE(spy2.count(), 1);
707 QCOMPARE(spy2.count(), 1);
688 }
708 }
689
709
690 QTEST_MAIN(tst_Domain)
710 QTEST_MAIN(tst_Domain)
691 #include "tst_domain.moc"
711 #include "tst_domain.moc"
692
712
General Comments 0
You need to be logged in to leave comments. Login now