|
|
/****************************************************************************
|
|
|
**
|
|
|
** Copyright (C) 2012 Digia Plc
|
|
|
** All rights reserved.
|
|
|
** For any questions to Digia, please use contact form at http://qt.digia.com
|
|
|
**
|
|
|
** This file is part of the Qt Commercial Charts Add-on.
|
|
|
**
|
|
|
** $QT_BEGIN_LICENSE$
|
|
|
** Licensees holding valid Qt Commercial licenses may use this file in
|
|
|
** accordance with the Qt Commercial License Agreement provided with the
|
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
|
** a written agreement between you and Digia.
|
|
|
**
|
|
|
** If you have questions regarding the use of this file, please use
|
|
|
** contact form at http://qt.digia.com
|
|
|
** $QT_END_LICENSE$
|
|
|
**
|
|
|
****************************************************************************/
|
|
|
#ifndef BUILD_PRIVATE_UNIT_TESTS
|
|
|
|
|
|
#include <QtTest/QtTest>
|
|
|
|
|
|
class tst_Domain: public QObject {
|
|
|
|
|
|
Q_OBJECT
|
|
|
|
|
|
private Q_SLOTS:
|
|
|
void skip();
|
|
|
|
|
|
};
|
|
|
|
|
|
void tst_Domain::skip()
|
|
|
{
|
|
|
#ifdef QT5_QUICK_1
|
|
|
QSKIP("This test requires the debug version of library");
|
|
|
#else
|
|
|
QSKIP("This test requires the debug version of library", SkipAll);
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
QTEST_MAIN(tst_Domain)
|
|
|
#include "tst_domain.moc"
|
|
|
|
|
|
#else
|
|
|
|
|
|
#include <QtTest/QtTest>
|
|
|
#include <private/domain_p.h>
|
|
|
#include <private/qabstractaxis_p.h>
|
|
|
#include <tst_definitions.h>
|
|
|
|
|
|
QTCOMMERCIALCHART_USE_NAMESPACE
|
|
|
|
|
|
Q_DECLARE_METATYPE(Domain*)
|
|
|
Q_DECLARE_METATYPE(QSizeF)
|
|
|
|
|
|
|
|
|
class AxisMock: public QAbstractAxisPrivate
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
public:
|
|
|
AxisMock(Qt::Orientation orientation):QAbstractAxisPrivate(0){ setOrientation(orientation);};
|
|
|
ChartAxis* createGraphics(ChartPresenter* presenter)
|
|
|
{
|
|
|
Q_UNUSED(presenter);
|
|
|
return 0;
|
|
|
};
|
|
|
void intializeDomain(Domain* domain)
|
|
|
{
|
|
|
Q_UNUSED(domain);
|
|
|
};
|
|
|
void setMin(const QVariant &min)
|
|
|
{
|
|
|
Q_UNUSED(min);
|
|
|
}
|
|
|
qreal min() { return m_min;}
|
|
|
void setMax(const QVariant &max)
|
|
|
{
|
|
|
Q_UNUSED(max);
|
|
|
}
|
|
|
qreal max() { return m_max; }
|
|
|
void setRange(const QVariant &min, const QVariant &max)
|
|
|
{
|
|
|
Q_UNUSED(min);
|
|
|
Q_UNUSED(max);
|
|
|
};
|
|
|
|
|
|
int count () const { return m_count; }
|
|
|
|
|
|
void handleDomainUpdated(){};
|
|
|
public:
|
|
|
int m_count;
|
|
|
qreal m_min;
|
|
|
qreal m_max;
|
|
|
};
|
|
|
|
|
|
class tst_Domain: public QObject
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
|
|
|
public Q_SLOTS:
|
|
|
void initTestCase();
|
|
|
void cleanupTestCase();
|
|
|
void init();
|
|
|
void cleanup();
|
|
|
|
|
|
private Q_SLOTS:
|
|
|
void domain();
|
|
|
void handleAxisUpdatedX_data();
|
|
|
void handleAxisUpdatedX();
|
|
|
void handleAxisUpdatedY_data();
|
|
|
void handleAxisUpdatedY();
|
|
|
void isEmpty_data();
|
|
|
void isEmpty();
|
|
|
void maxX_data();
|
|
|
void maxX();
|
|
|
void maxY_data();
|
|
|
void maxY();
|
|
|
void minX_data();
|
|
|
void minX();
|
|
|
void minY_data();
|
|
|
void minY();
|
|
|
void operatorEquals_data();
|
|
|
void operatorEquals();
|
|
|
void setRange_data();
|
|
|
void setRange();
|
|
|
void setRangeX_data();
|
|
|
void setRangeX();
|
|
|
void setRangeY_data();
|
|
|
void setRangeY();
|
|
|
void spanX_data();
|
|
|
void spanX();
|
|
|
void spanY_data();
|
|
|
void spanY();
|
|
|
void zoom_data();
|
|
|
void zoom();
|
|
|
void move_data();
|
|
|
void move();
|
|
|
};
|
|
|
|
|
|
void tst_Domain::initTestCase()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void tst_Domain::cleanupTestCase()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void tst_Domain::init()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void tst_Domain::cleanup()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void tst_Domain::domain()
|
|
|
{
|
|
|
Domain domain;
|
|
|
|
|
|
QCOMPARE(domain.isEmpty(), true);
|
|
|
QCOMPARE(domain.maxX(), 0.0);
|
|
|
QCOMPARE(domain.maxY(), 0.0);
|
|
|
QCOMPARE(domain.minX(), 0.0);
|
|
|
QCOMPARE(domain.minY(), 0.0);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::handleAxisUpdatedX_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("min");
|
|
|
QTest::addColumn<qreal>("max");
|
|
|
QTest::newRow("-1 1") << -1.0 << 1.0;
|
|
|
QTest::newRow("0 1") << 0.0 << 1.0;
|
|
|
QTest::newRow("-1 0") << -1.0 << 0.0;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::handleAxisUpdatedX()
|
|
|
{
|
|
|
QFETCH(qreal, min);
|
|
|
QFETCH(qreal, max);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
AxisMock axis(Qt::Horizontal);
|
|
|
QObject::connect(&axis,SIGNAL(updated()),&domain,SLOT(handleAxisUpdated()));
|
|
|
axis.m_min=min;
|
|
|
axis.m_max=max;
|
|
|
axis.emitUpdated();
|
|
|
|
|
|
QVERIFY(qFuzzyIsNull(domain.minX() - min));
|
|
|
QVERIFY(qFuzzyIsNull(domain.maxX() - max));
|
|
|
|
|
|
QList<QVariant> arg1 = spy1.first();
|
|
|
QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
|
|
|
QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), 1);
|
|
|
TRY_COMPARE(spy1.count(), 1);
|
|
|
TRY_COMPARE(spy2.count(), 0);
|
|
|
|
|
|
}
|
|
|
|
|
|
void tst_Domain::handleAxisUpdatedY_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("min");
|
|
|
QTest::addColumn<qreal>("max");
|
|
|
QTest::newRow("-1 1") << -1.0 << 1.0;
|
|
|
QTest::newRow("0 1") << 0.0 << 1.0;
|
|
|
QTest::newRow("-1 0") << -1.0 << 0.0;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::handleAxisUpdatedY()
|
|
|
{
|
|
|
QFETCH(qreal, min);
|
|
|
QFETCH(qreal, max);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
AxisMock axis(Qt::Vertical);
|
|
|
QObject::connect(&axis, SIGNAL(updated()), &domain, SLOT(handleAxisUpdated()));
|
|
|
axis.m_min = min;
|
|
|
axis.m_max = max;
|
|
|
axis.emitUpdated();
|
|
|
|
|
|
QVERIFY(qFuzzyIsNull(domain.minY() - min));
|
|
|
QVERIFY(qFuzzyIsNull(domain.maxY() - max));
|
|
|
|
|
|
QList<QVariant> arg1 = spy2.first();
|
|
|
QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
|
|
|
QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), 1);
|
|
|
TRY_COMPARE(spy1.count(), 0);
|
|
|
TRY_COMPARE(spy2.count(), 1);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::isEmpty_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("minX");
|
|
|
QTest::addColumn<qreal>("maxX");
|
|
|
QTest::addColumn<qreal>("minY");
|
|
|
QTest::addColumn<qreal>("maxY");
|
|
|
QTest::addColumn<bool>("isEmpty");
|
|
|
QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << true;
|
|
|
QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << true;
|
|
|
QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << true;
|
|
|
QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << false;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::isEmpty()
|
|
|
{
|
|
|
QFETCH(qreal, minX);
|
|
|
QFETCH(qreal, maxX);
|
|
|
QFETCH(qreal, minY);
|
|
|
QFETCH(qreal, maxY);
|
|
|
QFETCH(bool, isEmpty);
|
|
|
|
|
|
Domain domain;
|
|
|
domain.setRange(minX, maxX, minY, maxY);
|
|
|
QCOMPARE(domain.isEmpty(), isEmpty);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::maxX_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("maxX1");
|
|
|
QTest::addColumn<qreal>("maxX2");
|
|
|
QTest::addColumn<int>("count");
|
|
|
QTest::newRow("1") << 0.0 << 1.0 << 1;
|
|
|
QTest::newRow("1.0") << 1.0 << 1.0 << 1;
|
|
|
QTest::newRow("2.0") << 1.0 << 0.0 << 2;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::maxX()
|
|
|
{
|
|
|
QFETCH(qreal, maxX1);
|
|
|
QFETCH(qreal, maxX2);
|
|
|
QFETCH(int, count);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
domain.setMaxX(maxX1);
|
|
|
QCOMPARE(domain.maxX(), maxX1);
|
|
|
domain.setMaxX(maxX2);
|
|
|
QCOMPARE(domain.maxX(), maxX2);
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), count);
|
|
|
TRY_COMPARE(spy1.count(), count);
|
|
|
TRY_COMPARE(spy2.count(), 0);
|
|
|
|
|
|
}
|
|
|
|
|
|
void tst_Domain::maxY_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("maxY1");
|
|
|
QTest::addColumn<qreal>("maxY2");
|
|
|
QTest::addColumn<int>("count");
|
|
|
QTest::newRow("1") << 0.0 << 1.0 << 1;
|
|
|
QTest::newRow("1.0") << 1.0 << 1.0 << 1;
|
|
|
QTest::newRow("2.0") << 1.0 << 0.0 << 2;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::maxY()
|
|
|
{
|
|
|
QFETCH(qreal, maxY1);
|
|
|
QFETCH(qreal, maxY2);
|
|
|
QFETCH(int, count);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
domain.setMaxY(maxY1);
|
|
|
QCOMPARE(domain.maxY(), maxY1);
|
|
|
domain.setMaxY(maxY2);
|
|
|
QCOMPARE(domain.maxY(), maxY2);
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), count);
|
|
|
TRY_COMPARE(spy1.count(), 0);
|
|
|
TRY_COMPARE(spy2.count(), count);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::minX_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("minX1");
|
|
|
QTest::addColumn<qreal>("minX2");
|
|
|
QTest::addColumn<int>("count");
|
|
|
QTest::newRow("1") << 0.0 << 1.0 << 1;
|
|
|
QTest::newRow("1.0") << 1.0 << 1.0 << 1;
|
|
|
QTest::newRow("2.0") << 1.0 << 0.0 << 2;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::minX()
|
|
|
{
|
|
|
QFETCH(qreal, minX1);
|
|
|
QFETCH(qreal, minX2);
|
|
|
QFETCH(int, count);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
domain.setMinX(minX1);
|
|
|
QCOMPARE(domain.minX(), minX1);
|
|
|
domain.setMinX(minX2);
|
|
|
QCOMPARE(domain.minX(), minX2);
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), count);
|
|
|
TRY_COMPARE(spy1.count(), count);
|
|
|
TRY_COMPARE(spy2.count(), 0);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::minY_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("minY1");
|
|
|
QTest::addColumn<qreal>("minY2");
|
|
|
QTest::addColumn<int>("count");
|
|
|
QTest::newRow("1") << 0.0 << 1.0 << 1;
|
|
|
QTest::newRow("1.0") << 1.0 << 1.0 << 1;
|
|
|
QTest::newRow("2.0") << 1.0 << 0.0 << 2;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::minY()
|
|
|
{
|
|
|
QFETCH(qreal, minY1);
|
|
|
QFETCH(qreal, minY2);
|
|
|
QFETCH(int, count);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
domain.setMinY(minY1);
|
|
|
QCOMPARE(domain.minY(), minY1);
|
|
|
domain.setMinY(minY2);
|
|
|
QCOMPARE(domain.minY(), minY2);
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), count);
|
|
|
TRY_COMPARE(spy1.count(), 0);
|
|
|
TRY_COMPARE(spy2.count(), count);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::operatorEquals_data()
|
|
|
{
|
|
|
|
|
|
QTest::addColumn<Domain*>("domain1");
|
|
|
QTest::addColumn<Domain*>("domain2");
|
|
|
QTest::addColumn<bool>("equals");
|
|
|
QTest::addColumn<bool>("notEquals");
|
|
|
Domain* a;
|
|
|
Domain* b;
|
|
|
a = new Domain();
|
|
|
a->setRange(0, 100, 0, 100);
|
|
|
b = new Domain();
|
|
|
b->setRange(0, 100, 0, 100);
|
|
|
QTest::newRow("equals") << a << b << true << false;
|
|
|
a = new Domain();
|
|
|
a->setRange(0, 100, 0, 100);
|
|
|
b = new Domain();
|
|
|
b->setRange(0, 100, 0, 1);
|
|
|
QTest::newRow("equals") << a << b << false << true;
|
|
|
a = new Domain();
|
|
|
a->setRange(0, 100, 0, 100);
|
|
|
b = new Domain();
|
|
|
b->setRange(0, 1, 0, 100);
|
|
|
QTest::newRow("equals") << a << b << false << true;
|
|
|
|
|
|
}
|
|
|
|
|
|
void tst_Domain::operatorEquals()
|
|
|
{
|
|
|
QFETCH(Domain*, domain1);
|
|
|
QFETCH(Domain*, domain2);
|
|
|
QFETCH(bool, equals);
|
|
|
QFETCH(bool, notEquals);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
QCOMPARE(*domain1==*domain2, equals);
|
|
|
QCOMPARE(*domain1!=*domain2, notEquals);
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), 0);
|
|
|
TRY_COMPARE(spy1.count(), 0);
|
|
|
TRY_COMPARE(spy2.count(), 0);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::setRange_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("minX");
|
|
|
QTest::addColumn<qreal>("maxX");
|
|
|
QTest::addColumn<qreal>("minY");
|
|
|
QTest::addColumn<qreal>("maxY");
|
|
|
QTest::newRow("1,2,1,2") << 1.0 << 2.0 << 1.0 << 2.0;
|
|
|
QTest::newRow("1,3,1,3") << 1.0 << 3.0 << 1.0 << 3.0;
|
|
|
QTest::newRow("-1,5,-2,-1") << -1.0 << 5.0 << -2.0 << -1.0;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::setRange()
|
|
|
{
|
|
|
QFETCH(qreal, minX);
|
|
|
QFETCH(qreal, maxX);
|
|
|
QFETCH(qreal, minY);
|
|
|
QFETCH(qreal, maxY);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
domain.setRange(minX, maxX, minY, maxY);
|
|
|
|
|
|
QCOMPARE(domain.minX(), minX);
|
|
|
QCOMPARE(domain.maxX(), maxX);
|
|
|
QCOMPARE(domain.minY(), minY);
|
|
|
QCOMPARE(domain.maxY(), maxY);
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), 1);
|
|
|
TRY_COMPARE(spy1.count(), 1);
|
|
|
TRY_COMPARE(spy2.count(), 1);
|
|
|
|
|
|
}
|
|
|
|
|
|
void tst_Domain::setRangeX_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("min");
|
|
|
QTest::addColumn<qreal>("max");
|
|
|
QTest::newRow("-1 1") << -1.0 << 1.0;
|
|
|
QTest::newRow("0 1") << 0.0 << 1.0;
|
|
|
QTest::newRow("-1 0") << -1.0 << 0.0;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::setRangeX()
|
|
|
{
|
|
|
QFETCH(qreal, min);
|
|
|
QFETCH(qreal, max);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
domain.setRangeX(min, max);
|
|
|
|
|
|
QVERIFY(qFuzzyIsNull(domain.minX() - min));
|
|
|
QVERIFY(qFuzzyIsNull(domain.maxX() - max));
|
|
|
|
|
|
QList<QVariant> arg1 = spy1.first();
|
|
|
QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
|
|
|
QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), 1);
|
|
|
TRY_COMPARE(spy1.count(), 1);
|
|
|
TRY_COMPARE(spy2.count(), 0);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::setRangeY_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("min");
|
|
|
QTest::addColumn<qreal>("max");
|
|
|
QTest::newRow("-1 1") << -1.0 << 1.0;
|
|
|
QTest::newRow("0 1") << 0.0 << 1.0;
|
|
|
QTest::newRow("-1 0") << -1.0 << 0.0;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::setRangeY()
|
|
|
{
|
|
|
QFETCH(qreal, min);
|
|
|
QFETCH(qreal, max);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
domain.setRangeY(min, max);
|
|
|
|
|
|
QVERIFY(qFuzzyIsNull(domain.minY() - min));
|
|
|
QVERIFY(qFuzzyIsNull(domain.maxY() - max));
|
|
|
|
|
|
QList<QVariant> arg1 = spy2.first();
|
|
|
QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
|
|
|
QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), 1);
|
|
|
TRY_COMPARE(spy1.count(), 0);
|
|
|
TRY_COMPARE(spy2.count(), 1);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::spanX_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("minX");
|
|
|
QTest::addColumn<qreal>("maxX");
|
|
|
QTest::addColumn<qreal>("spanX");
|
|
|
QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
|
|
|
QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::spanX()
|
|
|
{
|
|
|
QFETCH(qreal, minX);
|
|
|
QFETCH(qreal, maxX);
|
|
|
QFETCH(qreal, spanX);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
domain.setRangeX(minX, maxX);
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
QCOMPARE(domain.spanX(), spanX);
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), 0);
|
|
|
TRY_COMPARE(spy1.count(), 0);
|
|
|
TRY_COMPARE(spy2.count(), 0);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::spanY_data()
|
|
|
{
|
|
|
QTest::addColumn<qreal>("minY");
|
|
|
QTest::addColumn<qreal>("maxY");
|
|
|
QTest::addColumn<qreal>("spanY");
|
|
|
QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
|
|
|
QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
|
|
|
}
|
|
|
|
|
|
void tst_Domain::spanY()
|
|
|
{
|
|
|
QFETCH(qreal, minY);
|
|
|
QFETCH(qreal, maxY);
|
|
|
QFETCH(qreal, spanY);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
domain.setRangeY(minY, maxY);
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
QCOMPARE(domain.spanY(), spanY);
|
|
|
|
|
|
TRY_COMPARE(spy0.count(), 0);
|
|
|
TRY_COMPARE(spy1.count(), 0);
|
|
|
TRY_COMPARE(spy2.count(), 0);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::zoom_data()
|
|
|
{
|
|
|
QTest::addColumn<QRectF>("rect0");
|
|
|
QTest::addColumn<QSizeF>("size0");
|
|
|
QTest::addColumn<QRectF>("rect1");
|
|
|
QTest::addColumn<QSizeF>("size1");
|
|
|
QTest::addColumn<QRectF>("rect2");
|
|
|
QTest::addColumn<QSizeF>("size2");
|
|
|
QTest::newRow("first") << QRectF(10, 10, 100, 100) << QSizeF(1000, 1000)
|
|
|
<< QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
|
|
|
<< QSizeF(1000, 1000);
|
|
|
QTest::newRow("scound") << QRectF(10, 10, 50, 50) << QSizeF(1000, 1000)
|
|
|
<< QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
|
|
|
<< QSizeF(1000, 1000);
|
|
|
QTest::newRow("third") << QRectF(10, 10, 10, 10) << QSizeF(100, 100) << QRectF(20, 20, 20, 20)
|
|
|
<< QSizeF(100, 100) << QRectF(50, 50, 50, 50) << QSizeF(100, 100);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::zoom()
|
|
|
{
|
|
|
QFETCH(QRectF, rect0);
|
|
|
QFETCH(QSizeF, size0);
|
|
|
QFETCH(QRectF, rect1);
|
|
|
QFETCH(QSizeF, size1);
|
|
|
QFETCH(QRectF, rect2);
|
|
|
QFETCH(QSizeF, size2);
|
|
|
|
|
|
Domain domain;
|
|
|
|
|
|
domain.setRange(0, 1000, 0, 1000);
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
Domain domain0;
|
|
|
domain0.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
|
|
|
domain.zoomIn(rect0, size0);
|
|
|
Domain domain1;
|
|
|
domain1.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
|
|
|
domain.zoomIn(rect1, size1);
|
|
|
Domain domain2;
|
|
|
domain2.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
|
|
|
domain.zoomIn(rect2, size2);
|
|
|
domain.zoomOut(rect2, size2);
|
|
|
QCOMPARE(domain == domain2, true);
|
|
|
domain.zoomOut(rect1, size1);
|
|
|
QCOMPARE(domain == domain1, true);
|
|
|
domain.zoomOut(rect0, size0);
|
|
|
QCOMPARE(domain == domain0, true);
|
|
|
TRY_COMPARE(spy0.count(), 6);
|
|
|
TRY_COMPARE(spy1.count(), 6);
|
|
|
TRY_COMPARE(spy2.count(), 6);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::move_data()
|
|
|
{
|
|
|
QTest::addColumn<int>("dx");
|
|
|
QTest::addColumn<int>("dy");
|
|
|
QTest::addColumn<QSizeF>("size");
|
|
|
QTest::newRow("dx 100, dy 0, size 1000x1000") << 100 << 0 << QSizeF(1000, 1000);
|
|
|
QTest::newRow("dx 0, dy 100, size 1000x1000") << 0 << 100 << QSizeF(1000, 1000);
|
|
|
QTest::newRow("dx -100, dy 0, size 1000x1000") << -100 << 0 << QSizeF(1000, 1000);
|
|
|
QTest::newRow("dx 0, dy -100, size 1000x1000") << 0 << -100 << QSizeF(1000, 1000);
|
|
|
QTest::newRow("dx 100, dy 100, size 1000x1000") << 100 << 100 << QSizeF(1000, 1000);
|
|
|
QTest::newRow("dx 100, dy 50, size 1000x1000") << 100 << 50 << QSizeF(1000, 1000);
|
|
|
}
|
|
|
|
|
|
void tst_Domain::move()
|
|
|
{
|
|
|
QFETCH(int, dx);
|
|
|
QFETCH(int, dy);
|
|
|
QFETCH(QSizeF, size);
|
|
|
Domain domain;
|
|
|
|
|
|
domain.setRange(0, size.width(), 0, size.height());
|
|
|
|
|
|
QSignalSpy spy0(&domain, SIGNAL(updated()));
|
|
|
QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal)));
|
|
|
QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal)));
|
|
|
|
|
|
domain.move(dx, dy, size);
|
|
|
|
|
|
Domain result;
|
|
|
result.setRange(dx, size.width() + dx, dy, size.height() + dy);
|
|
|
|
|
|
QCOMPARE(domain == result, true);
|
|
|
TRY_COMPARE(spy0.count(), 1);
|
|
|
TRY_COMPARE(spy1.count(), (dx != 0 ? 1 : 0));
|
|
|
TRY_COMPARE(spy2.count(), (dy != 0 ? 1 : 0));
|
|
|
}
|
|
|
|
|
|
QTEST_MAIN(tst_Domain)
|
|
|
#include "tst_domain.moc"
|
|
|
#endif
|
|
|
|
