From ba2a82b7db86d96fc1f110b4bbc88408f47a5774 Mon Sep 17 00:00:00 2001 From: Paolo Angelelli Date: Fri, 10 Feb 2017 19:05:56 +0100 Subject: Make QGeoCameraCapabilities independent of the engine This patch makes it possible to change QGeoCameraCapabilites at runtime, when the map type changes, to accommodate for those plugins that offer different maps having different capabilities. This is then used to properly push the min/max zoom levels for each map type in our OSM plugin. Autotests are included. Change-Id: I48532da77ffb3eaf2e752561395945c3a2c21985 Reviewed-by: Alex Blasche --- tests/auto/declarative_ui/tst_map.qml | 41 ++++++++++ tests/auto/declarative_ui/tst_map_maptype.qml | 94 +++++++++++++++++++++- .../qgeotiledmappingmanagerengine_test.h | 22 +++++ .../tst_qgeocameracapabilities.cpp | 80 +++++++++++++++--- 4 files changed, 227 insertions(+), 10 deletions(-) (limited to 'tests/auto') diff --git a/tests/auto/declarative_ui/tst_map.qml b/tests/auto/declarative_ui/tst_map.qml index ab1ddd8c..004e3b10 100644 --- a/tests/auto/declarative_ui/tst_map.qml +++ b/tests/auto/declarative_ui/tst_map.qml @@ -260,6 +260,47 @@ Item { compare(map.maximumZoomLevel, 20) } + function test_tilt_limits() + { + // Tilt limits are read only + map.tilt = 0 + + //initial plugin values + compare(map.minimumTilt, 0) + compare(map.maximumTilt, 60) + + map.tilt = 18 + compare(map.tilt, 18) + + map.tilt = -2 + compare(map.tilt, 0) + + map.tilt = 2 + compare(map.tilt, 2) + + map.tilt = 62 + compare(map.tilt, 60) + + map.tilt = 0 + compare(map.tilt, 0) + } + + function test_fov_limits() + { + // Tilt limits are read only + map.fieldOfView = 45 + + //initial plugin values + compare(map.fieldOfView, 45) + compare(map.fieldOfView, 45) + + map.fieldOfView = 18 + compare(map.fieldOfView, 45) + + map.fieldOfView = 62 + compare(map.fieldOfView, 45) + } + function test_zoom() { wait(1000) diff --git a/tests/auto/declarative_ui/tst_map_maptype.qml b/tests/auto/declarative_ui/tst_map_maptype.qml index fa056c44..17e958d5 100644 --- a/tests/auto/declarative_ui/tst_map_maptype.qml +++ b/tests/auto/declarative_ui/tst_map_maptype.qml @@ -40,6 +40,12 @@ Item{ Map { id: map; anchors.fill: parent } SignalSpy { id: supportedMapTypesSpy; target: map; signalName: "supportedMapTypesChanged" } SignalSpy { id: activeMapTypeChangedSpy; target: map; signalName: "activeMapTypeChanged" } + SignalSpy { id: minimumZoomLevelChangedSpy; target: map; signalName: "minimumZoomLevelChanged" } + SignalSpy { id: maximumZoomLevelChangedSpy; target: map; signalName: "maximumZoomLevelChanged" } + SignalSpy { id: minimumTiltChangedSpy; target: map; signalName: "minimumTiltChanged" } + SignalSpy { id: maximumTiltChangedSpy; target: map; signalName: "maximumTiltChanged" } + SignalSpy { id: minimumFieldOfViewChangedSpy; target: map; signalName: "minimumFieldOfViewChanged" } + SignalSpy { id: maximumFieldOfViewChangedSpy; target: map; signalName: "maximumFieldOfViewChanged" } TestCase { id: testCase @@ -52,7 +58,7 @@ Item{ compare(map.activeMapType.style, MapType.NoMap) map.plugin = testPlugin tryCompare(supportedMapTypesSpy, "count", 1) - compare(map.supportedMapTypes.length,3) + compare(map.supportedMapTypes.length, 4) compare(map.supportedMapTypes[0].style, MapType.StreetMap) compare(map.supportedMapTypes[0].name, "StreetMap") compare(map.supportedMapTypes[0].description, "StreetMap") @@ -62,6 +68,9 @@ Item{ compare(map.supportedMapTypes[2].style, MapType.CycleMap) compare(map.supportedMapTypes[2].name, "CycleMap") compare(map.supportedMapTypes[2].description, "CycleMap") + compare(map.supportedMapTypes[3].style, MapType.CustomMap) + compare(map.supportedMapTypes[3].name, "AlternateCameraCapabilities") + compare(map.supportedMapTypes[3].description, "AlternateCameraCapabilities") //default compare(map.activeMapType.style, MapType.StreetMap) } @@ -87,6 +96,89 @@ Item{ tryCompare(activeMapTypeChangedSpy, "count", 2) compare(map.supportedMapTypes[2].name, map.activeMapType.name) compare(map.supportedMapTypes[2].style, map.activeMapType.style) + + map.activeMapType = map.supportedMapTypes[3] + tryCompare(activeMapTypeChangedSpy, "count", 3) + compare(map.supportedMapTypes[3].name, map.activeMapType.name) + compare(map.supportedMapTypes[3].style, map.activeMapType.style) + } + + function test_maptype_capabilities() + { + minimumZoomLevelChangedSpy.clear(); + maximumZoomLevelChangedSpy.clear(); + minimumTiltChangedSpy.clear(); + maximumTiltChangedSpy.clear(); + minimumFieldOfViewChangedSpy.clear(); + maximumFieldOfViewChangedSpy.clear(); + + map.activeMapType = map.supportedMapTypes[0] + + compare(map.minimumZoomLevel, 0) + compare(map.maximumZoomLevel, 20) + compare(map.minimumTilt, 0) + compare(map.maximumTilt, 60) + compare(map.minimumFieldOfView, 45) + compare(map.maximumFieldOfView, 45) + + tryCompare(minimumZoomLevelChangedSpy, "count", 0) + tryCompare(maximumZoomLevelChangedSpy, "count", 0) + tryCompare(minimumTiltChangedSpy, "count", 0) + tryCompare(maximumTiltChangedSpy, "count", 0) + tryCompare(minimumFieldOfViewChangedSpy, "count", 0) + tryCompare(maximumFieldOfViewChangedSpy, "count", 0) + + + map.activeMapType = map.supportedMapTypes[1] + + compare(map.minimumZoomLevel, 0) + compare(map.maximumZoomLevel, 20) + compare(map.minimumTilt, 0) + compare(map.maximumTilt, 60) + compare(map.minimumFieldOfView, 45) + compare(map.maximumFieldOfView, 45) + + tryCompare(minimumZoomLevelChangedSpy, "count", 0) + tryCompare(maximumZoomLevelChangedSpy, "count", 0) + tryCompare(minimumTiltChangedSpy, "count", 0) + tryCompare(maximumTiltChangedSpy, "count", 0) + tryCompare(minimumFieldOfViewChangedSpy, "count", 0) + tryCompare(maximumFieldOfViewChangedSpy, "count", 0) + + + map.activeMapType = map.supportedMapTypes[3] + + compare(map.minimumZoomLevel, 0) + compare(map.maximumZoomLevel, 19) + compare(map.minimumTilt, 0) + compare(map.maximumTilt, 80) + compare(map.minimumFieldOfView, 1) + compare(map.maximumFieldOfView, 179) + + tryCompare(minimumZoomLevelChangedSpy, "count", 0) + tryCompare(maximumZoomLevelChangedSpy, "count", 1) + tryCompare(minimumTiltChangedSpy, "count", 0) + tryCompare(maximumTiltChangedSpy, "count", 1) + tryCompare(minimumFieldOfViewChangedSpy, "count", 1) + tryCompare(maximumFieldOfViewChangedSpy, "count", 1) + + + map.activeMapType = map.supportedMapTypes[0] + + compare(map.minimumZoomLevel, 0) + compare(map.maximumZoomLevel, 20) + compare(map.minimumTilt, 0) + compare(map.maximumTilt, 60) + compare(map.minimumFieldOfView, 45) + compare(map.maximumFieldOfView, 45) + + tryCompare(minimumZoomLevelChangedSpy, "count", 0) + tryCompare(maximumZoomLevelChangedSpy, "count", 2) + tryCompare(minimumTiltChangedSpy, "count", 0) + tryCompare(maximumTiltChangedSpy, "count", 2) + tryCompare(minimumFieldOfViewChangedSpy, "count", 2) + tryCompare(maximumFieldOfViewChangedSpy, "count", 2) + } } } diff --git a/tests/auto/geotestplugin/qgeotiledmappingmanagerengine_test.h b/tests/auto/geotestplugin/qgeotiledmappingmanagerengine_test.h index 015a203a..df729392 100644 --- a/tests/auto/geotestplugin/qgeotiledmappingmanagerengine_test.h +++ b/tests/auto/geotestplugin/qgeotiledmappingmanagerengine_test.h @@ -66,6 +66,7 @@ public: mapTypes << QGeoMapType(QGeoMapType::StreetMap, tr("StreetMap"), tr("StreetMap"), false, false, 1); mapTypes << QGeoMapType(QGeoMapType::SatelliteMapDay, tr("SatelliteMapDay"), tr("SatelliteMapDay"), false, false, 2); mapTypes << QGeoMapType(QGeoMapType::CycleMap, tr("CycleMap"), tr("CycleMap"), false, false, 3); + mapTypes << QGeoMapType(QGeoMapType::CustomMap, tr("AlternateCameraCapabilities"), tr("AlternateCameraCapabilities"), false, false, 4); setSupportedMapTypes(mapTypes); QGeoTileFetcherTest *fetcher = new QGeoTileFetcherTest(this); @@ -90,6 +91,27 @@ public: return new QGeoTiledMapTest(this); } + QGeoCameraCapabilities cameraCapabilities(const QGeoMapType &mapType) const Q_DECL_OVERRIDE + { + switch (mapType.mapId()) { + case 4: + { + QGeoCameraCapabilities capabilities; + capabilities.setMinimumZoomLevel(0.0); + capabilities.setMaximumZoomLevel(19.0); + capabilities.setSupportsBearing(true); + capabilities.setSupportsTilting(true); + capabilities.setMinimumTilt(0); + capabilities.setMaximumTilt(80); + capabilities.setMinimumFieldOfView(1); + capabilities.setMaximumFieldOfView(179); + return capabilities; + } + default: + return QGeoMappingManagerEngine::cameraCapabilities(mapType); + } + } + }; #endif diff --git a/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp b/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp index 09d7293b..06d85e1e 100644 --- a/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp +++ b/tests/auto/qgeocameracapabilities/tst_qgeocameracapabilities.cpp @@ -54,6 +54,8 @@ private Q_SLOTS: void supportsTiltingTest(); void minimumTiltTest(); void maximumTiltTest(); + void minimumFieldOfViewTest(); + void maximumFieldOfViewTest(); void operatorsTest_data(); void operatorsTest(); void isValidTest(); @@ -68,12 +70,14 @@ void tst_QGeoCameraCapabilities::populateGeoCameraCapabilitiesData(){ QTest::addColumn("maximumZoomLevel"); QTest::addColumn("minimumTilt"); QTest::addColumn("maximumTilt"); + QTest::addColumn("minimumFieldOfView"); + QTest::addColumn("maximumFieldOfView"); QTest::addColumn("bearingSupport"); QTest::addColumn("rollingSupport"); QTest::addColumn("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; + QTest::newRow("zeros") << 0.0 << 0.0 << 0.0 << 0.0 << 0.0 << 0.0 << false << false << false; + QTest::newRow("valid") << 1.0 << 2.0 << 0.5 << 1.5 << 1.0 << 179.0 << true << true << true; + QTest::newRow("negative values") << 0.0 << 0.5 << -0.5 << -0.1 << -20.0 << -30.0 << true << true << true; } void tst_QGeoCameraCapabilities::constructorTest_data(){ @@ -86,10 +90,15 @@ void tst_QGeoCameraCapabilities::constructorTest() QFETCH(double, maximumZoomLevel); QFETCH(double, minimumTilt); QFETCH(double, maximumTilt); + QFETCH(double, minimumFieldOfView); + QFETCH(double, maximumFieldOfView); QFETCH(bool, bearingSupport); QFETCH(bool, rollingSupport); QFETCH(bool, tiltingSupport); + minimumFieldOfView = qBound(1.0, minimumFieldOfView, 179.0); + maximumFieldOfView = qBound(1.0, maximumFieldOfView, 179.0); + // contructor test with default values QGeoCameraCapabilities cameraCapabilities; QGeoCameraCapabilities cameraCapabilities2(cameraCapabilities); @@ -100,12 +109,16 @@ void tst_QGeoCameraCapabilities::constructorTest() QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities2.supportsTilting(), "Copy constructor failed for tilting support"); QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities2.minimumTilt()); QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities2.maximumTilt()); + QCOMPARE(cameraCapabilities.minimumFieldOfView(), cameraCapabilities2.minimumFieldOfView()); + QCOMPARE(cameraCapabilities.maximumFieldOfView(), cameraCapabilities2.maximumFieldOfView()); // constructor test after setting values cameraCapabilities.setMinimumZoomLevel(minimumZoomLevel); cameraCapabilities.setMaximumZoomLevel(maximumZoomLevel); cameraCapabilities.setMinimumTilt(minimumTilt); cameraCapabilities.setMaximumTilt(maximumTilt); + cameraCapabilities.setMinimumFieldOfView(minimumFieldOfView); + cameraCapabilities.setMaximumFieldOfView(maximumFieldOfView); cameraCapabilities.setSupportsBearing(bearingSupport); cameraCapabilities.setSupportsRolling(rollingSupport); cameraCapabilities.setSupportsTilting(tiltingSupport); @@ -116,6 +129,8 @@ void tst_QGeoCameraCapabilities::constructorTest() QCOMPARE(cameraCapabilities3.maximumZoomLevel(), maximumZoomLevel); QCOMPARE(cameraCapabilities3.minimumTilt(), minimumTilt); QCOMPARE(cameraCapabilities3.maximumTilt(), maximumTilt); + QCOMPARE(cameraCapabilities3.minimumFieldOfView(), minimumFieldOfView); + QCOMPARE(cameraCapabilities3.maximumFieldOfView(), maximumFieldOfView); 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"); @@ -127,6 +142,8 @@ void tst_QGeoCameraCapabilities::constructorTest() QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities3.supportsTilting(), "Copy constructor failed for tilting support"); QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities3.minimumTilt()); QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities3.maximumTilt()); + QCOMPARE(cameraCapabilities.minimumFieldOfView(), cameraCapabilities3.minimumFieldOfView()); + QCOMPARE(cameraCapabilities.maximumFieldOfView(), cameraCapabilities3.maximumFieldOfView()); } void tst_QGeoCameraCapabilities::minimumZoomLevelTest() @@ -213,6 +230,40 @@ void tst_QGeoCameraCapabilities::maximumTiltTest(){ QCOMPARE(cameraCapabilities2.maximumTilt(), 1.5); } +void tst_QGeoCameraCapabilities::minimumFieldOfViewTest() +{ + QGeoCameraCapabilities cameraCapabilities; + QCOMPARE(cameraCapabilities.minimumFieldOfView(), 45.0); // min/max default to 45 + cameraCapabilities.setMinimumFieldOfView(1.5); + QCOMPARE(cameraCapabilities.minimumFieldOfView(), 1.5); + cameraCapabilities.setMinimumFieldOfView(-1.5); + QCOMPARE(cameraCapabilities.minimumFieldOfView(), 1.0); + cameraCapabilities.setMinimumFieldOfView(245.5); + QCOMPARE(cameraCapabilities.minimumFieldOfView(), 179.0); + + QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities; + QCOMPARE(cameraCapabilities2.minimumFieldOfView(), 179.0); + cameraCapabilities.setMinimumFieldOfView(2.5); + QCOMPARE(cameraCapabilities2.minimumFieldOfView(), 179.0); +} + +void tst_QGeoCameraCapabilities::maximumFieldOfViewTest() +{ + QGeoCameraCapabilities cameraCapabilities; + QCOMPARE(cameraCapabilities.maximumFieldOfView(), 45.0); // min/max default to 45 + cameraCapabilities.setMaximumFieldOfView(1.5); + QCOMPARE(cameraCapabilities.maximumFieldOfView(), 1.5); + cameraCapabilities.setMaximumFieldOfView(-1.5); + QCOMPARE(cameraCapabilities.maximumFieldOfView(), 1.0); + cameraCapabilities.setMaximumFieldOfView(245.5); + QCOMPARE(cameraCapabilities.maximumFieldOfView(), 179.0); + + QGeoCameraCapabilities cameraCapabilities2 = cameraCapabilities; + QCOMPARE(cameraCapabilities2.maximumFieldOfView(), 179.0); + cameraCapabilities.setMaximumFieldOfView(2.5); + QCOMPARE(cameraCapabilities2.maximumFieldOfView(), 179.0); +} + void tst_QGeoCameraCapabilities::operatorsTest_data(){ populateGeoCameraCapabilitiesData(); } @@ -223,15 +274,22 @@ void tst_QGeoCameraCapabilities::operatorsTest(){ QFETCH(double, maximumZoomLevel); QFETCH(double, minimumTilt); QFETCH(double, maximumTilt); + QFETCH(double, minimumFieldOfView); + QFETCH(double, maximumFieldOfView); QFETCH(bool, bearingSupport); QFETCH(bool, rollingSupport); QFETCH(bool, tiltingSupport); + minimumFieldOfView = qBound(1.0, minimumFieldOfView, 179.0); + maximumFieldOfView = qBound(1.0, maximumFieldOfView, 179.0); + QGeoCameraCapabilities cameraCapabilities; cameraCapabilities.setMinimumZoomLevel(minimumZoomLevel); cameraCapabilities.setMaximumZoomLevel(maximumZoomLevel); cameraCapabilities.setMinimumTilt(minimumTilt); cameraCapabilities.setMaximumTilt(maximumTilt); + cameraCapabilities.setMinimumFieldOfView(minimumFieldOfView); + cameraCapabilities.setMaximumFieldOfView(maximumFieldOfView); cameraCapabilities.setSupportsBearing(bearingSupport); cameraCapabilities.setSupportsRolling(rollingSupport); cameraCapabilities.setSupportsTilting(tiltingSupport); @@ -242,17 +300,21 @@ void tst_QGeoCameraCapabilities::operatorsTest(){ 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"); + QVERIFY2(cameraCapabilities2.supportsBearing() == bearingSupport, "Assignment operator failed for bearing support"); + QVERIFY2(cameraCapabilities2.supportsRolling() == rollingSupport, "Assignment operator failed for rolling support "); + QVERIFY2(cameraCapabilities2.supportsTilting() == tiltingSupport, "Assignment operator failed for tilting support"); + QCOMPARE(cameraCapabilities2.minimumFieldOfView(), minimumFieldOfView); + QCOMPARE(cameraCapabilities2.maximumFieldOfView(), maximumFieldOfView); // 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"); + QVERIFY2(cameraCapabilities.supportsBearing() == cameraCapabilities2.supportsBearing(), "Assignment operator failed for bearing support"); + QVERIFY2(cameraCapabilities.supportsRolling() == cameraCapabilities2.supportsRolling(), "Assignment operator failed for rolling support "); + QVERIFY2(cameraCapabilities.supportsTilting() == cameraCapabilities2.supportsTilting(), "Assignment operator failed for tilting support"); QCOMPARE(cameraCapabilities.minimumTilt(), cameraCapabilities2.minimumTilt()); QCOMPARE(cameraCapabilities.maximumTilt(), cameraCapabilities2.maximumTilt()); + QCOMPARE(cameraCapabilities.minimumFieldOfView(), cameraCapabilities2.minimumFieldOfView()); + QCOMPARE(cameraCapabilities.maximumFieldOfView(), cameraCapabilities2.maximumFieldOfView()); } void tst_QGeoCameraCapabilities::isValidTest(){ -- cgit v1.2.3