Enable and update map flick and pinch autotest.

Make pan drag distance inclusive in
QDeclarativeGeoMapGestureArea which simplifies
unit testing on different platforms.

Use sceneCenter instead of lastPos for panning startup.
lastPos is used with velocity sampling which
makes it not reliable as a starting value.

Change-Id: If0d98e834a5e2d4264a51d70c2c39846cd2a677b
Reviewed-by: Alex Blasche <alexander.blasche@theqtcompany.com>

4 files changed, 155 insertions, 72 deletions

diff --git a/src/imports/location/qdeclarativegeomapgesturearea.cpp b/src/imports/location/qdeclarativegeomapgesturearea.cpp
index 05891626..b18864eb 100644
--- a/src/imports/location/qdeclarativegeomapgesturearea.cpp
+++ b/src/imports/location/qdeclarativegeomapgesturearea.cpp
@@ -994,7 +994,7 @@ void QDeclarativeGeoMapGestureArea::panStateMachine()
     case panInactive:
         if (canStartPan()) {
             // Update startCoord_ to ensure smooth start for panning when going over startDragDistance
-            QGeoCoordinate newStartCoord = map_->itemPositionToCoordinate(QDoubleVector2D(lastPos_), false);
+            QGeoCoordinate newStartCoord = map_->itemPositionToCoordinate(QDoubleVector2D(sceneCenter_), false);
             startCoord_.setLongitude(newStartCoord.longitude());
             startCoord_.setLatitude(newStartCoord.latitude());
             panState_ = panActive;
@@ -1053,7 +1053,7 @@ bool QDeclarativeGeoMapGestureArea::canStartPan()
     QPointF p1 = declarativeMap_->mapFromScene(m_allPoints.at(0).scenePos());
     int dyFromPress = int(p1.y() - sceneStartPoint1_.y());
     int dxFromPress = int(p1.x() - sceneStartPoint1_.x());
-    if ((qAbs(dyFromPress) > startDragDistance || qAbs(dxFromPress) > startDragDistance))
+    if ((qAbs(dyFromPress) >= startDragDistance || qAbs(dxFromPress) >= startDragDistance))
         return true;
     return false;
 }
diff --git a/tests/auto/declarative_ui/tst_map_pinch_and_flick.qml_disabled b/tests/auto/declarative_ui/tst_map_pinch_and_flick.qml
index 3fd12f9d..a5f68d5e 100644
--- a/tests/auto/declarative_ui/tst_map_pinch_and_flick.qml_disabled
+++ b/tests/auto/declarative_ui/tst_map_pinch_and_flick.qml
@@ -54,9 +54,15 @@ Item {
         anchors.fill: page
         x:0; y:0
         property variant lastPinchEvent: null
+        property point startPinchPoint1: Qt.point(0,0)
+        property point startPinchPoint2: Qt.point(0,0)
+        property point endPinchPoint1: Qt.point(0,0)
+        property point endPinchPoint2: Qt.point(0,0)
         property bool rejectPinch: false
         gesture.onPinchStarted: {
             map.lastPinchEvent = pinch;
+            map.startPinchPoint1= pinch.point1;
+            map.startPinchPoint2= pinch.point2;
             if (rejectPinch)
                 pinch.accepted = false;
             //console.log('Pinch got started, point1: ' + pinch.point1 + ' point2: ' + pinch.point2 + ' angle: ' + pinch.angle)
@@ -67,6 +73,8 @@ Item {
         }
         gesture.onPinchFinished: {
             map.lastPinchEvent = pinch;
+            map.endPinchPoint1= pinch.point1;
+            map.endPinchPoint2= pinch.point2;
         }
         property real flickStartedLatitude
         property real flickStartedLongitude
@@ -88,12 +96,12 @@ Item {
     SignalSpy {id: pinchUpdatedSpy; target: map.gesture; signalName: 'pinchUpdated'}
     SignalSpy {id: pinchFinishedSpy; target: map.gesture; signalName: 'pinchFinished'}
     SignalSpy {id: pinchMaximumZoomLevelChangeSpy; target: map.gesture; signalName: 'maximumZoomLevelChangeChanged'}
+    SignalSpy {id: panFinishedSpy; target: map.gesture; signalName: 'panFinished'}
     SignalSpy {id: gestureEnabledSpy; target: map.gesture; signalName: 'enabledChanged'}
     SignalSpy {id: pinchActiveSpy; target: map.gesture; signalName: 'pinchActiveChanged'}
     SignalSpy {id: pinchActiveGesturesSpy; target: map.gesture; signalName: 'activeGesturesChanged'}
     SignalSpy {id: mapZoomLevelSpy; target: map; signalName: 'zoomLevelChanged'}
     SignalSpy {id: flickDecelerationSpy; target: map.gesture; signalName: 'flickDecelerationChanged'}
-    SignalSpy {id: movementStoppedSpy; target: map.gesture; signalName: 'movementStopped'}
     SignalSpy {id: flickStartedSpy; target: map.gesture; signalName: 'flickStarted'}
     SignalSpy {id: flickFinishedSpy; target: map.gesture; signalName: 'flickFinished'}
 
@@ -120,11 +128,22 @@ Item {
             pinchActiveGesturesSpy.clear()
             mapZoomLevelSpy.clear()
             flickDecelerationSpy.clear()
-            movementStoppedSpy.clear()
+            panFinishedSpy.clear()
             flickStartedSpy.clear()
             flickFinishedSpy.clear()
         }
 
+        //see QDeclarativeGeoMapGestureArea::updatePinch()
+        function calculateZoom(startPinchPoint1,startPinchPoint2,endPinchPoint1,endPinchPoint2,
+                               width,height, maximumZoomLevelChange, startZoomLevel) {
+            var startDistance = Math.sqrt(Math.pow(startPinchPoint2.x - startPinchPoint1.x,2) +
+                         + Math.pow(startPinchPoint2.y - startPinchPoint1.y,2))
+            var endDistance = Math.sqrt(Math.pow(endPinchPoint2.x - endPinchPoint1.x,2) +
+                         + Math.pow(endPinchPoint2.y - endPinchPoint1.y,2))
+            return  2 * (endDistance - startDistance) * maximumZoomLevelChange /
+                    (width + height) + startZoomLevel;
+        }
+
         function test_a_basic_properties() { // a to excecute first
             clear_data()
 
@@ -158,18 +177,18 @@ Item {
             compare(map.gesture.activeGestures, MapGestureArea.ZoomGesture)
             compare(pinchActiveGesturesSpy.count, 4)
 
-            compare(map.gesture.maximumZoomLevelChange, 2)
-            map.gesture.maximumZoomLevelChange = 4
+            compare(map.gesture.maximumZoomLevelChange, 4)
+            map.gesture.maximumZoomLevelChange = 8
             compare(pinchMaximumZoomLevelChangeSpy.count, 1)
-            compare (map.gesture.maximumZoomLevelChange, 4)
-            map.gesture.maximumZoomLevelChange = 4
+            compare (map.gesture.maximumZoomLevelChange, 8)
+            map.gesture.maximumZoomLevelChange = 8
             compare(pinchMaximumZoomLevelChangeSpy.count, 1)
-            compare (map.gesture.maximumZoomLevelChange, 4)
+            compare (map.gesture.maximumZoomLevelChange, 8)
             map.gesture.maximumZoomLevelChange = 11   // too big
             map.gesture.maximumZoomLevelChange = 0.01 // too small
             map.gesture.maximumZoomLevelChange = -1   // too small
             compare(pinchMaximumZoomLevelChangeSpy.count, 1)
-            compare (map.gesture.maximumZoomLevelChange, 4)
+            compare (map.gesture.maximumZoomLevelChange, 8)
             map.gesture.maximumZoomLevelChange = 2
             compare(pinchMaximumZoomLevelChangeSpy.count, 2)
             compare (map.gesture.maximumZoomLevelChange, 2)
@@ -218,7 +237,7 @@ Item {
             var moveLatitude = map.center.latitude // store lat and check that flick continues
             tryCompare(flickStartedSpy, "count", 1)
 
-            tryCompare(movementStoppedSpy, "count", 1)
+            tryCompare(panFinishedSpy, "count", 1)
             tryCompare(flickFinishedSpy, "count", 1)
             verify(map.center.latitude > moveLatitude)
             compare(map.center.longitude, 11) // should remain the same
@@ -236,7 +255,7 @@ Item {
             verify(map.center.latitude < 70)
             moveLatitude = map.center.latitude // store lat and check that flick continues
             tryCompare(flickStartedSpy, "count", 1)
-            tryCompare(movementStoppedSpy, "count", 1)
+            tryCompare(panFinishedSpy, "count", 1)
             tryCompare(flickFinishedSpy, "count", 1)
             verify(map.center.latitude < moveLatitude)
             compare(map.center.longitude, 11) // should remain the same
@@ -256,7 +275,7 @@ Item {
             moveLatitude = map.center.latitude
             var moveLongitude = map.center.longitude
             tryCompare(flickStartedSpy, "count", 1)
-            tryCompare(movementStoppedSpy, "count", 1)
+            tryCompare(panFinishedSpy, "count", 1)
             tryCompare(flickFinishedSpy, "count", 1)
             verify(map.center.latitude > moveLatitude)
             verify(map.center.longitude < moveLongitude)
@@ -274,7 +293,7 @@ Item {
             mouseRelease(map, i, i)
             compare(flickStartedSpy.count, 0)
             compare(flickFinishedSpy.count, 0)
-            compare(movementStoppedSpy.count, 0)
+            compare(panFinishedSpy.count, 0)
             map.gesture.panEnabled = true
 
             // 5. disable during flick: onFlickStarted
@@ -291,7 +310,7 @@ Item {
             tryCompare(flickStartedSpy, "count", 1)
             verify(map.center.latitude > 50)
             tryCompare(flickStartedSpy, "count", 1)
-            tryCompare(movementStoppedSpy, "count", 1)
+            tryCompare(panFinishedSpy, "count", 1)
             tryCompare(flickFinishedSpy, "count", 1)
             // compare that flick was interrupted (less movement than without interrupting)
             verify(diagonalFlickResultLatitude > map.center.latitude)
@@ -310,8 +329,9 @@ Item {
                 mouseMove(map, i, i, 0, Qt.LeftButton);
             }
             mouseRelease(map, i, i)
-            verify(map.center.latitude > 50)
-            tryCompare(movementStoppedSpy, "count", 1)
+            verify(map.center.latitude === 50)
+            verify(map.center.longitude === 50)
+            tryCompare(panFinishedSpy, "count", 1)
             // compare that flick was interrupted (less movement than without interrupting)
             verify(diagonalFlickResultLatitude > map.center.latitude)
             verify(diagonalFlickResultLongitude < map.center.longitude)
@@ -319,9 +339,11 @@ Item {
         }
 
         function test_pinch_zoom() {
+            var startZoomLevel = 9
             map.gesture.activeGestures = MapGestureArea.ZoomGesture
-            map.zoomLevel = 9
+            map.zoomLevel = startZoomLevel
             clear_data()
+
             // 1. typical zoom in
             map.gesture.maximumZoomLevelChange = 2
             compare(map.gesture.isPinchActive, false)
@@ -339,15 +361,17 @@ Item {
             compare(map.lastPinchEvent.center.x, 50)
             compare(map.lastPinchEvent.center.y, 50)
             compare(map.lastPinchEvent.angle, 0)
-            verify((map.lastPinchEvent.point1.x > 0) && (map.lastPinchEvent.point1.x < 25))
+            verify((map.lastPinchEvent.point1.x > pinchGenerator.startDragDistance())
+                && (map.lastPinchEvent.point1.x < 25))
             compare(map.lastPinchEvent.point1.y, 50)
-            verify((map.lastPinchEvent.point2.x > 75) && (map.lastPinchEvent.point2.x < 100))
+            verify((map.lastPinchEvent.point2.x > 75)
+                && (map.lastPinchEvent.point2.x < 100 - pinchGenerator.startDragDistance()))
             compare(map.lastPinchEvent.point2.y, 50)
             compare(map.lastPinchEvent.accepted, true)
             compare(map.lastPinchEvent.pointCount, 2)
-            tryCompare(pinchActiveSpy, "count", 1) // check that pinch is active
+            tryCompare(pinchActiveSpy, "count", 2) // check that pinch is active
             compare(map.gesture.isPinchActive, true)
-            wait(200)
+            wait(200) // five points, each 40ms
             // check the pinch event data for pinchUpdated
             compare(map.lastPinchEvent.center.x, 50)
             compare(map.lastPinchEvent.center.y, 50)
@@ -359,6 +383,7 @@ Item {
             compare(map.lastPinchEvent.accepted, true)
             compare(map.lastPinchEvent.pointCount, 2)
             tryCompare(pinchFinishedSpy, "count", 1);
+            compare(map.gesture.isPinchActive, false)
             // check the pinch event data for pinchFinished
             compare(map.lastPinchEvent.center.x, 50)
             compare(map.lastPinchEvent.center.y, 50)
@@ -371,111 +396,136 @@ Item {
             compare(map.lastPinchEvent.pointCount, 0)
 
             verify(pinchUpdatedSpy.count >= 5); // verify 'sane' number of updates received
-            compare(pinchActiveSpy.count,2)
+            compare(pinchActiveSpy.count,3)
             compare(map.gesture.isPinchActive, false)
             compare(mapZoomLevelSpy.count, pinchUpdatedSpy.count)
-            compare(map.zoomLevel, 8)
+            var endZoomLevel = calculateZoom( map.startPinchPoint1, map.startPinchPoint2,
+                                              map.endPinchPoint1, map.endPinchPoint2,
+                                              map.width,map.height,
+                                              map.gesture.maximumZoomLevelChange,startZoomLevel)
+            compare(map.zoomLevel, endZoomLevel)
+
             // 2. typical zoom out
             clear_data();
+            startZoomLevel = 7.8
             map.gesture.maximumZoomLevelChange = 2
+            map.zoomLevel = startZoomLevel
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
                                  Qt.point(50,50), Qt.point(100,50),
                                  40, 40, 10, 10);
             tryCompare(pinchStartedSpy, "count", 1);
             tryCompare(pinchFinishedSpy, "count", 1);
             verify(pinchUpdatedSpy.count >= 5); // verify 'sane' number of updates received
-            compare(map.zoomLevel, 9)
+            endZoomLevel = calculateZoom( map.startPinchPoint1, map.startPinchPoint2,
+                                              map.endPinchPoint1, map.endPinchPoint2,
+                                              map.width,map.height,
+                                              map.gesture.maximumZoomLevelChange,startZoomLevel)
+
+            compare(map.zoomLevel, endZoomLevel)
+
             // 3. zoom in and back out (direction change during same pinch)
             clear_data();
+            startZoomLevel = 7.8
+            map.gesture.maximumZoomLevelChange = 2
+            map.zoomLevel = startZoomLevel
             pinchGenerator.pinch(Qt.point(0,50), Qt.point(100,50),
                                  Qt.point(100,50),Qt.point(0,50),
                                  40, 40, 10, 10);
             tryCompare(pinchStartedSpy, "count", 1);
             tryCompare(pinchFinishedSpy, "count", 1);
             verify(pinchUpdatedSpy.count >= 5); // verify 'sane' number of updates received
-            compare(map.zoomLevel, 9) // should remain the same
+            endZoomLevel = calculateZoom( map.startPinchPoint1, map.startPinchPoint2,
+                                              map.endPinchPoint1, map.endPinchPoint2,
+                                              map.width,map.height,
+                                              map.gesture.maximumZoomLevelChange,startZoomLevel)
+            compare(map.zoomLevel, endZoomLevel) // should remain the same
+
             // 4. typical zoom in with different change level
             clear_data();
+            startZoomLevel = 8
             map.gesture.maximumZoomLevelChange = 4
+            map.zoomLevel = startZoomLevel
             compare (map.gesture.maximumZoomLevelChange, 4)
             pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),
                                  Qt.point(100,50),Qt.point(50,50),
                                  40, 40, 10, 10);
             tryCompare(pinchFinishedSpy, "count", 1);
-            compare(map.zoomLevel, 7)
+            endZoomLevel = calculateZoom( map.startPinchPoint1, map.startPinchPoint2,
+                                              map.endPinchPoint1, map.endPinchPoint2,
+                                              map.width,map.height,
+                                              map.gesture.maximumZoomLevelChange,startZoomLevel)
+            compare(map.zoomLevel, endZoomLevel)
+
             // 5. typical zoom out with different change level
             clear_data();
+            startZoomLevel = 8
             map.gesture.maximumZoomLevelChange = 1
+            map.zoomLevel = startZoomLevel
             compare (map.gesture.maximumZoomLevelChange, 1)
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
                                  Qt.point(50,50), Qt.point(100,50),
                                  40, 40, 10, 10);
             tryCompare(pinchFinishedSpy, "count", 1);
-            compare(map.zoomLevel, 7.5)
+            endZoomLevel = calculateZoom( map.startPinchPoint1, map.startPinchPoint2,
+                                              map.endPinchPoint1, map.endPinchPoint2,
+                                              map.width,map.height,
+                                              map.gesture.maximumZoomLevelChange,startZoomLevel)
+            compare(map.zoomLevel, endZoomLevel)
 
             // 6. try to zoom in below minimum zoom level
-            /*
+
             clear_data()
+            startZoomLevel = 8
             map.gesture.maximumZoomLevelChange = 4
-            map.gesture.minimumZoomLevel = 7
+            map.minimumZoomLevel = 7
             pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),Qt.point(100,50),Qt.point(50,50));
             wait(250);
             tryCompare(pinchFinishedSpy, "count", 1);
-            compare(map.zoomLevel, 7) // would go to 5.5
+            compare(map.zoomLevel, 7) // would go to 6
 
             // 7. try to zoom out above maximum zoom level
             clear_data()
             map.gesture.maximumZoomLevelChange = 4
-            map.gesture.maximumZoomLevel = 8
+            map.maximumZoomLevel = 8
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),Qt.point(50,50), Qt.point(100,50));
             tryCompare(pinchFinishedSpy, "count", 1);
             compare(map.zoomLevel, 8) // would go to 9
 
             // 8. pinch when max and min are same
             clear_data()
-            map.gesture.maximumZoomLevel = 8
-            map.gesture.minimumZoomLevel = 8
-            compare(map.gesture.maximumZoomLevel, 8)
-            compare(map.gesture.minimumZoomLevel, 8)
+            map.maximumZoomLevel = 8
+            map.minimumZoomLevel = 8
+            compare(map.maximumZoomLevel, 8)
+            compare(map.minimumZoomLevel, 8)
             pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),Qt.point(100,50),Qt.point(50,50));
             tryCompare(pinchFinishedSpy, "count", 1);
             compare(map.zoomLevel, 8)
+            map.minimumZoomLevel = 1
+            map.maximumZoomLevel = 20
 
             // 9. pinch when max..min is not where map zoomLevel currently is
             clear_data()
             map.gesture.maximumZoomLevelChange = 4
-            map.gesture.minimumZoomLevel = 4
-            map.gesture.maximumZoomLevel = 6
+            map.minimumZoomLevel = 4
+            map.maximumZoomLevel = 6
             // first when above the zoom range
-            map.zoomLevel = 10
-            pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),Qt.point(50,50), Qt.point(100,50)); // zoom out
+            map.zoomLevel = 5
+            pinchGenerator.pinch(Qt.point(50,50),Qt.point(0,50),Qt.point(50,50),Qt.point(100,50)); // zoom out
             tryCompare(pinchFinishedSpy, "count", 1);
             compare(map.zoomLevel, 6)
-            map.zoomLevel = 10
+            map.zoomLevel = 5
             pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),Qt.point(100,50),Qt.point(50,50)); // zoom in
             tryCompare(pinchFinishedSpy, "count", 2);
-            compare(map.zoomLevel, 6)
-            pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),Qt.point(100,50),Qt.point(50,50)); // zoom in
-            tryCompare(pinchFinishedSpy, "count", 3);
-            compare(map.zoomLevel, 4)
-            // when below the zoom range
-            map.zoomLevel = 1
-            pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),Qt.point(50,50), Qt.point(100,50)); // zoom out
-            tryCompare(pinchFinishedSpy, "count", 4);
             compare(map.zoomLevel, 4)
-            map.zoomLevel = 1
             pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),Qt.point(100,50),Qt.point(50,50)); // zoom in
-            tryCompare(pinchFinishedSpy, "count", 5);
+            tryCompare(pinchFinishedSpy, "count", 3);
             compare(map.zoomLevel, 4)
-            pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),Qt.point(50,50), Qt.point(100,50)); // zoom out
-            tryCompare(pinchFinishedSpy, "count", 6);
-            compare(map.zoomLevel, 6)
-            map.gesture.minimumZoomLevel = map.minimumZoomLevel
-            map.gesture.maximumZoomLevel = map.maximumZoomLevel
-            */
+            map.minimumZoomLevel = 1
+            map.maximumZoomLevel = 20
 
             // 10. pinch while pinch area is disabled
             clear_data()
+            map.zoomLevel = 7.5
             map.gesture.enabled = false
             map.gesture.maximumZoomLevelChange = 2
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
@@ -493,25 +543,36 @@ Item {
 
             // 11. pinch disabling during pinching
             clear_data()
+            startZoomLevel = 7.5
+            map.zoomLevel = startZoomLevel
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
                                  Qt.point(50,50), Qt.point(100,50),
                                  40, 40, 10, 10);
-            wait(300)
-            map.gesture.enabled = false
+            tryCompare(pinchStartedSpy, "count", 1);
             // check that pinch is active. then disable the pinch. pinch area should still process
             // as long as it is active
-            compare(pinchActiveSpy.count,1)
+            compare(pinchActiveSpy.count,2)
             compare(map.gesture.isPinchActive, true)
-            compare(pinchStartedSpy.count, 1)
-            compare(pinchFinishedSpy.count, 0)
+            map.gesture.enabled = false
+            tryCompare(pinchFinishedSpy, "count", 1)
             var pinchupdates = pinchUpdatedSpy.count
             verify(pinchupdates > 0)
-            tryCompare(pinchFinishedSpy, "count", 1)
-            compare(pinchActiveSpy.count,2)
+            compare(pinchActiveSpy.count,3)
             compare(map.gesture.isPinchActive, false)
+            endZoomLevel = calculateZoom( map.startPinchPoint1, map.startPinchPoint2,
+                                              map.endPinchPoint1, map.endPinchPoint2,
+                                              map.width,map.height,
+                                              map.gesture.maximumZoomLevelChange,startZoomLevel)
+            compare(map.zoomLevel, endZoomLevel)
+            pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
+                                 Qt.point(50,50), Qt.point(100,50),
+                                 40, 40, 10, 10);
+            compare(map.zoomLevel, endZoomLevel)
             map.gesture.enabled = true
+
             // 12. check nuthin happens if no active gestures
             clear_data()
+            map.zoomLevel = 8.5
             map.gesture.activeGestures = MapGestureArea.NoGesture
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
                                  Qt.point(50,50), Qt.point(100,50),
@@ -523,19 +584,27 @@ Item {
             compare(map.zoomLevel, 8.5)
             pinchGenerator.stop()
             map.gesture.activeGestures = MapGestureArea.ZoomGesture
+
             // 13. manually changing zoom level during active pinch zoom
             clear_data();
+            startZoomLevel = 8.5
+            map.zoomLevel = startZoomLevel
             map.gesture.maximumZoomLevelChange = 2
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
                                  Qt.point(50,50), Qt.point(100,50),
                                  40, 40, 10, 10);
             tryCompare(pinchStartedSpy, "count", 1);
-            tryCompare(pinchActiveSpy, "count", 1)
+            tryCompare(pinchActiveSpy, "count", 2)
             compare(map.gesture.isPinchActive, true)
             map.zoomLevel = 3 // will get overridden by pinch
             tryCompare(pinchFinishedSpy, "count", 1);
             verify(pinchUpdatedSpy.count >= 5); // verify 'sane' number of updates received
-            compare(map.zoomLevel, 9.5)
+            endZoomLevel = calculateZoom( map.startPinchPoint1, map.startPinchPoint2,
+                                          map.endPinchPoint1, map.endPinchPoint2,
+                                          map.width,map.height,
+                                          map.gesture.maximumZoomLevelChange,startZoomLevel)
+            compare(map.zoomLevel, endZoomLevel)
+
             // 14. try to zoom below and above plugin's support
             clear_data()
             map.gesture.maximumZoomLevelChange = 4
@@ -550,6 +619,7 @@ Item {
             tryCompare(pinchFinishedSpy, "count", 2);
             compare(map.zoomLevel, map.maximumZoomLevel)
             map.zoomLevel = 10
+
             // 15. check that pinch accepted works (rejection)
             clear_data()
             map.rejectPinch = true
@@ -561,12 +631,18 @@ Item {
             compare(pinchFinishedSpy.count, 0)
             compare(map.gesture.isPinchActive, false)
             compare(map.zoomLevel, 10)
+            startZoomLevel = 10
             map.rejectPinch = false
-            pinchGenerator.stop()
-            pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),Qt.point(100,50),Qt.point(50,50));
+            wait(500)
+            pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),Qt.point(100,50),Qt.point(50,50),40, 40, 10, 10);
             tryCompare(pinchFinishedSpy, "count",  1)
-            compare(map.zoomLevel, 8)
+            endZoomLevel = calculateZoom( map.startPinchPoint1, map.startPinchPoint2,
+                                              map.endPinchPoint1, map.endPinchPoint2,
+                                              map.width,map.height,
+                                              map.gesture.maximumZoomLevelChange,startZoomLevel)
+            compare(map.zoomLevel, endZoomLevel)
             compare(map.lastPinchEvent.accepted, true)
+
             // 16. moving center
             clear_data()
             pinchGenerator.pinch(Qt.point(0, 50), Qt.point(50,100), Qt.point(50,0), Qt.point(100, 50))
diff --git a/tests/plugins/declarativetestplugin/qdeclarativepinchgenerator.cpp b/tests/plugins/declarativetestplugin/qdeclarativepinchgenerator.cpp
index e1613cf7..98da18d0 100644
--- a/tests/plugins/declarativetestplugin/qdeclarativepinchgenerator.cpp
+++ b/tests/plugins/declarativetestplugin/qdeclarativepinchgenerator.cpp
@@ -36,6 +36,7 @@
 #include <QtTest/QtTest>
 #include <QtGui/QGuiApplication>
 #include <QtGui/qpa/qwindowsysteminterface.h>
+#include <QtGui/QStyleHints>
 
 QDeclarativePinchGenerator::QDeclarativePinchGenerator():
     target_(0),
@@ -331,7 +332,7 @@ void QDeclarativePinchGenerator::pinchRelease(QPoint point1To, QPoint point2To)
     QTest::touchEvent(window_, device_).release(0, point1To).release(1, point2To);
 }
 
-Q_INVOKABLE void QDeclarativePinchGenerator::replay()
+void QDeclarativePinchGenerator::replay()
 {
     if (state_ != Idle) {
         qDebug() << "Wrong state, will not replay pinch, state: " << state_;
@@ -354,7 +355,7 @@ Q_INVOKABLE void QDeclarativePinchGenerator::replay()
     setState(Replaying);
 }
 
-Q_INVOKABLE void QDeclarativePinchGenerator::clear()
+void QDeclarativePinchGenerator::clear()
 {
     stop();
     delete activeSwipe_;
@@ -365,7 +366,7 @@ Q_INVOKABLE void QDeclarativePinchGenerator::clear()
     }
 }
 
-Q_INVOKABLE void QDeclarativePinchGenerator::stop()
+void QDeclarativePinchGenerator::stop()
 {
     if (state_ != Replaying)
         return;
@@ -375,3 +376,8 @@ Q_INVOKABLE void QDeclarativePinchGenerator::stop()
     replayTimer_ = -1;
     setState(Idle);
 }
+
+int QDeclarativePinchGenerator::startDragDistance()
+{
+    return qApp->styleHints()->startDragDistance();
+}
diff --git a/tests/plugins/declarativetestplugin/qdeclarativepinchgenerator_p.h b/tests/plugins/declarativetestplugin/qdeclarativepinchgenerator_p.h
index 3bf785e0..b2a4e77c 100644
--- a/tests/plugins/declarativetestplugin/qdeclarativepinchgenerator_p.h
+++ b/tests/plugins/declarativetestplugin/qdeclarativepinchgenerator_p.h
@@ -76,6 +76,7 @@ public:
     Q_INVOKABLE void replay();
     Q_INVOKABLE void clear();
     Q_INVOKABLE void stop();
+    Q_INVOKABLE int startDragDistance();
 
     // programmatic interface, useful for autotests
     Q_INVOKABLE void pinch(QPoint point1From,