HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2892:5c50b9f6fefd

use standardized test export macros...

Oswald Buddenhagen -

r2892:5c50b9f6fefd

parent child

Context file:

r2892:5c50b9f6fefd

Collapse all files

src/charts/charts.pro 0 -5

             ############################# BUILD CONFIG ######################################
             TARGET = QtCharts
             QT = core gui widgets
             QMAKE_DOCS = $$PWD/doc/qtcharts.qdocconf
             QMAKE_TARGET_PRODUCT = "Qt Charts (Qt $$QT_VERSION)"
             QMAKE_TARGET_DESCRIPTION = "Charts component for Qt."
             ############################# SOURCES ##########################################
             SOURCES += \
                 $$PWD/chartdataset.cpp \
                 $$PWD/chartpresenter.cpp \
                 $$PWD/chartthememanager.cpp \
                 $$PWD/qchart.cpp \
                 $$PWD/qchartview.cpp \
                 $$PWD/qabstractseries.cpp \
                 $$PWD/chartbackground.cpp \
                 $$PWD/chartelement.cpp \
                 $$PWD/chartitem.cpp \
                 $$PWD/scroller.cpp \
                 $$PWD/charttitle.cpp \
                 $$PWD/qpolarchart.cpp
             contains(QT_CONFIG, opengl): SOURCES += $$PWD/glwidget.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/chartpresenter_p.h \
                 $$PWD/chartthememanager_p.h \
                 $$PWD/chartbackground_p.h \
                 $$PWD/chartelement_p.h \
                 $$PWD/chartconfig_p.h \
                 $$PWD/qchart_p.h \
                 $$PWD/qchartview_p.h \
                 $$PWD/scroller_p.h \
                 $$PWD/qabstractseries_p.h \
                 $$PWD/charttitle_p.h \
                 $$PWD/charthelpers_p.h
             contains(QT_CONFIG, opengl): PRIVATE_HEADERS += $$PWD/glwidget_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchart.h \
                 $$PWD/qchartglobal.h \
                 $$PWD/qabstractseries.h \
                 $$PWD/qchartview.h \
                 $$PWD/chartsnamespace.h \
                 $$PWD/qpolarchart.h
             include($$PWD/animations/animations.pri)
             include($$PWD/areachart/areachart.pri)
             include($$PWD/axis/axis.pri)
             include($$PWD/domain/domain.pri)
             include($$PWD/barchart/barchart.pri)
             include($$PWD/legend/legend.pri)
             include($$PWD/linechart/linechart.pri)
             include($$PWD/piechart/piechart.pri)
             include($$PWD/scatterchart/scatter.pri)
             include($$PWD/splinechart/splinechart.pri)
             include($$PWD/themes/themes.pri)
             include($$PWD/xychart/xychart.pri)
             include($$PWD/layout/layout.pri)
             include($$PWD/boxplotchart/boxplotchart.pri)
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             OTHER_FILES += doc/qtcharts.qdocconf \
                            doc/src/* \
                            doc/images/*
-            #Define for unit tests
-            CONFIG(debug, debug|release) {
-                DEFINES += BUILD_PRIVATE_UNIT_TESTS
             msvc {
                 # Suppress "conversion from 'size_t' to 'int', possible loss of data" warnings in 64bit
                 # builds resulting from usage of str::sort
                 QMAKE_CXXFLAGS_WARN_ON += -wd4267
             }
             win32:!winrt:!wince {
                 # ChartThemeSystem uses Windows native API
                 LIBS += -luser32
             }
             load(qt_module)

src/charts/qchartglobal.h +1 -8

             /******************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd.
             ** Contact: http://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module.
             **
             ** $QT_BEGIN_LICENSE:COMM$
             **
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see http://www.qt.io/terms-conditions. For further
             ** information use the contact form at http://www.qt.io/contact-us.
             **
             ** $QT_END_LICENSE$
             **
             ******************************************************************************/
             #ifndef QCHARTGLOBAL_H
             #define QCHARTGLOBAL_H
             #include <QtCore/QtGlobal>
             #define QT_CHARTS_VERSION_STR   "2.1.1"
             /*
                QT_CHARTS_VERSION is (major << 16) + (minor << 8) + patch.
             */
             #define QT_CHARTS_VERSION       0x020101
             /*
                can be used like #if (QT_CHARTS_VERSION >= QT_CHARTS_VERSION_CHECK(1, 1, 0))
             */
             #define QT_CHARTS_VERSION_CHECK(major, minor, patch) ((major<<16)|(minor<<8)|(patch))
             #ifndef QT_STATIC
             #  if defined(QT_BUILD_CHARTS_LIB)
             #    define QT_CHARTS_EXPORT Q_DECL_EXPORT
             #  else
             #    define QT_CHARTS_EXPORT Q_DECL_IMPORT
             #  endif
             #else
             #  define QT_CHARTS_EXPORT
             #endif
-            #if defined(BUILD_PRIVATE_UNIT_TESTS) && defined(QT_BUILD_CHARTS_LIB)
+            #define QT_CHARTS_AUTOTEST_EXPORT Q_AUTOTEST_EXPORT
-            #  define QT_CHARTS_AUTOTEST_EXPORT Q_DECL_EXPORT
-            #elif defined(BUILD_PRIVATE_UNIT_TESTS) && !defined(QT_BUILD_CHARTS_LIB)
-            #  define QT_CHARTS_AUTOTEST_EXPORT Q_DECL_IMPORT
-            #else
-            #  define QT_CHARTS_AUTOTEST_EXPORT
-            #endif
             #define QT_CHARTS_NAMESPACE QtCharts
             #ifdef QT_CHARTS_NAMESPACE
             #  define QT_CHARTS_BEGIN_NAMESPACE namespace QT_CHARTS_NAMESPACE {
             #  define QT_CHARTS_END_NAMESPACE }
             #  define QT_CHARTS_USE_NAMESPACE using namespace QT_CHARTS_NAMESPACE;
             #else
             #  define QT_CHARTS_BEGIN_NAMESPACE
             #  define QT_CHARTS_END_NAMESPACE
             #  define QT_CHARTS_USE_NAMESPACE
             #endif
             /*
                 On Windows min and max conflict with standard macros
             */
             #ifdef Q_OS_WIN
             #ifndef NOMINMAX
             #define NOMINMAX
             #endif
             #endif
             #endif // QCHARTGLOBAL_H

tests/auto/auto.pri 0 -5

             !include( ../tests.pri ) {
                 error( "Couldn't find the tests.pri file!" )
             }
             QT += testlib widgets
             !contains(TARGET, ^tst_.*):TARGET = $$join(TARGET,,"tst_")
             INCLUDEPATH += ../inc
             HEADERS += ../inc/tst_definitions.h
-            #Define for unit tests
-            CONFIG(debug, debug|release) {
-                DEFINES += BUILD_PRIVATE_UNIT_TESTS

tests/auto/chartdataset/tst_chartdataset.cpp +2 -2

             /******************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd.
             ** Contact: http://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module.
             **
             ** $QT_BEGIN_LICENSE:COMM$
             **
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see http://www.qt.io/terms-conditions. For further
             ** information use the contact form at http://www.qt.io/contact-us.
             **
             ** $QT_END_LICENSE$
             **
             ******************************************************************************/
-            #ifndef BUILD_PRIVATE_UNIT_TESTS
+            #ifndef QT_BUILD_INTERNAL
             #include <QtTest/QtTest>
             class tst_ChartDataSet: public QObject {
                 Q_OBJECT
             private Q_SLOTS:
                 void skip();
             };
             void tst_ChartDataSet::skip()
             {
-                QSKIP("This test requires the debug version of library");
+                QSKIP("This test requires a developer build of the library");
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"
             #else
             #include <QtTest/QtTest>
             #include <QtCharts/QAbstractAxis>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QBarCategoryAxis>
             #include <QtCharts/QCategoryAxis>
             #ifndef QT_ON_ARM
             #include <QtCharts/QDateTimeAxis>
             #endif
             #include <QtCharts/QLineSeries>
             #include <QtCharts/QAreaSeries>
             #include <QtCharts/QScatterSeries>
             #include <QtCharts/QSplineSeries>
             #include <QtCharts/QPieSeries>
             #include <QtCharts/QBarSeries>
             #include <QtCharts/QPercentBarSeries>
             #include <QtCharts/QStackedBarSeries>
             #include <private/chartdataset_p.h>
             #include <private/abstractdomain_p.h>
             #include <tst_definitions.h>
             QT_CHARTS_USE_NAMESPACE
             Q_DECLARE_METATYPE(AbstractDomain *)
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
             Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
             Q_DECLARE_METATYPE(Qt::Alignment)
             Q_DECLARE_METATYPE(QList<Qt::Alignment>)
             Q_DECLARE_METATYPE(QLineSeries *)
             class tst_ChartDataSet: public QObject {
                 Q_OBJECT
             public:
                 tst_ChartDataSet():m_dataset(0){};
             public Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private Q_SLOTS:
                 void chartdataset_data();
                 void chartdataset();
                 void addSeries_data();
                 void addSeries();
                 void removeSeries_data();
                 void removeSeries();
                 void addAxis_data();
                 void addAxis();
                 void removeAxis_data();
                 void removeAxis();
                 void attachAxis_data();
                 void attachAxis();
                 void detachAxis_data();
                 void detachAxis();
             private:
                 ChartDataSet* m_dataset;
             };
             void tst_ChartDataSet::initTestCase()
             {
                 qRegisterMetaType<AbstractDomain*>();
                 qRegisterMetaType<QAbstractAxis*>();
                 qRegisterMetaType<QAbstractSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_ChartDataSet::init()
             {
                 Q_ASSERT(!m_dataset);
                 m_dataset = new ChartDataSet(0);
             }
             void tst_ChartDataSet::cleanup()
             {
                 delete m_dataset;
                 m_dataset = 0;
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	QVERIFY(m_dataset->axes().isEmpty());
             	QVERIFY(m_dataset->series().isEmpty());
             	m_dataset->createDefaultAxes();
             }
             void tst_ChartDataSet::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries*>("series");
                 QAbstractSeries* line = new QLineSeries(this);
                 QTest::newRow("line") << line;
                 QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(new QLineSeries(this)));
                 QTest::newRow("area") << area;
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QTest::newRow("scatter") << scatter;
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QTest::newRow("spline") << spline;
                 QAbstractSeries* pie = new QPieSeries(this);
                 QTest::newRow("pie") << pie;
                 QAbstractSeries* bar = new QBarSeries(this);
                 QTest::newRow("bar") << bar;
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QTest::newRow("percent") << percent;
                 QAbstractSeries* stacked = new QStackedBarSeries(this);
                 QTest::newRow("stacked") << stacked;
             }
             void tst_ChartDataSet::addSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(m_dataset->series().isEmpty());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->addSeries(series);
                 QCOMPARE(m_dataset->series().count(),1);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(m_dataset->series().isEmpty());
                 m_dataset->addSeries(series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->removeSeries(series);
                 QCOMPARE(m_dataset->series().count(),0);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 1);
                 delete series;
             }
             void tst_ChartDataSet::addAxis_data()
             {
                 QTest::addColumn<QAbstractAxis*>("axis");
                 QAbstractAxis* value = new QValueAxis(this);
                 QAbstractAxis* category = new QCategoryAxis(this);
                 QAbstractAxis* barcategory = new QBarCategoryAxis(this);
             #ifndef Q_WS_QWS
                 QAbstractAxis* datetime = new QDateTimeAxis(this);
             #endif
                 QTest::newRow("value") << value;
                 QTest::newRow("category") << category;
                 QTest::newRow("barcategory") << barcategory;
             #ifndef Q_WS_QWS
                 QTest::newRow("datetime") << datetime;
             #endif
             }
             void tst_ChartDataSet::addAxis()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QVERIFY(m_dataset->axes().isEmpty());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->addAxis(axis,Qt::AlignBottom);
                 QCOMPARE(m_dataset->axes().count(),1);
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::removeAxis_data()
             {
                 addAxis_data();
             }
             void tst_ChartDataSet::removeAxis()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QVERIFY(m_dataset->series().isEmpty());
                 m_dataset->addAxis(axis,Qt::AlignBottom);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->removeAxis(axis);
                 QCOMPARE(m_dataset->axes().count(),0);
                 QCOMPARE(m_dataset->series().count(),0);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
                 delete axis;
             }
             void tst_ChartDataSet::attachAxis_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("series");
                 QTest::addColumn<QList<QAbstractAxis*> >("axis");
                 QTest::addColumn<QList<Qt::Alignment> >("alignment");
                 QTest::addColumn<QAbstractSeries*>("attachSeries");
                 QTest::addColumn<QAbstractAxis*>("attachAxis");
                 QTest::addColumn<bool>("success");
                 {
                  QList<QAbstractSeries*> series;
                  QList<QAbstractAxis*> axes;
                  QList<Qt::Alignment> alignment;
                  QAbstractSeries* line = new QLineSeries(this);
                  QAbstractAxis* value1 = new QValueAxis(this);
                  QAbstractAxis* value2 = new QValueAxis(this);
                  series << line << 0;
                  axes << value1 << value2;
                  alignment << Qt::AlignBottom << Qt::AlignLeft;
                  QTest::newRow("first") << series << axes << alignment << line << value2 << true ;
                 }
                 {
                   QList<QAbstractSeries*> series;
                   QList<QAbstractAxis*> axes;
                   QList<Qt::Alignment> alignment;
                   QAbstractSeries* line = new QLineSeries(this);
                   QAbstractAxis* value1 = new QValueAxis(this);
                   QAbstractAxis* value2 = new QValueAxis(this);
                   series << 0 << line;
                   axes << value1 << value2;
                   alignment << Qt::AlignBottom << Qt::AlignLeft;
                   QTest::newRow("second") << series << axes << alignment << line << value1 << true;
                 }
             }
             void tst_ChartDataSet::attachAxis()
             {
                 QFETCH(QList<QAbstractSeries*>, series);
                 QFETCH(QList<QAbstractAxis*>, axis);
                 QFETCH(QList<Qt::Alignment>, alignment);
                 QFETCH(QAbstractSeries*, attachSeries);
                 QFETCH(QAbstractAxis*, attachAxis);
                 QFETCH(bool, success);
                 Q_ASSERT(series.count() == axis.count());
                 Q_ASSERT(series.count() == alignment.count());
                 QVERIFY(m_dataset->series().isEmpty());
                 QVERIFY(m_dataset->axes().isEmpty());
                 for(int i = 0 ; i < series.count() ; i++){
                     if(series[i]) m_dataset->addSeries(series[i]);
                     if(axis[i]) m_dataset->addAxis(axis[i],alignment[i]);
                     if(series[i] && axis[i]) m_dataset->attachAxis(series[i],axis[i]);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 QCOMPARE(m_dataset->attachAxis(attachSeries,attachAxis),success);
             }
             void tst_ChartDataSet::detachAxis_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("series");
                 QTest::addColumn<QList<QAbstractAxis*> >("axis");
                 QTest::addColumn<QAbstractSeries*>("detachSeries");
                 QTest::addColumn<QAbstractAxis*>("detachAxis");
                 QTest::addColumn<bool>("success");
                 {
                 QList<QAbstractSeries*> series;
                 QList<QAbstractAxis*> axes;
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractAxis* value = new QValueAxis(this);
                 series << line;
                 axes << value;
                 QTest::newRow("first") << series << axes << line << value << true;
                 }
             }
             void tst_ChartDataSet::detachAxis()
             {
                 QFETCH(QList<QAbstractSeries*>, series);
                 QFETCH(QList<QAbstractAxis*>, axis);
                 QFETCH(QAbstractSeries*, detachSeries);
                 QFETCH(QAbstractAxis*, detachAxis);
                 QFETCH(bool, success);
                 Q_ASSERT(series.count() == axis.count());
                 QVERIFY(m_dataset->series().isEmpty());
                 QVERIFY(m_dataset->axes().isEmpty());
                 for(int i = 0; i < series.count(); i++) {
                     if(series[i]) m_dataset->addSeries(series[i]);
                     if(axis[i]) m_dataset->addAxis(axis[i],Qt::AlignBottom);
                     if(series[i] && axis[i]) m_dataset->attachAxis(series[i],axis[i]);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 QCOMPARE(m_dataset->detachAxis(detachSeries,detachAxis),success);
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"
             #endif

tests/auto/domain/tst_domain.cpp +2 -2

             /******************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd.
             ** Contact: http://www.qt.io/licensing/
             **
             ** This file is part of the Qt Charts module.
             **
             ** $QT_BEGIN_LICENSE:COMM$
             **
             ** Commercial License Usage
             ** Licensees holding valid commercial Qt licenses may use this file in
             ** accordance with the commercial license agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and The Qt Company. For licensing terms
             ** and conditions see http://www.qt.io/terms-conditions. For further
             ** information use the contact form at http://www.qt.io/contact-us.
             **
             ** $QT_END_LICENSE$
             **
             ******************************************************************************/
-            #ifndef BUILD_PRIVATE_UNIT_TESTS
+            #ifndef QT_BUILD_INTERNAL
             #include <QtTest/QtTest>
             class tst_Domain: public QObject {
                 Q_OBJECT
             private Q_SLOTS:
                 void skip();
             };
             void tst_Domain::skip()
             {
-                QSKIP("This test requires the debug version of library");
+                QSKIP("This test requires a developer build of the library");
             }
             QTEST_MAIN(tst_Domain)
             #include "tst_domain.moc"
             #else
             #include <QtTest/QtTest>
             #include <private/xydomain_p.h>
             #include <private/qabstractaxis_p.h>
             #include <tst_definitions.h>
             QT_CHARTS_USE_NAMESPACE
             Q_DECLARE_METATYPE(XYDomain*)
             Q_DECLARE_METATYPE(QSizeF)
             Q_DECLARE_METATYPE(QMargins)
             class AxisMock: public QAbstractAxisPrivate
             {
             Q_OBJECT
             public:
                 AxisMock(Qt::Alignment alignment):QAbstractAxisPrivate(0){ setAlignment(alignment);};
                 void initializeGraphics(QGraphicsItem* item)
                 {
                     Q_UNUSED(item);
                 };
                 void initializeDomain(AbstractDomain* 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);
                 };
                 void setRange(qreal min, qreal max)
                 {
                       m_min=min;
                       m_max=max;
                       emit rangeChanged(min,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 handleHorizontalAxisRangeChanged_data();
                 void handleHorizontalAxisRangeChanged();
                 void handleVerticalAxisRangeChanged_data();
                 void handleVerticalAxisRangeChanged();
                 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 zoomIn_data();
                 void zoomIn();
                 void zoomOut_data();
                 void zoomOut();
                 void move_data();
                 void move();
             };
             void tst_Domain::initTestCase()
             {
             }
             void tst_Domain::cleanupTestCase()
             {
                 QTest::qWait(1); // Allow final deleteLaters to run
             }
             void tst_Domain::init()
             {
             }
             void tst_Domain::cleanup()
             {
             }
             void tst_Domain::domain()
             {
                 XYDomain 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::handleHorizontalAxisRangeChanged_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::handleHorizontalAxisRangeChanged()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 XYDomain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 AxisMock axis(Qt::AlignBottom);
                 QObject::connect(&axis,SIGNAL(rangeChanged(qreal,qreal)),&domain,SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
                 axis.setRange(min,max);
                 QVERIFY(qFuzzyCompare(domain.minX(), min));
                 QVERIFY(qFuzzyCompare(domain.maxX(), max));
                 QList<QVariant> arg1 = spy1.first();
                 QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
                 QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 0);
             }
             void tst_Domain::handleVerticalAxisRangeChanged_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::handleVerticalAxisRangeChanged()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 XYDomain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 AxisMock axis(Qt::AlignLeft);
                 QObject::connect(&axis, SIGNAL(rangeChanged(qreal,qreal)), &domain, SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
                 axis.setRange(min,max);
                 QVERIFY(qFuzzyCompare(domain.minY(), min));
                 QVERIFY(qFuzzyCompare(domain.maxY(), max));
                 QList<QVariant> arg1 = spy2.first();
                 QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
                 QVERIFY(qFuzzyCompare(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<QSizeF>("size");
                 QTest::addColumn<bool>("isEmpty");
                 QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << QSizeF(1,1) << true;
                 QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << QSizeF(1,1) << true;
                 QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << QSizeF(1,1) << true;
                 QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << QSizeF(1,1) << false;
                 QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << QSizeF(-11,1) << true;
             }
             void tst_Domain::isEmpty()
             {
                 QFETCH(qreal, minX);
                 QFETCH(qreal, maxX);
                 QFETCH(qreal, minY);
                 QFETCH(qreal, maxY);
                 QFETCH(QSizeF, size);
                 QFETCH(bool, isEmpty);
                 XYDomain domain;
                 domain.setRange(minX, maxX, minY, maxY);
                 domain.setSize(size);
                 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);
                 XYDomain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(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);
                 XYDomain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(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);
                 XYDomain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(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);
                 XYDomain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(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<XYDomain*>("domain1");
                 QTest::addColumn<XYDomain*>("domain2");
                 QTest::addColumn<bool>("equals");
                 QTest::addColumn<bool>("notEquals");
                 XYDomain* a;
                 XYDomain* b;
                 a = new XYDomain();
                 a->setRange(0, 100, 0, 100);
                 b = new XYDomain();
                 b->setRange(0, 100, 0, 100);
                 QTest::newRow("equals") << a << b << true << false;
                 a = new XYDomain();
                 a->setRange(0, 100, 0, 100);
                 b = new XYDomain();
                 b->setRange(0, 100, 0, 1);
                 QTest::newRow("equals") << a << b << false << true;
                 a = new XYDomain();
                 a->setRange(0, 100, 0, 100);
                 b = new XYDomain();
                 b->setRange(0, 1, 0, 100);
                 QTest::newRow("equals") << a << b << false << true;
             }
             void tst_Domain::operatorEquals()
             {
                 QFETCH(XYDomain*, domain1);
                 QFETCH(XYDomain*, domain2);
                 QFETCH(bool, equals);
                 QFETCH(bool, notEquals);
                 XYDomain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(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);
                 delete domain1;
                 delete domain2;
             }
             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);
                 XYDomain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(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);
                 XYDomain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.setRangeX(min, max);
                 QVERIFY(qFuzzyCompare(domain.minX(), min));
                 QVERIFY(qFuzzyCompare(domain.maxX(), max));
                 QList<QVariant> arg1 = spy1.first();
                 QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
                 QVERIFY(qFuzzyCompare(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);
                 XYDomain domain;
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.setRangeY(min, max);
                 QVERIFY(qFuzzyCompare(domain.minY(), min));
                 QVERIFY(qFuzzyCompare(domain.maxY(), max));
                 QList<QVariant> arg1 = spy2.first();
                 QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
                 QVERIFY(qFuzzyCompare(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);
                 XYDomain domain;
                 domain.setRangeX(minX, maxX);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(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);
                 XYDomain domain;
                 domain.setRangeY(minY, maxY);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 QCOMPARE(domain.spanY(), spanY);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
             }
             void tst_Domain::zoomIn_data()
             {
                 QTest::addColumn<QMargins>("range");
                 QTest::addColumn<QSizeF>("size");
                 QTest::addColumn<QMargins>("zoom");
                 QTest::addColumn<QMargins>("result");
                 QTest::newRow("first") << QMargins(0,0,1000,1000) << QSizeF(1000, 1000) <<
                 						  QMargins(100, 100, 900, 900) << QMargins(100,100,900,900);
                 QTest::newRow("second") << QMargins(0,0,2000,2000) << QSizeF(1000, 1000) <<
                 						  QMargins(100, 100, 900, 900) << QMargins(200,200,1800,1800);
             }
             void tst_Domain::zoomIn()
             {
                 QFETCH(QMargins, range);
                 QFETCH(QSizeF, size);
                 QFETCH(QMargins, zoom);
                 QFETCH(QMargins, result);
                 XYDomain domain;
                 domain.setRange(range.left(), range.right(), range.top(),range.bottom());
                 domain.setSize(size);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.zoomIn(QRectF(zoom.left(),zoom.top(),zoom.right()-zoom.left(),zoom.bottom()-zoom.top()));
                 QCOMPARE(domain.minX(),qreal(result.left()));
                 QCOMPARE(domain.maxX(),qreal(result.right()));
                 QCOMPARE(domain.minY(),qreal(result.top()));
                 QCOMPARE(domain.maxY(),qreal(result.bottom()));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
             }
             void tst_Domain::zoomOut_data()
             {
                 QTest::addColumn<QMargins>("range");
                 QTest::addColumn<QSizeF>("size");
                 QTest::addColumn<QMargins>("zoom");
                 QTest::addColumn<QMargins>("result");
                 QTest::newRow("first") << QMargins(100,100,900,900) << QSizeF(1000, 1000) <<
                 						  QMargins(100, 100, 900, 900) << QMargins(0,0,1000,1000);
                 QTest::newRow("second") << QMargins(200,200,1800,1800) << QSizeF(1000, 1000) <<
                 						  QMargins(100, 100, 900, 900) << QMargins(0,0,2000,2000);
             }
             void tst_Domain::zoomOut()
             {
                 QFETCH(QMargins, range);
                 QFETCH(QSizeF, size);
                 QFETCH(QMargins, zoom);
                 QFETCH(QMargins, result);
                 XYDomain domain;
                 domain.setRange(range.left(), range.right(), range.top(),range.bottom());
                 domain.setSize(size);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.zoomOut(QRectF(zoom.left(),zoom.top(),zoom.right()-zoom.left(),zoom.bottom()-zoom.top()));
                 QCOMPARE(domain.minX(),qreal(result.left()));
                 QCOMPARE(domain.maxX(),qreal(result.right()));
                 QCOMPARE(domain.minY(),qreal(result.top()));
                 QCOMPARE(domain.maxY(),qreal(result.bottom()));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 1);
             }
             void tst_Domain::move_data()
             {
             	QTest::addColumn<QMargins>("range");
             	QTest::addColumn<QSizeF>("size");
                 QTest::addColumn<int>("dx");
                 QTest::addColumn<int>("dy");
                 QTest::addColumn<QMargins>("result");
                 QTest::newRow("first") << QMargins(0,0,1000,1000) << QSizeF(1000, 1000) <<
 << 10 << QMargins(10,10,1010,1010);
                 QTest::newRow("second") << QMargins(0,0,1000,1000) << QSizeF(1000, 1000) <<
                    						  -10 << -10 << QMargins(-10,-10,990,990);
             }
             void tst_Domain::move()
             {
                 QFETCH(QMargins, range);
                 QFETCH(QSizeF, size);
                 QFETCH(int, dx);
                 QFETCH(int, dy);
                 QFETCH(QMargins, result);
                 XYDomain domain;
                 domain.setRange(range.left(), range.right(), range.top(),range.bottom());
                 domain.setSize(size);
                 QSignalSpy spy0(&domain, SIGNAL(updated()));
                 QSignalSpy spy1(&domain, SIGNAL(rangeHorizontalChanged(qreal,qreal)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeVerticalChanged(qreal,qreal)));
                 domain.move(dx, dy);
                 QCOMPARE(domain.minX(),qreal(result.left()));
                 QCOMPARE(domain.maxX(),qreal(result.right()));
                 QCOMPARE(domain.minY(),qreal(result.top()));
                 QCOMPARE(domain.maxY(),qreal(result.bottom()));
                 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

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages