1 files changed, 199 insertions, 1 deletions
diff --git a/tests/auto/declarative_positioning_core/tst_positionsource.qml b/tests/auto/declarative_positioning_core/tst_positionsource.qml
index 7b787a0c..858ff699 100644
--- a/tests/auto/declarative_positioning_core/tst_positionsource.qml
+++ b/tests/auto/declarative_positioning_core/tst_positionsource.qml
@@ -121,7 +121,7 @@ TestCase {
     SignalSpy { id: directionValidSpyWParams; target: testingSourceWParams.position; signalName: "directionValidChanged" }
     SignalSpy { id: directionSpyWParams; target: testingSourceWParams.position; signalName: "directionChanged" }
 
-    PositionSource { id: testingSourceV1; name: "test.source.v1"; updateInterval: 1000 }
+    PositionSource { id: testingSourceV1; name: "test.source"; updateInterval: 1000 }
     SignalSpy { id: updateSpyV1; target: testingSourceV1; signalName: "positionChanged" }
     SignalSpy { id: directionValidSpyV1; target: testingSourceV1.position; signalName: "directionValidChanged" }
     SignalSpy { id: directionSpyV1; target: testingSourceV1.position; signalName: "directionChanged" }
@@ -224,4 +224,202 @@ TestCase {
         verify(testingSourceWParams.position.speedValid)
         verify(testingSourceWParams.position.speed > 10000)
     }
+
+    // tests for bindings
+    PositionSource {
+        id: testSourceForBindings
+        name: "test.source"
+    }
+
+    property var positionObserver: testSourceForBindings.position
+    SignalSpy {
+        id: positionObserverSpy; target: testSourceForBindings; signalName: "positionChanged"
+    }
+
+    property bool activeObserver: testSourceForBindings.active
+    SignalSpy {
+        id: activeObserverSpy; target: testSourceForBindings; signalName: "activeChanged"
+    }
+
+    property bool validObserver: testSourceForBindings.valid
+    SignalSpy {
+        id: validObserverSpy; target: testSourceForBindings; signalName: "validityChanged"
+    }
+
+    property int updateIntervalObserver: testSourceForBindings.updateInterval
+    SignalSpy {
+        id: updateIntervalObserverSpy; target: testSourceForBindings; signalName: "updateIntervalChanged"
+    }
+
+    property int supportedMethodsObserver: testSourceForBindings.supportedPositioningMethods
+    SignalSpy {
+        id: supportedMethodsObserverSpy; target: testSourceForBindings; signalName: "supportedPositioningMethodsChanged"
+    }
+
+    property int preferredMethodsObserver: testSourceForBindings.preferredPositioningMethods
+    SignalSpy {
+        id: preferredMethodsObserverSpy;
+        target: testSourceForBindings;
+        signalName: "preferredPositioningMethodsChanged"
+    }
+
+    property int errorObserver: testSourceForBindings.sourceError
+    SignalSpy {
+        id: errorObserverSpy; target: testSourceForBindings; signalName: "sourceErrorChanged"
+    }
+
+    property string nameObserver: testSourceForBindings.name
+    SignalSpy {
+        id: nameObserverSpy; target: testSourceForBindings; signalName: "nameChanged"
+    }
+
+    function test_bindingsToPositionSource() {
+        positionObserverSpy.clear()
+        activeObserverSpy.clear()
+        validObserverSpy.clear()
+        updateIntervalObserverSpy.clear()
+        supportedMethodsObserverSpy.clear()
+        preferredMethodsObserverSpy.clear()
+        errorObserverSpy.clear()
+        nameObserverSpy.clear()
+
+        verify(testSourceForBindings.valid)
+        compare(testSourceForBindings.supportedPositioningMethods, PositionSource.AllPositioningMethods)
+
+        testSourceForBindings.preferredPositioningMethods = PositionSource.SatellitePositioningMethods
+        compare(preferredMethodsObserver, PositionSource.SatellitePositioningMethods)
+        compare(preferredMethodsObserverSpy.count, 1)
+
+        testSourceForBindings.updateInterval = 1100;
+        compare(updateIntervalObserver, 1100)
+        compare(updateIntervalObserverSpy.count, 1)
+
+        testSourceForBindings.start();
+        compare(activeObserver, true)
+        compare(activeObserverSpy.count, 1)
+
+        tryCompare(positionObserverSpy, "count", 1, 1500);
+        verify(testSourceForBindings.position.coordinate !== QtPositioning.coordinate())
+
+        testSourceForBindings.update(100) // small timeout will result in an error
+        tryCompare(errorObserverSpy, "count", 1, 200)
+        compare(errorObserver, PositionSource.UpdateTimeoutError)
+
+        var newSourceName = "some invalid name"
+        testSourceForBindings.name = newSourceName
+
+        compare(validObserver, false)
+        compare(validObserverSpy.count, 1)
+
+        compare(nameObserver, newSourceName)
+        compare(nameObserverSpy.count, 1)
+
+        compare(supportedMethodsObserver, PositionSource.NoPositioningMethods)
+        compare(supportedMethodsObserverSpy.count, 1)
+    }
+
+    property bool activeSetter: false
+    property string nameSetter: "test.source"
+    property int updateIntervalSetter: 1000
+    property int preferredMethodsSetter: PositionSource.NonSatellitePositioningMethods
+
+    PositionSource {
+        id: sourceWithBindings
+        name: nameSetter
+        active: activeSetter
+        updateInterval: updateIntervalSetter
+        preferredPositioningMethods: preferredMethodsSetter
+    }
+
+    function test_bindPositionSourceProperties() {
+        compare(sourceWithBindings.name, "test.source")
+        compare(sourceWithBindings.active, false)
+        compare(sourceWithBindings.updateInterval, 1000)
+        compare(sourceWithBindings.preferredPositioningMethods, PositionSource.NonSatellitePositioningMethods)
+
+        updateIntervalSetter = 1100;
+        preferredMethodsSetter = PositionSource.AllPositioningMethods
+        activeSetter = true
+
+        wait(0) // to trigger event processing
+
+        compare(sourceWithBindings.active, true)
+        compare(sourceWithBindings.updateInterval, 1100)
+        compare(sourceWithBindings.preferredPositioningMethods, PositionSource.AllPositioningMethods)
+
+        activeSetter = false;
+
+        compare(sourceWithBindings.active, false)
+
+        // check how call to update() effects the binding
+        sourceWithBindings.update(updateIntervalSetter)
+        compare(sourceWithBindings.active, true)
+
+        wait(1500)
+        compare(sourceWithBindings.active, false)
+
+        activeSetter = true;
+        wait(0) // to trigger event processing
+        // the binding is *not* broken by calling update()
+        compare(sourceWithBindings.active, true)
+    }
+
+    function test_updateIntervalBindings() {
+        var updateIntervalSpy = Qt.createQmlObject('import QtTest; SignalSpy { }', testCase)
+        updateIntervalSpy.target = sourceWithBindings
+        updateIntervalSpy.signalName = "updateIntervalChanged"
+        verify(updateIntervalSpy.valid)
+
+        nameSetter = "invalid name"
+        updateIntervalSetter = 800;
+        compare(sourceWithBindings.updateInterval, 800)
+        compare(updateIntervalSpy.count, 1)
+
+        nameSetter = "test.source"
+        // "test.source" has a minimum update interval of 1000
+        compare(sourceWithBindings.updateInterval, 1000)
+        compare(updateIntervalSpy.count, 2)
+
+        nameSetter = "dummy.source"
+        // "dummy.source" has a minimum udpate interval of 100, so we expect
+        // the updateInterval to be set to 800
+        compare(sourceWithBindings.updateInterval, 800)
+        compare(updateIntervalSpy.count, 3)
+
+        // The binding still works
+        updateIntervalSetter = 1100
+        compare(sourceWithBindings.updateInterval, 1100)
+        compare(updateIntervalSpy.count, 4)
+    }
+
+    function test_preferredPositioningMethodsBindings() {
+        var preferredMethodsSpy = Qt.createQmlObject('import QtTest; SignalSpy { }', testCase)
+        preferredMethodsSpy.target = sourceWithBindings
+        preferredMethodsSpy.signalName = "preferredPositioningMethodsChanged"
+        verify(preferredMethodsSpy.valid)
+
+        nameSetter = "invalid name"
+        preferredMethodsSetter = PositionSource.SatellitePositioningMethods
+        compare(sourceWithBindings.preferredPositioningMethods, PositionSource.SatellitePositioningMethods)
+        compare(preferredMethodsSpy.count, 1)
+
+        nameSetter = "dummy.source"
+        // "dummy.source" has only NonSatellitePositioningMethods, so we expect
+        // the value to be set to NonSatellitePositioningMethods (see
+        // QGeoPositionInfoSource::setPreferredPositioningMethods for details)
+        compare(sourceWithBindings.preferredPositioningMethods, PositionSource.NonSatellitePositioningMethods)
+        compare(preferredMethodsSpy.count, 2)
+
+        nameSetter = "test.source"
+        // "test.source" has all positioning methods, so we expect the value to
+        // be set to the desired SatellitePositioningMethods
+        compare(sourceWithBindings.preferredPositioningMethods, PositionSource.SatellitePositioningMethods)
+        compare(preferredMethodsSpy.count, 3)
+
+        // The binding still works
+        preferredMethodsSetter = PositionSource.AllPositioningMethods
+        compare(sourceWithBindings.preferredPositioningMethods, PositionSource.AllPositioningMethods)
+        compare(preferredMethodsSpy.count, 4)
+    }
+
 }