diff options
| -rw-r--r-- | src/location/maps/qgeotilespec.cpp | 5 | ||||
| -rw-r--r-- | tests/auto/auto.pro | 3 | ||||
| -rw-r--r-- | tests/auto/qgeocameracapabilities/qgeocameracapabilities.pro | 9 | ||||
| -rw-r--r-- | tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp | 310 | ||||
| -rw-r--r-- | tests/auto/qgeocameradata/qgeocameradata.pro | 9 | ||||
| -rw-r--r-- | tests/auto/qgeocameradata/tst_qgeocameradata.cpp | 258 | ||||
| -rw-r--r-- | tests/auto/qgeotilespec/qgeotilespec.pro | 7 | ||||
| -rw-r--r-- | tests/auto/qgeotilespec/tst_qgeotilespec.cpp | 332 |
8 files changed, 933 insertions, 0 deletions
diff --git a/src/location/maps/qgeotilespec.cpp b/src/location/maps/qgeotilespec.cpp index 26b56f21..342706fa 100644 --- a/src/location/maps/qgeotilespec.cpp +++ b/src/location/maps/qgeotilespec.cpp @@ -193,6 +193,11 @@ bool QGeoTileSpecPrivate::operator < (const QGeoTileSpecPrivate &rhs) const if (plugin_ > rhs.plugin_) return false; + if (mapId_ < rhs.mapId_) + return true; + if (mapId_ > rhs.mapId_) + return false; + if (zoom_ < rhs.zoom_) return true; if (zoom_ > rhs.zoom_) diff --git a/tests/auto/auto.pro b/tests/auto/auto.pro index 959c82b5..a8be1277 100644 --- a/tests/auto/auto.pro +++ b/tests/auto/auto.pro @@ -35,6 +35,8 @@ SUBDIRS += geotestplugin \ qgeoboundingarea \ qgeoboundingbox \ qgeoboundingcircle \ + qgeocameradata \ + qgeocameracapabilities \ qgeocameratiles \ qgeocodereply \ qgeocodingmanager \ @@ -51,6 +53,7 @@ SUBDIRS += geotestplugin \ qgeoroutingmanagerplugins \ qgeosatelliteinfo \ qgeosatelliteinfosource \ + qgeotilespec \ qnmeapositioninfosource \ declarative_core \ qgeoroutexmlparser \ diff --git a/tests/auto/qgeocameracapabilities/qgeocameracapabilities.pro b/tests/auto/qgeocameracapabilities/qgeocameracapabilities.pro new file mode 100644 index 00000000..fe13b8fd --- /dev/null +++ b/tests/auto/qgeocameracapabilities/qgeocameracapabilities.pro @@ -0,0 +1,9 @@ +TEMPLATE = app +CONFIG += testcase +TARGET = tst_qgeocameracapabilities + +INCLUDEPATH += ../../../src/location/maps + +SOURCES += tst_qgeocameracapabilities.cpp + +QT += location testlib diff --git a/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp b/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp new file mode 100644 index 00000000..68146a93 --- /dev/null +++ b/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp @@ -0,0 +1,310 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtCore/QString> +#include <QtTest/QtTest> + +#include "qgeocameracapabilities_p.h" +#include "qgeotiledmapdata_p.h" + +QT_USE_NAMESPACE + +class tst_QGeoCameraCapabilities : public QObject +{ + Q_OBJECT + +public: + tst_QGeoCameraCapabilities(); + +private: + void populateGeoCameraCapabilitiesData(); + +private Q_SLOTS: + void constructorTest_data(); + void constructorTest(); + void minimumZoomLevelTest(); + void maximumZoomLevelTest(); + void supportsBearingTest(); + void supportsRollingTest(); + void supportsTiltingTest(); + void minimumTiltTest(); + void maximumTiltTest(); + void operatorsTest_data(); + void operatorsTest(); + void isValidTest(); +}; + +tst_QGeoCameraCapabilities::tst_QGeoCameraCapabilities() +{ +} + +void tst_QGeoCameraCapabilities::populateGeoCameraCapabilitiesData(){ + QTest::addColumn<double>("minimumZoomLevel"); + QTest::addColumn<double>("maximumZoomLevel"); + QTest::addColumn<double>("minimumTilt"); + QTest::addColumn<double>("maximumTilt"); + QTest::addColumn<bool>("bearingSupport"); + QTest::addColumn<bool>("rollingSupport"); + QTest::addColumn<bool>("tiltingSupport"); + QTest::newRow("zeros") << 0.0 << 0.0 << 0.0 << 0.0 << false << false << false; + QTest::newRow("valid") << 1.0 << 2.0 << 0.5 << 1.5 << true << true << true; + QTest::newRow("negative values") << 0.0 << 0.5 << -0.5 << -0.1 << true << true << true; +} + +void tst_QGeoCameraCapabilities::constructorTest_data(){ + populateGeoCameraCapabilitiesData(); +} + +void tst_QGeoCameraCapabilities::constructorTest() +{ + QFETCH(double, minimumZoomLevel); + QFETCH(double, maximumZoomLevel); + QFETCH(double, minimumTilt); + QFETCH(double, maximumTilt); + QFETCH(bool, bearingSupport); + QFETCH(bool, rollingSupport); + QFETCH(bool, tiltingSupport); + + // contructor test with default values + QGeoCameraCapabilities cameraCapabilities; + QGeoCameraCapabilities cameraCapabilities2(cameraCapabilities); + QCOMPARE(cameraCapabilities.minimumZoomLevel(), cameraCapabilities2.minimumZoomLevel()); + QCOMPARE(cameraCapabilities.maximumZoomLevel(), cameraCapabilities2.maximumZoomLevel()); + QVERIFY2(cameraCapabilities.supportsBearing() == cameraCapabilities2.supportsBearing(), "Copy constructor failed for bearing support"); + QVERIFY2(cameraCapabilities.supportsRolling() == cameraCapabilities2.supportsRolling(), "Copy constructor failed for rolling support "); + QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities2.supportsTilting(), "Copy constructor failed for tilting support"); + QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities2.minimumTilt()); + QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities2.maximumTilt()); + + // constructor test after setting values + cameraCapabilities.setMinimumZoomLevel(minimumZoomLevel); + cameraCapabilities.setMaximumZoomLevel(maximumZoomLevel); + cameraCapabilities.setMinimumTilt(minimumTilt); + cameraCapabilities.setMaximumTilt(maximumTilt); + cameraCapabilities.setSupportsBearing(bearingSupport); + cameraCapabilities.setSupportsRolling(rollingSupport); + cameraCapabilities.setSupportsTilting(tiltingSupport); + + QGeoCameraCapabilities cameraCapabilities3(cameraCapabilities); + // test the correctness of the constructor copy + QCOMPARE(cameraCapabilities3.minimumZoomLevel(), minimumZoomLevel); + QCOMPARE(cameraCapabilities3.maximumZoomLevel(), maximumZoomLevel); + QCOMPARE(cameraCapabilities3.minimumTilt(), minimumTilt); + QCOMPARE(cameraCapabilities3.maximumTilt(), maximumTilt); + QVERIFY2(cameraCapabilities3.supportsBearing() == bearingSupport, "Copy constructor failed for bearing support"); + QVERIFY2(cameraCapabilities3.supportsRolling() == rollingSupport, "Copy constructor failed for rolling support "); + QVERIFY2(cameraCapabilities3.supportsTilting() == tiltingSupport, "Copy constructor failed for tilting support"); + // verify that values have not changed after a constructor copy + QCOMPARE(cameraCapabilities.minimumZoomLevel(), cameraCapabilities3.minimumZoomLevel()); + QCOMPARE(cameraCapabilities.maximumZoomLevel(), cameraCapabilities3.maximumZoomLevel()); + QVERIFY2(cameraCapabilities.supportsBearing() == cameraCapabilities3.supportsBearing(), "Copy constructor failed for bearing support"); + QVERIFY2(cameraCapabilities.supportsRolling() == cameraCapabilities3.supportsRolling(), "Copy constructor failed for rolling support "); + QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities3.supportsTilting(), "Copy constructor failed for tilting support"); + QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities3.minimumTilt()); + QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities3.maximumTilt()); +} + +void tst_QGeoCameraCapabilities::minimumZoomLevelTest() +{ + QGeoCameraCapabilities cameraCapabilities; + cameraCapabilities.setMinimumZoomLevel(1.5); + QCOMPARE(cameraCapabilities.minimumZoomLevel(), 1.5); + + QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities; + QCOMPARE(cameraCapabilities2.minimumZoomLevel(), 1.5); + cameraCapabilities.setMinimumZoomLevel(2.5); + QCOMPARE(cameraCapabilities2.minimumZoomLevel(), 1.5); +} + +void tst_QGeoCameraCapabilities::maximumZoomLevelTest() +{ + QGeoCameraCapabilities cameraCapabilities; + cameraCapabilities.setMaximumZoomLevel(3.5); + QCOMPARE(cameraCapabilities.maximumZoomLevel(), 3.5); + + QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities; + QCOMPARE(cameraCapabilities2.maximumZoomLevel(), 3.5); + cameraCapabilities.setMaximumZoomLevel(4.5); + QCOMPARE(cameraCapabilities2.maximumZoomLevel(), 3.5); +} + +void tst_QGeoCameraCapabilities::supportsBearingTest(){ + QGeoCameraCapabilities cameraCapabilities; + QVERIFY(!cameraCapabilities.supportsBearing()); + cameraCapabilities.setSupportsBearing(true); + QVERIFY2(cameraCapabilities.supportsBearing(), "Camera capabilities should support bearing"); + + QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities; + QVERIFY(cameraCapabilities2.supportsBearing()); + cameraCapabilities.setSupportsBearing(false); + QVERIFY2(cameraCapabilities2.supportsBearing(), "Camera capabilities should support bearing"); +} + +void tst_QGeoCameraCapabilities::supportsRollingTest(){ + QGeoCameraCapabilities cameraCapabilities; + QVERIFY(!cameraCapabilities.supportsRolling()); + cameraCapabilities.setSupportsRolling(true); + QVERIFY2(cameraCapabilities.supportsRolling(), "Camera capabilities should support rolling"); + + QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities; + QVERIFY(cameraCapabilities2.supportsRolling()); + cameraCapabilities.setSupportsRolling(false); + QVERIFY2(cameraCapabilities2.supportsRolling(), "Camera capabilities should support rolling"); +} + +void tst_QGeoCameraCapabilities::supportsTiltingTest(){ + QGeoCameraCapabilities cameraCapabilities; + QVERIFY(!cameraCapabilities.supportsTilting()); + cameraCapabilities.setSupportsTilting(true); + QVERIFY2(cameraCapabilities.supportsTilting(), "Camera capabilities should support tilting"); + + QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities; + QVERIFY(cameraCapabilities2.supportsTilting()); + cameraCapabilities.setSupportsTilting(false); + QVERIFY2(cameraCapabilities2.supportsTilting(), "Camera capabilities should support tilting"); +} + +void tst_QGeoCameraCapabilities::minimumTiltTest(){ + QGeoCameraCapabilities cameraCapabilities; + QCOMPARE(cameraCapabilities.minimumTilt(),0.0); + cameraCapabilities.setMinimumTilt(0.5); + QCOMPARE(cameraCapabilities.minimumTilt(),0.5); + + QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities; + QCOMPARE(cameraCapabilities2.minimumTilt(), 0.5); + cameraCapabilities.setMinimumTilt(1.5); + QCOMPARE(cameraCapabilities2.minimumTilt(), 0.5); +} + +void tst_QGeoCameraCapabilities::maximumTiltTest(){ + QGeoCameraCapabilities cameraCapabilities; + QCOMPARE(cameraCapabilities.maximumTilt(),0.0); + cameraCapabilities.setMaximumTilt(1.5); + QCOMPARE(cameraCapabilities.maximumTilt(),1.5); + + QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities; + QCOMPARE(cameraCapabilities2.maximumTilt(), 1.5); + cameraCapabilities.setMaximumTilt(2.5); + QCOMPARE(cameraCapabilities2.maximumTilt(), 1.5); +} + +void tst_QGeoCameraCapabilities::operatorsTest_data(){ + populateGeoCameraCapabilitiesData(); +} + +void tst_QGeoCameraCapabilities::operatorsTest(){ + + QFETCH(double, minimumZoomLevel); + QFETCH(double, maximumZoomLevel); + QFETCH(double, minimumTilt); + QFETCH(double, maximumTilt); + QFETCH(bool, bearingSupport); + QFETCH(bool, rollingSupport); + QFETCH(bool, tiltingSupport); + + QGeoCameraCapabilities cameraCapabilities; + cameraCapabilities.setMinimumZoomLevel(minimumZoomLevel); + cameraCapabilities.setMaximumZoomLevel(maximumZoomLevel); + cameraCapabilities.setMinimumTilt(minimumTilt); + cameraCapabilities.setMaximumTilt(maximumTilt); + cameraCapabilities.setSupportsBearing(bearingSupport); + cameraCapabilities.setSupportsRolling(rollingSupport); + cameraCapabilities.setSupportsTilting(tiltingSupport); + QGeoCameraCapabilities cameraCapabilities2; + cameraCapabilities2 = cameraCapabilities; + // test the correctness of the assignment + QCOMPARE(cameraCapabilities2.minimumZoomLevel(), minimumZoomLevel); + QCOMPARE(cameraCapabilities2.maximumZoomLevel(), maximumZoomLevel); + QCOMPARE(cameraCapabilities2.minimumTilt(), minimumTilt); + QCOMPARE(cameraCapabilities2.maximumTilt(), maximumTilt); + QVERIFY2(cameraCapabilities2.supportsBearing() == bearingSupport, "Copy constructor failed for bearing support"); + QVERIFY2(cameraCapabilities2.supportsRolling() == rollingSupport, "Copy constructor failed for rolling support "); + QVERIFY2(cameraCapabilities2.supportsTilting() == tiltingSupport, "Copy constructor failed for tilting support"); + // verify that values have not changed after a constructor copy + QCOMPARE(cameraCapabilities.minimumZoomLevel(), cameraCapabilities2.minimumZoomLevel()); + QCOMPARE(cameraCapabilities.maximumZoomLevel(), cameraCapabilities2.maximumZoomLevel()); + QVERIFY2(cameraCapabilities.supportsBearing() == cameraCapabilities2.supportsBearing(), "Copy constructor failed for bearing support"); + QVERIFY2(cameraCapabilities.supportsRolling() == cameraCapabilities2.supportsRolling(), "Copy constructor failed for rolling support "); + QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities2.supportsTilting(), "Copy constructor failed for tilting support"); + QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities2.minimumTilt()); + QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities2.maximumTilt()); +} + +void tst_QGeoCameraCapabilities::isValidTest(){ + QGeoCameraCapabilities cameraCapabilities; + QVERIFY2(!cameraCapabilities.isValid(), "Camera capabilities should default to invalid"); + cameraCapabilities.setSupportsBearing(true); + QVERIFY2(cameraCapabilities.isValid(), "Camera capabilities should be valid"); + + QGeoCameraCapabilities cameraCapabilities2; + QVERIFY2(!cameraCapabilities2.isValid(), "Camera capabilities should default to invalid"); + cameraCapabilities2.setSupportsRolling(true); + QVERIFY2(cameraCapabilities2.isValid(), "Camera capabilities should be valid"); + + QGeoCameraCapabilities cameraCapabilities3; + QVERIFY2(!cameraCapabilities3.isValid(), "Camera capabilities should default to invalid"); + cameraCapabilities3.setSupportsTilting(true); + QVERIFY2(cameraCapabilities3.isValid(), "Camera capabilities should be valid"); + + QGeoCameraCapabilities cameraCapabilities4; + QVERIFY2(!cameraCapabilities4.isValid(), "Camera capabilities should default to invalid"); + cameraCapabilities4.setMinimumZoomLevel(1.0); + QVERIFY2(cameraCapabilities4.isValid(), "Camera capabilities should be valid"); + + QGeoCameraCapabilities cameraCapabilities5; + QVERIFY2(!cameraCapabilities5.isValid(), "Camera capabilities should default to invalid"); + cameraCapabilities5.setMaximumZoomLevel(1.5); + QVERIFY2(cameraCapabilities5.isValid(), "Camera capabilities should be valid"); + + QGeoCameraCapabilities cameraCapabilities6; + QVERIFY2(!cameraCapabilities6.isValid(), "Camera capabilities should default to invalid"); + cameraCapabilities6.setMinimumTilt(0.2); + QVERIFY2(cameraCapabilities6.isValid(), "Camera capabilities should be valid"); + + QGeoCameraCapabilities cameraCapabilities7; + QVERIFY2(!cameraCapabilities7.isValid(), "Camera capabilities should default to invalid"); + cameraCapabilities7.setMaximumTilt(0.8); + QVERIFY2(cameraCapabilities7.isValid(), "Camera capabilities should be valid"); +} + +QTEST_APPLESS_MAIN(tst_QGeoCameraCapabilities) + +#include "tst_qgeocameracapabilities.moc" diff --git a/tests/auto/qgeocameradata/qgeocameradata.pro b/tests/auto/qgeocameradata/qgeocameradata.pro new file mode 100644 index 00000000..74ac69e9 --- /dev/null +++ b/tests/auto/qgeocameradata/qgeocameradata.pro @@ -0,0 +1,9 @@ +TEMPLATE = app +CONFIG += testcase +TARGET = tst_qgeocameradata + +INCLUDEPATH += ../../../src/location/maps + +SOURCES += tst_qgeocameradata.cpp + +QT += location testlib diff --git a/tests/auto/qgeocameradata/tst_qgeocameradata.cpp b/tests/auto/qgeocameradata/tst_qgeocameradata.cpp new file mode 100644 index 00000000..29de3698 --- /dev/null +++ b/tests/auto/qgeocameradata/tst_qgeocameradata.cpp @@ -0,0 +1,258 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtCore/QString> +#include <QtTest/QtTest> + +#include "qgeocameradata_p.h" + +QT_USE_NAMESPACE + +// For testing the setters and getters of the QGeoCoordinateInterpolator shared pointer +class QGeoCoordinateInterpolatorTest : public QGeoCoordinateInterpolator +{ +public: + QGeoCoordinateInterpolatorTest(){} + ~QGeoCoordinateInterpolatorTest(){} + QGeoCoordinate interpolate(const QGeoCoordinate &start, const QGeoCoordinate &end, qreal progress){ + Q_UNUSED(start); + Q_UNUSED(end); + Q_UNUSED(progress); + return QGeoCoordinate(); + } +}; + + +class tst_QGeoCameraData : public QObject +{ + Q_OBJECT + +public: + tst_QGeoCameraData(); + +private: + void populateCameraData(); + +private Q_SLOTS: + void constructorTest_data(); + void constructorTest(); + void centerTest(); + void bearingTest(); + void tiltTest(); + void rollTest(); + void zoomLevelTest(); + void coordinateInterpolatorTest(); + void operatorsTest_data(); + void operatorsTest(); +}; + +tst_QGeoCameraData::tst_QGeoCameraData() +{ +} + + +void tst_QGeoCameraData::populateCameraData() +{ + QTest::addColumn<QGeoCoordinate>("center"); + QTest::addColumn<double>("bearing"); + QTest::addColumn<double>("tilt"); + QTest::addColumn<double>("roll"); + QTest::addColumn<double>("zoomLevel"); + QTest::newRow("zeros") << QGeoCoordinate() << 0.0 << 0.0 << 0.0 << 0.0; + QTest::newRow("valid") << QGeoCoordinate(10.0,20.5,30.8) << 0.1 << 0.2 << 0.3 << 2.0; + QTest::newRow("negative values") << QGeoCoordinate(-50,-20,100) << -0.1 << -0.2 << -0.3 << 1.0; +} + +void tst_QGeoCameraData::constructorTest_data(){ + populateCameraData(); +} + +void tst_QGeoCameraData::constructorTest() +{ + QFETCH(QGeoCoordinate, center); + QFETCH(double, bearing); + QFETCH(double, tilt); + QFETCH(double, roll); + QFETCH(double, zoomLevel); + + // constructor test with default values + QGeoCameraData cameraData; + QGeoCameraData cameraData2(cameraData); + QCOMPARE(cameraData.center(), cameraData2.center()); + QCOMPARE(cameraData.bearing(), cameraData2.bearing()); + QCOMPARE(cameraData.tilt(), cameraData2.tilt()); + QCOMPARE(cameraData.roll(), cameraData2.roll()); + QCOMPARE(cameraData.zoomLevel(), cameraData2.zoomLevel()); + + // constructor test after setting values + cameraData.setCenter(center); + cameraData.setBearing(bearing); + cameraData.setTilt(tilt); + cameraData.setRoll(roll); + cameraData.setZoomLevel(zoomLevel); + QGeoCameraData cameraData3(cameraData); + // test the correctness of the constructor copy + QCOMPARE(cameraData3.center(), center); + QCOMPARE(cameraData3.bearing(), bearing); + QCOMPARE(cameraData3.tilt(), tilt); + QCOMPARE(cameraData3.roll(), roll); + QCOMPARE(cameraData3.zoomLevel(), zoomLevel); + // verify that values have not changed after a constructor copy + QCOMPARE(cameraData.center(), cameraData3.center()); + QCOMPARE(cameraData.bearing(), cameraData3.bearing()); + QCOMPARE(cameraData.tilt(), cameraData3.tilt()); + QCOMPARE(cameraData.roll(), cameraData3.roll()); + QCOMPARE(cameraData.zoomLevel(), cameraData3.zoomLevel()); +} + + +void tst_QGeoCameraData::centerTest() +{ + QGeoCameraData cameraData; //center currently default to (-27.5, 153) + cameraData.setCenter(QGeoCoordinate(10.0,20.4,30.8)); + QCOMPARE(cameraData.center(),QGeoCoordinate(10.0,20.4,30.8)); +} + +void tst_QGeoCameraData::bearingTest(){ + QGeoCameraData cameraData; + QCOMPARE(cameraData.bearing(),0.0); + cameraData.setBearing(0.1); + QCOMPARE(cameraData.bearing(),0.1); + + QGeoCameraData cameraData2 = cameraData; + QCOMPARE(cameraData2.bearing(),0.1); + cameraData.setBearing(0.2); + QCOMPARE(cameraData2.bearing(),0.1); +} + +void tst_QGeoCameraData::tiltTest(){ + QGeoCameraData cameraData; + QCOMPARE(cameraData.tilt(),0.0); + cameraData.setTilt(0.4); + QCOMPARE(cameraData.tilt(),0.4); + + QGeoCameraData cameraData2 = cameraData; + QCOMPARE(cameraData2.tilt(),0.4); + cameraData.setTilt(0.5); + QCOMPARE(cameraData2.tilt(),0.4); +} + +void tst_QGeoCameraData::rollTest(){ + QGeoCameraData cameraData; + QCOMPARE(cameraData.roll(),0.0); + cameraData.setRoll(0.5); + QCOMPARE(cameraData.roll(),0.5); + + QGeoCameraData cameraData2 = cameraData; + QCOMPARE(cameraData2.roll(),0.5); + cameraData.setRoll(0.6); + QCOMPARE(cameraData2.roll(),0.5); +} + +void tst_QGeoCameraData::zoomLevelTest(){ + QGeoCameraData cameraData; //zoom level currently defaults to 9.0 + cameraData.setZoomLevel(8.0); + QCOMPARE(cameraData.zoomLevel(),8.0); + + QGeoCameraData cameraData2 = cameraData; + QCOMPARE(cameraData2.zoomLevel(),8.0); + cameraData.setZoomLevel(9.0); + QCOMPARE(cameraData2.zoomLevel(),8.0); +} + +void tst_QGeoCameraData::coordinateInterpolatorTest(){ + QGeoCameraData cameraData; + QVERIFY2(cameraData.coordinateInterpolator().isNull(), "Default coordinate interpolator shared point is not null"); + QSharedPointer<QGeoCoordinateInterpolator> testPointer = QSharedPointer<QGeoCoordinateInterpolator>(new QGeoCoordinateInterpolatorTest()); + cameraData.setCoordinateInterpolator(testPointer); + QVERIFY2(!cameraData.coordinateInterpolator().isNull(), "Coordinate interpolator shared point is null"); +} + +void tst_QGeoCameraData::operatorsTest_data(){ + populateCameraData(); +} + +void tst_QGeoCameraData::operatorsTest(){ + QGeoCameraData cameraData; + QGeoCameraData cameraData2; + QVERIFY2(cameraData == cameraData2, "Camera data with default values are not copied correctly"); + + QFETCH(QGeoCoordinate, center); + QFETCH(double, bearing); + QFETCH(double, tilt); + QFETCH(double, roll); + QFETCH(double, zoomLevel); + cameraData.setCenter(center); + cameraData.setBearing(bearing); + cameraData.setTilt(tilt); + cameraData.setRoll(roll); + cameraData.setZoomLevel(zoomLevel); + + QGeoCameraData cameraData3; + cameraData3 = cameraData; + QVERIFY2(cameraData == cameraData3, "Camera data not copied correctly"); + + // test QGeoCameraData pairs where they differ in one field + QGeoCameraData cameraData4; + cameraData4 = cameraData; + cameraData4.setCenter(QGeoCoordinate(10.0,20.0,30.0)); + QVERIFY2(cameraData != cameraData4, "Camera data should be different"); + QGeoCameraData cameraData5; + cameraData5 = cameraData; + cameraData5.setBearing(bearing+1.0); + QVERIFY2(cameraData != cameraData5, "Camera data should be different"); + QGeoCameraData cameraData6; + cameraData6 = cameraData; + cameraData6.setTilt(tilt+0.1); + QVERIFY2(cameraData != cameraData6, "Camera data should be different"); + QGeoCameraData cameraData7; + cameraData7 = cameraData; + cameraData7.setRoll(roll+0.1); + QVERIFY2(cameraData != cameraData7, "Camera data should be different"); + QGeoCameraData cameraData8; + cameraData8 = cameraData; + cameraData8.setZoomLevel(zoomLevel+1.0); + QVERIFY2(cameraData != cameraData8, "Camera data should be different"); +} + +QTEST_APPLESS_MAIN(tst_QGeoCameraData) + +#include "tst_qgeocameradata.moc" diff --git a/tests/auto/qgeotilespec/qgeotilespec.pro b/tests/auto/qgeotilespec/qgeotilespec.pro new file mode 100644 index 00000000..d92e5975 --- /dev/null +++ b/tests/auto/qgeotilespec/qgeotilespec.pro @@ -0,0 +1,7 @@ +TEMPLATE = app +CONFIG += testcase +TARGET = tst_qgeotilespec + +SOURCES += tst_qgeotilespec.cpp + +QT += location testlib diff --git a/tests/auto/qgeotilespec/tst_qgeotilespec.cpp b/tests/auto/qgeotilespec/tst_qgeotilespec.cpp new file mode 100644 index 00000000..54e13407 --- /dev/null +++ b/tests/auto/qgeotilespec/tst_qgeotilespec.cpp @@ -0,0 +1,332 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtCore/QString> +#include <QtTest/QtTest> + +#include <qgeotilespec.h> + +QT_USE_NAMESPACE + +class tst_QGeoTileSpec : public QObject +{ + Q_OBJECT + +public: + tst_QGeoTileSpec(); + +private: + void populateGeoTileSpecData(); + +private Q_SLOTS: + void constructorTest_data(); + void constructorTest(); + void pluginTest(); + void zoomTest(); + void xTest(); + void yTest(); + void mapIdTest(); + void assignsOperatorTest_data(); + void assignsOperatorTest(); + void equalsOperatorTest_data(); + void equalsOperatorTest(); + void lessThanOperatorTest_data(); + void lessThanOperatorTest(); + void qHashTest_data(); + void qHashTest(); +}; + +tst_QGeoTileSpec::tst_QGeoTileSpec() +{ +} + +void tst_QGeoTileSpec::populateGeoTileSpecData(){ + QTest::addColumn<QString>("plugin"); + QTest::addColumn<int>("mapId"); + QTest::addColumn<int>("zoom"); + QTest::addColumn<int>("x"); + QTest::addColumn<int>("y"); + QTest::newRow("zeros") << QString() << 0 << 0 << 0 << 0; + QTest::newRow("valid") << QString("geo plugin") << 455 << 1 << 20 << 50; + QTest::newRow("negative values") << QString("geo plugin negative") << -350 << 2 << -20 << -50; +} + +void tst_QGeoTileSpec::constructorTest_data() +{ + populateGeoTileSpecData(); +} + +void tst_QGeoTileSpec::constructorTest() +{ + QFETCH(QString,plugin); + QFETCH(int,zoom); + QFETCH(int,mapId); + QFETCH(int,x); + QFETCH(int,y); + + // test constructor copy with default values + QGeoTileSpec testObj; + QGeoTileSpec testObj2(testObj); + QCOMPARE(testObj.plugin(), testObj2.plugin()); + QCOMPARE(testObj.mapId(), testObj2.mapId()); + QCOMPARE(testObj.zoom(), testObj2.zoom()); + QCOMPARE(testObj.x(), testObj2.x()); + QCOMPARE(testObj.y(), testObj2.y()); + + // test second construct + QGeoTileSpec testObj3(plugin, mapId, zoom, x, y); + QCOMPARE(testObj3.plugin(), plugin); + QCOMPARE(testObj3.mapId(), mapId); + QCOMPARE(testObj3.zoom(), zoom); + QCOMPARE(testObj3.x(), x); + QCOMPARE(testObj3.y(), y); +} + +void tst_QGeoTileSpec::pluginTest() +{ + QGeoTileSpec tileSpec; + QCOMPARE(tileSpec.plugin(), QString()); + + QGeoTileSpec tileSpec2(QString("plugin test"),1,10,10,5); + QCOMPARE(tileSpec2.plugin(), QString("plugin test")); +} + +void tst_QGeoTileSpec::zoomTest() +{ + QGeoTileSpec tileSpec; + QVERIFY(tileSpec.zoom() == -1); + tileSpec.setZoom(1); + QVERIFY(tileSpec.zoom() == 1); + + QGeoTileSpec tileSpec2 = tileSpec; + QVERIFY(tileSpec2.zoom() == 1); + tileSpec.setZoom(2); + QVERIFY(tileSpec2.zoom() == 1); +} + +void tst_QGeoTileSpec::xTest() +{ + QGeoTileSpec tileSpec; + QVERIFY(tileSpec.x() == -1); + tileSpec.setX(10); + QVERIFY(tileSpec.x() == 10); + + QGeoTileSpec tileSpec2 = tileSpec; + QVERIFY(tileSpec2.x() == 10); + tileSpec.setX(30); + QVERIFY(tileSpec2.x() == 10); +} + +void tst_QGeoTileSpec::yTest() +{ + QGeoTileSpec tileSpec; + QVERIFY(tileSpec.y() == -1); + tileSpec.setY(20); + QVERIFY(tileSpec.y() == 20); + + QGeoTileSpec tileSpec2 = tileSpec; + QVERIFY(tileSpec2.y() == 20); + tileSpec.setY(40); + QVERIFY(tileSpec2.y() == 20); +} + +void tst_QGeoTileSpec::mapIdTest() +{ + QGeoTileSpec tileSpec; + QVERIFY(tileSpec.mapId() == 0); + tileSpec.setMapId(1); + QVERIFY(tileSpec.mapId() == 1); + + QGeoTileSpec tileSpec2 = tileSpec; + QVERIFY(tileSpec2.mapId() == 1); + tileSpec.setMapId(5); + QVERIFY(tileSpec2.mapId() == 1); +} + +void tst_QGeoTileSpec::assignsOperatorTest_data() +{ + populateGeoTileSpecData(); +} + + +void tst_QGeoTileSpec::assignsOperatorTest() +{ + QFETCH(QString,plugin); + QFETCH(int,mapId); + QFETCH(int,zoom); + QFETCH(int,x); + QFETCH(int,y); + + QGeoTileSpec testObj(plugin, mapId, zoom, x, y); + QGeoTileSpec testObj2; + testObj2 = testObj; + // test the correctness of the asignment operator + QVERIFY2(testObj2.plugin() == plugin, "Plugin not copied correctly"); + QVERIFY2(testObj2.zoom() == zoom, "Zoom not copied correctly"); + QVERIFY2(testObj2.mapId() == mapId, "Map Id not copied correctly"); + QVERIFY2(testObj2.x() == x, "X not copied correctly"); + QVERIFY2(testObj2.y() == y, "Y not copied correctly"); + // verify that values have not changed after an assignment + QVERIFY2(testObj.plugin() == testObj2.plugin(), "Plugin not copied correctly"); + QVERIFY2(testObj.zoom() == testObj2.zoom(), "Zoom not copied correctly"); + QVERIFY2(testObj.mapId() == testObj2.mapId(), "Map Id not copied correctly"); + QVERIFY2(testObj.x() == testObj2.x(), "X not copied correctly"); + QVERIFY2(testObj.y() == testObj2.y(), "Y not copied correctly"); +} + + +void tst_QGeoTileSpec::equalsOperatorTest_data() +{ + populateGeoTileSpecData(); +} + +void tst_QGeoTileSpec::equalsOperatorTest() +{ + QFETCH(QString,plugin); + QFETCH(int,mapId); + QFETCH(int,zoom); + QFETCH(int,x); + QFETCH(int,y); + + QGeoTileSpec testObj(plugin, mapId, zoom, x, y); + QGeoTileSpec testObj2(plugin, mapId, zoom, x, y); + QVERIFY2(testObj == testObj2, "Equals operator is not correct"); + + // test QGeoTileSpec pairs where they differ in one field + testObj2.setZoom(zoom+1); + QVERIFY2(!(testObj == testObj2), "Equals operator is not correct"); + testObj2 = testObj; + testObj2.setMapId(mapId+1); + QVERIFY2(!(testObj == testObj2), "Equals operator is not correct"); + testObj2 = testObj; + testObj2.setX(x+1); + QVERIFY2(!(testObj == testObj2), "Equals operator is not correct"); + testObj2 = testObj; + testObj2.setY(y+1); + QVERIFY2(!(testObj == testObj2), "Equals operator is not correct"); +} + +void tst_QGeoTileSpec::lessThanOperatorTest_data() +{ + populateGeoTileSpecData(); +} + +void tst_QGeoTileSpec::lessThanOperatorTest() +{ + QFETCH(QString,plugin); + QFETCH(int,mapId); + QFETCH(int,zoom); + QFETCH(int,x); + QFETCH(int,y); + + QGeoTileSpec testObj(plugin, mapId, zoom, x, y); + QGeoTileSpec testObj2(testObj); + QVERIFY(!(testObj < testObj2)); + + testObj2.setMapId(mapId-1); + QVERIFY2(testObj2 < testObj, "Less than operator is not correct for mapId"); + testObj2 = testObj; + testObj2.setZoom(zoom-1); + QVERIFY2(testObj2 < testObj, "Less than operator is not correct for zoom"); + testObj2 = testObj; + testObj2.setX(x-1); + QVERIFY2(testObj2 < testObj, "Less than operator is not correct for x"); + testObj2 = testObj; + testObj2.setY(y-1); + QVERIFY2(testObj2 < testObj, "Less than operator is not correct for y"); + + // less than comparisons are done in the order: plugin -> mapId -> zoom -> x -> y + // the test below checks if the order is correct + QGeoTileSpec testObj3(plugin + QString('a'), mapId-1, zoom-1, x-1, y-1); + QVERIFY2(testObj < testObj3, "Order of less than operator is not correct"); + QGeoTileSpec testObj4(plugin, mapId+1, zoom-1, x-1, y-1); + QVERIFY2(testObj < testObj4, "Order of less than operator is not correct"); + QGeoTileSpec testObj5(plugin, mapId, zoom+1, x-1, y-1); + QVERIFY2(testObj < testObj5, "Order of less than operator is not correct"); + QGeoTileSpec testObj6(plugin, mapId, zoom, x+1, y-1); + QVERIFY2(testObj < testObj6, "Order of less than operator is not correct"); + QGeoTileSpec testObj7(plugin, mapId, zoom, x, y+1); + QVERIFY2(testObj < testObj7, "Order of less than operator is not correct"); + + QGeoTileSpec testObj8(plugin, mapId-1, zoom+1, x+1, y+1); + QVERIFY2(testObj8 < testObj, "Order of less than operator is not correct"); + QGeoTileSpec testObj9(plugin, mapId, zoom-1, x+1, y+1); + QVERIFY2(testObj9 < testObj, "Order of less than operator is not correct"); + QGeoTileSpec testObj10(plugin, mapId, zoom, x-1, y+1); + QVERIFY2(testObj10 < testObj, "Order of less than operator is not correct"); +} + +void tst_QGeoTileSpec::qHashTest_data(){ + populateGeoTileSpecData(); +} + +void tst_QGeoTileSpec::qHashTest() +{ + QGeoTileSpec testObj; + unsigned int hash1 = qHash(testObj); + QGeoTileSpec testObj2; + testObj2 = testObj; + unsigned int hash2 = qHash(testObj2); + QCOMPARE(hash1, hash2); + + QFETCH(QString,plugin); + QFETCH(int,mapId); + QFETCH(int,zoom); + QFETCH(int,x); + QFETCH(int,y); + + QGeoTileSpec testObj3(plugin, mapId, zoom, x, y); + unsigned int hash3 = qHash(testObj3); + QVERIFY(hash1 != hash3); + + testObj2.setMapId(testObj3.mapId()+1); + testObj2.setZoom(testObj3.zoom()+1); + testObj2.setX(testObj3.x()*5); + testObj2.setY(testObj3.y()*10); + hash2 = qHash(testObj2); + QVERIFY(hash2 != hash3); +} + +QTEST_APPLESS_MAIN(tst_QGeoTileSpec) + +#include "tst_qgeotilespec.moc" + + |