summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorIvan Solovev <ivan.solovev@qt.io>2021-04-08 18:31:29 +0200
committerIvan Solovev <ivan.solovev@qt.io>2021-04-27 11:10:56 +0200
commit4258f337f5c550c86256e4f5494a2bb9f7eedf0f (patch)
tree78178cec3d4d4c3a7e125484c19a38b44d61139e
parentd0e4e0c47c98634bade7025567e25c12ff578c67 (diff)
downloadqtlocation-4258f337f5c550c86256e4f5494a2bb9f7eedf0f.tar.gz
QDeclarativePosition: add property bindings
Signals of QDeclarativePosition class are removed because they were only needed for QML. With the new bindable properties we do not need them any more. [ChangeLog][QtPositioning][Position] horizontalAccuracy and verticalAccuracy properties are no longer writable. This is done to align with the other properties of the class, which are read-only. There is no real usecase for making them writable. Task-number: QTBUG-89874 Change-Id: I9d14ce8c558c7b50d1e1dd8a46a599cdd4811f5b Reviewed-by: Sona Kurazyan <sona.kurazyan@qt.io> Reviewed-by: Alex Blasche <alexander.blasche@qt.io>
-rw-r--r--src/positioningquick/qdeclarativeposition.cpp305
-rw-r--r--src/positioningquick/qdeclarativeposition_p.h139
-rw-r--r--tests/auto/CMakeLists.txt1
-rw-r--r--tests/auto/declarative_positioning_core/tst_position.qml47
-rw-r--r--tests/auto/declarative_positioning_core/tst_positionsource.qml66
-rw-r--r--tests/auto/qdeclarativeposition/CMakeLists.txt8
-rw-r--r--tests/auto/qdeclarativeposition/tst_qdeclarativeposition.cpp225
7 files changed, 599 insertions, 192 deletions
diff --git a/src/positioningquick/qdeclarativeposition.cpp b/src/positioningquick/qdeclarativeposition.cpp
index b63aaab8..5b659666 100644
--- a/src/positioningquick/qdeclarativeposition.cpp
+++ b/src/positioningquick/qdeclarativeposition.cpp
@@ -111,88 +111,97 @@ void QDeclarativePosition::setPosition(const QGeoPositionInfo &info)
// timestamp
const QDateTime pTimestamp = m_info.timestamp();
const QDateTime timestamp = info.timestamp();
- bool emitTimestampChanged = pTimestamp != timestamp;
+ const bool timestampChanged = pTimestamp != timestamp;
// coordinate
const QGeoCoordinate pCoordinate = m_info.coordinate();
const QGeoCoordinate coordinate = info.coordinate();
- bool emitCoordinateChanged = pCoordinate != coordinate;
- bool emitLatitudeValidChanged = exclusiveNaN(pCoordinate.latitude(), coordinate.latitude());
- bool emitLongitudeValidChanged = exclusiveNaN(pCoordinate.longitude(), coordinate.longitude());
- bool emitAltitudeValidChanged = exclusiveNaN(pCoordinate.altitude(), coordinate.altitude());
+ const bool coordinateChanged = pCoordinate != coordinate;
+ const bool latitudeValidChanged = exclusiveNaN(pCoordinate.latitude(), coordinate.latitude());
+ const bool longitudeValidChanged =
+ exclusiveNaN(pCoordinate.longitude(), coordinate.longitude());
+ const bool altitudeValidChanged = exclusiveNaN(pCoordinate.altitude(), coordinate.altitude());
// direction
const qreal pDirection = m_info.attribute(QGeoPositionInfo::Direction);
const qreal direction = info.attribute(QGeoPositionInfo::Direction);
- bool emitDirectionChanged = !equalOrNaN(pDirection, direction);
- bool emitDirectionValidChanged = exclusiveNaN(pDirection, direction);
+ const bool directionChanged = !equalOrNaN(pDirection, direction);
+ const bool directionValidChanged = exclusiveNaN(pDirection, direction);
// ground speed
const qreal pSpeed = m_info.attribute(QGeoPositionInfo::GroundSpeed);
const qreal speed = info.attribute(QGeoPositionInfo::GroundSpeed);
- bool emitSpeedChanged = !equalOrNaN(pSpeed, speed);
- bool emitSpeedValidChanged = exclusiveNaN(pSpeed, speed);
+ const bool speedChanged = !equalOrNaN(pSpeed, speed);
+ const bool speedValidChanged = exclusiveNaN(pSpeed, speed);
// vertical speed
const qreal pVerticalSpeed = m_info.attribute(QGeoPositionInfo::VerticalSpeed);
const qreal verticalSpeed = info.attribute(QGeoPositionInfo::VerticalSpeed);
- bool emitVerticalSpeedChanged = !equalOrNaN(pVerticalSpeed, verticalSpeed);
- bool emitVerticalSpeedValidChanged = exclusiveNaN(pVerticalSpeed, verticalSpeed);
+ const bool verticalSpeedChanged = !equalOrNaN(pVerticalSpeed, verticalSpeed);
+ const bool verticalSpeedValidChanged = exclusiveNaN(pVerticalSpeed, verticalSpeed);
// magnetic variation
const qreal pMagneticVariation = m_info.attribute(QGeoPositionInfo::MagneticVariation);
const qreal magneticVariation = info.attribute(QGeoPositionInfo::MagneticVariation);
- bool emitMagneticVariationChanged = !equalOrNaN(pMagneticVariation, magneticVariation);
- bool emitMagneticVariationValidChanged = exclusiveNaN(pMagneticVariation, magneticVariation);
+ const bool magneticVariationChanged = !equalOrNaN(pMagneticVariation, magneticVariation);
+ const bool magneticVariationValidChanged = exclusiveNaN(pMagneticVariation, magneticVariation);
// horizontal accuracy
const qreal pHorizontalAccuracy = m_info.attribute(QGeoPositionInfo::HorizontalAccuracy);
const qreal horizontalAccuracy = info.attribute(QGeoPositionInfo::HorizontalAccuracy);
- bool emitHorizontalAccuracyChanged = !equalOrNaN(pHorizontalAccuracy, horizontalAccuracy);
- bool emitHorizontalAccuracyValidChanged = exclusiveNaN(pHorizontalAccuracy, horizontalAccuracy);
+ const bool horizontalAccuracyChanged = !equalOrNaN(pHorizontalAccuracy, horizontalAccuracy);
+ const bool horizontalAccuracyValidChanged =
+ exclusiveNaN(pHorizontalAccuracy, horizontalAccuracy);
// vertical accuracy
const qreal pVerticalAccuracy = m_info.attribute(QGeoPositionInfo::VerticalAccuracy);
const qreal verticalAccuracy = info.attribute(QGeoPositionInfo::VerticalAccuracy);
- bool emitVerticalAccuracyChanged = !equalOrNaN(pVerticalAccuracy, verticalAccuracy);
- bool emitVerticalAccuracyValidChanged = exclusiveNaN(pVerticalAccuracy, verticalAccuracy);
+ const bool verticalAccuracyChanged = !equalOrNaN(pVerticalAccuracy, verticalAccuracy);
+ const bool verticalAccuracyValidChanged = exclusiveNaN(pVerticalAccuracy, verticalAccuracy);
m_info = info;
- if (emitTimestampChanged)
- emit timestampChanged();
- if (emitCoordinateChanged)
- emit coordinateChanged();
- if (emitLatitudeValidChanged)
- emit latitudeValidChanged();
- if (emitLongitudeValidChanged)
- emit longitudeValidChanged();
- if (emitAltitudeValidChanged)
- emit altitudeValidChanged();
- if (emitDirectionChanged)
- emit directionChanged();
- if (emitDirectionValidChanged)
- emit directionValidChanged();
- if (emitSpeedChanged)
- emit speedChanged();
- if (emitSpeedValidChanged)
- emit speedValidChanged();
- if (emitVerticalSpeedChanged)
- emit verticalSpeedChanged();
- if (emitVerticalSpeedValidChanged)
- emit verticalSpeedValidChanged();
- if (emitHorizontalAccuracyChanged)
- emit horizontalAccuracyChanged();
- if (emitHorizontalAccuracyValidChanged)
- emit horizontalAccuracyValidChanged();
- if (emitVerticalAccuracyChanged)
- emit verticalAccuracyChanged();
- if (emitVerticalAccuracyValidChanged)
- emit verticalAccuracyValidChanged();
- if (emitMagneticVariationChanged)
- emit magneticVariationChanged();
- if (emitMagneticVariationValidChanged)
- emit magneticVariationValidChanged();
+ if (timestampChanged)
+ m_computedTimestamp.notify();
+
+ if (coordinateChanged)
+ m_computedCoordinate.notify();
+ if (latitudeValidChanged)
+ m_computedLatitudeValid.notify();
+ if (longitudeValidChanged)
+ m_computedLongitudeValid.notify();
+ if (altitudeValidChanged)
+ m_computedAltitudeValid.notify();
+
+ if (directionChanged)
+ m_computedDirection.notify();
+ if (directionValidChanged)
+ m_computedDirectionValid.notify();
+
+ if (speedChanged)
+ m_computedSpeed.notify();
+ if (speedValidChanged)
+ m_computedSpeedValid.notify();
+
+ if (verticalSpeedChanged)
+ m_computedVerticalSpeed.notify();
+ if (verticalSpeedValidChanged)
+ m_computedVerticalSpeedValid.notify();
+
+ if (horizontalAccuracyChanged)
+ m_computedHorizontalAccuracy.notify();
+ if (horizontalAccuracyValidChanged)
+ m_computedHorizontalAccuracyValid.notify();
+
+ if (verticalAccuracyChanged)
+ m_computedVerticalAccuracy.notify();
+ if (verticalAccuracyValidChanged)
+ m_computedVerticalAccuracyValid.notify();
+
+ if (magneticVariationChanged)
+ m_computedMagneticVariation.notify();
+ if (magneticVariationValidChanged)
+ m_computedMagneticVariationValid.notify();
}
const QGeoPositionInfo &QDeclarativePosition::position() const
@@ -200,6 +209,91 @@ const QGeoPositionInfo &QDeclarativePosition::position() const
return m_info;
}
+QBindable<bool> QDeclarativePosition::bindableLatitudeValid() const
+{
+ return QBindable<bool>(&m_computedLatitudeValid);
+}
+
+QBindable<bool> QDeclarativePosition::bindableLongitudeValid() const
+{
+ return QBindable<bool>(&m_computedLongitudeValid);
+}
+
+QBindable<bool> QDeclarativePosition::bindableAltitudeValid() const
+{
+ return QBindable<bool>(&m_computedAltitudeValid);
+}
+
+QBindable<QGeoCoordinate> QDeclarativePosition::bindableCoordinate() const
+{
+ return QBindable<QGeoCoordinate>(&m_computedCoordinate);
+}
+
+QBindable<QDateTime> QDeclarativePosition::bindableTimestamp() const
+{
+ return QBindable<QDateTime>(&m_computedTimestamp);
+}
+
+QBindable<double> QDeclarativePosition::bindableSpeed() const
+{
+ return QBindable<double>(&m_computedSpeed);
+}
+
+QBindable<bool> QDeclarativePosition::bindableSpeedValid() const
+{
+ return QBindable<bool>(&m_computedSpeedValid);
+}
+
+QBindable<qreal> QDeclarativePosition::bindableHorizontalAccuracy() const
+{
+ return QBindable<qreal>(&m_computedHorizontalAccuracy);
+}
+
+QBindable<qreal> QDeclarativePosition::binableVerticalAccuracy() const
+{
+ return QBindable<qreal>(&m_computedVerticalAccuracy);
+}
+
+QBindable<bool> QDeclarativePosition::bindableHorizontalAccuracyValid() const
+{
+ return QBindable<bool>(&m_computedHorizontalAccuracyValid);
+}
+
+QBindable<bool> QDeclarativePosition::bindableVerticalAccuracyValid() const
+{
+ return QBindable<bool>(&m_computedVerticalAccuracyValid);
+}
+
+QBindable<bool> QDeclarativePosition::bindableDirectionValid() const
+{
+ return QBindable<bool>(&m_computedDirectionValid);
+}
+
+QBindable<double> QDeclarativePosition::bindableDirection() const
+{
+ return QBindable<double>(&m_computedDirection);
+}
+
+QBindable<bool> QDeclarativePosition::bindableVerticalSpeedValid() const
+{
+ return QBindable<bool>(&m_computedVerticalSpeedValid);
+}
+
+QBindable<double> QDeclarativePosition::bindableVerticalSpeed() const
+{
+ return QBindable<double>(&m_computedVerticalSpeed);
+}
+
+QBindable<double> QDeclarativePosition::bindableMagneticVariation() const
+{
+ return QBindable<double>(&m_computedMagneticVariation);
+}
+
+QBindable<bool> QDeclarativePosition::bindableMagneticVariationValid() const
+{
+ return QBindable<bool>(&m_computedMagneticVariationValid);
+}
+
/*!
\qmlproperty coordinate Position::coordinate
@@ -211,6 +305,11 @@ const QGeoPositionInfo &QDeclarativePosition::position() const
*/
QGeoCoordinate QDeclarativePosition::coordinate()
{
+ return m_computedCoordinate.value();
+}
+
+QGeoCoordinate QDeclarativePosition::coordinateActualCalculation() const
+{
return m_info.coordinate();
}
@@ -225,9 +324,13 @@ QGeoCoordinate QDeclarativePosition::coordinate()
*/
bool QDeclarativePosition::isLatitudeValid() const
{
- return !qIsNaN(m_info.coordinate().latitude());
+ return m_computedLatitudeValid.value();
}
+bool QDeclarativePosition::isLatitudeValidActualCalculation() const
+{
+ return !qIsNaN(m_info.coordinate().latitude());
+}
/*!
\qmlproperty bool Position::longitudeValid
@@ -240,9 +343,13 @@ bool QDeclarativePosition::isLatitudeValid() const
*/
bool QDeclarativePosition::isLongitudeValid() const
{
- return !qIsNaN(m_info.coordinate().longitude());
+ return m_computedLongitudeValid.value();
}
+bool QDeclarativePosition::isLongitudeValidActualCalculation() const
+{
+ return !qIsNaN(m_info.coordinate().longitude());
+}
/*!
\qmlproperty bool Position::speedValid
@@ -255,6 +362,11 @@ bool QDeclarativePosition::isLongitudeValid() const
*/
bool QDeclarativePosition::isSpeedValid() const
{
+ return m_computedSpeedValid.value();
+}
+
+bool QDeclarativePosition::isSpeedValidActualCalculation() const
+{
return !qIsNaN(m_info.attribute(QGeoPositionInfo::GroundSpeed));
}
@@ -269,6 +381,11 @@ bool QDeclarativePosition::isSpeedValid() const
*/
bool QDeclarativePosition::isAltitudeValid() const
{
+ return m_computedAltitudeValid.value();
+}
+
+bool QDeclarativePosition::isAltitudeValidActualCalculation() const
+{
return !qIsNaN(m_info.coordinate().altitude());
}
@@ -283,6 +400,11 @@ bool QDeclarativePosition::isAltitudeValid() const
*/
double QDeclarativePosition::speed() const
{
+ return m_computedSpeed.value();
+}
+
+double QDeclarativePosition::speedActualCalculation() const
+{
return m_info.attribute(QGeoPositionInfo::GroundSpeed);
}
@@ -293,22 +415,12 @@ double QDeclarativePosition::speed() const
\sa horizontalAccuracyValid, coordinate
*/
-void QDeclarativePosition::setHorizontalAccuracy(qreal horizontalAccuracy)
+qreal QDeclarativePosition::horizontalAccuracy() const
{
- const qreal pHorizontalAccuracy = m_info.attribute(QGeoPositionInfo::HorizontalAccuracy);
-
- if (equalOrNaN(pHorizontalAccuracy, horizontalAccuracy))
- return;
-
- bool validChanged = exclusiveNaN(pHorizontalAccuracy, horizontalAccuracy);
-
- m_info.setAttribute(QGeoPositionInfo::HorizontalAccuracy, horizontalAccuracy);
- emit horizontalAccuracyChanged();
- if (validChanged)
- emit horizontalAccuracyValidChanged();
+ return m_computedHorizontalAccuracy.value();
}
-qreal QDeclarativePosition::horizontalAccuracy() const
+qreal QDeclarativePosition::horizontalAccuracyActualCalculation() const
{
return m_info.attribute(QGeoPositionInfo::HorizontalAccuracy);
}
@@ -324,6 +436,11 @@ qreal QDeclarativePosition::horizontalAccuracy() const
*/
bool QDeclarativePosition::isHorizontalAccuracyValid() const
{
+ return m_computedHorizontalAccuracyValid.value();
+}
+
+bool QDeclarativePosition::isHorizontalAccuracyValidActualCalculation() const
+{
return !qIsNaN(m_info.attribute(QGeoPositionInfo::HorizontalAccuracy));
}
@@ -334,22 +451,12 @@ bool QDeclarativePosition::isHorizontalAccuracyValid() const
\sa verticalAccuracyValid, coordinate
*/
-void QDeclarativePosition::setVerticalAccuracy(qreal verticalAccuracy)
+qreal QDeclarativePosition::verticalAccuracy() const
{
- const qreal pVerticalAccuracy = m_info.attribute(QGeoPositionInfo::VerticalAccuracy);
-
- if (equalOrNaN(pVerticalAccuracy, verticalAccuracy))
- return;
-
- bool validChanged = exclusiveNaN(pVerticalAccuracy, verticalAccuracy);
-
- m_info.setAttribute(QGeoPositionInfo::VerticalAccuracy, verticalAccuracy);
- emit verticalAccuracyChanged();
- if (validChanged)
- emit verticalAccuracyValidChanged();
+ return m_computedVerticalAccuracy.value();
}
-qreal QDeclarativePosition::verticalAccuracy() const
+qreal QDeclarativePosition::verticalAccuracyActualCalculation() const
{
return m_info.attribute(QGeoPositionInfo::VerticalAccuracy);
}
@@ -365,6 +472,11 @@ qreal QDeclarativePosition::verticalAccuracy() const
*/
bool QDeclarativePosition::isVerticalAccuracyValid() const
{
+ return m_computedVerticalAccuracyValid.value();
+}
+
+bool QDeclarativePosition::isVerticalAccuracyValidActualCalculation() const
+{
return !qIsNaN(m_info.attribute(QGeoPositionInfo::VerticalAccuracy));
}
@@ -378,6 +490,11 @@ bool QDeclarativePosition::isVerticalAccuracyValid() const
*/
QDateTime QDeclarativePosition::timestamp() const
{
+ return m_computedTimestamp.value();
+}
+
+QDateTime QDeclarativePosition::timestampActualCalculation() const
+{
return m_info.timestamp();
}
@@ -392,6 +509,11 @@ QDateTime QDeclarativePosition::timestamp() const
*/
bool QDeclarativePosition::isDirectionValid() const
{
+ return m_computedDirectionValid.value();
+}
+
+bool QDeclarativePosition::isDirectionValidActualCalculation() const
+{
return !qIsNaN(m_info.attribute(QGeoPositionInfo::Direction));
}
@@ -407,6 +529,11 @@ bool QDeclarativePosition::isDirectionValid() const
*/
double QDeclarativePosition::direction() const
{
+ return m_computedDirection.value();
+}
+
+double QDeclarativePosition::directionActualCalculation() const
+{
return m_info.attribute(QGeoPositionInfo::Direction);
}
@@ -421,6 +548,11 @@ double QDeclarativePosition::direction() const
*/
bool QDeclarativePosition::isVerticalSpeedValid() const
{
+ return m_computedVerticalSpeedValid.value();
+}
+
+bool QDeclarativePosition::isVerticalSpeedValidActualCalculation() const
+{
return !qIsNaN(m_info.attribute(QGeoPositionInfo::VerticalSpeed));
}
@@ -436,6 +568,11 @@ bool QDeclarativePosition::isVerticalSpeedValid() const
*/
double QDeclarativePosition::verticalSpeed() const
{
+ return m_computedVerticalSpeed.value();
+}
+
+double QDeclarativePosition::verticalSpeedActualCalculation() const
+{
return m_info.attribute(QGeoPositionInfo::VerticalSpeed);
}
@@ -450,6 +587,11 @@ double QDeclarativePosition::verticalSpeed() const
*/
bool QDeclarativePosition::isMagneticVariationValid() const
{
+ return m_computedMagneticVariationValid.value();
+}
+
+bool QDeclarativePosition::isMagneticVariationValidActualCalculation() const
+{
return !qIsNaN(m_info.attribute(QGeoPositionInfo::MagneticVariation));
}
@@ -468,6 +610,11 @@ bool QDeclarativePosition::isMagneticVariationValid() const
*/
double QDeclarativePosition::magneticVariation() const
{
+ return m_computedMagneticVariation.value();
+}
+
+double QDeclarativePosition::magneticVariationActualCalculation() const
+{
return m_info.attribute(QGeoPositionInfo::MagneticVariation);
}
diff --git a/src/positioningquick/qdeclarativeposition_p.h b/src/positioningquick/qdeclarativeposition_p.h
index 7556e6b9..f597a091 100644
--- a/src/positioningquick/qdeclarativeposition_p.h
+++ b/src/positioningquick/qdeclarativeposition_p.h
@@ -67,25 +67,32 @@ class Q_POSITIONINGQUICK_PRIVATE_EXPORT QDeclarativePosition : public QObject
QML_NAMED_ELEMENT(Position)
QML_ADDED_IN_VERSION(5, 0)
- Q_PROPERTY(bool latitudeValid READ isLatitudeValid NOTIFY latitudeValidChanged)
- Q_PROPERTY(bool longitudeValid READ isLongitudeValid NOTIFY longitudeValidChanged)
- Q_PROPERTY(bool altitudeValid READ isAltitudeValid NOTIFY altitudeValidChanged)
- Q_PROPERTY(QGeoCoordinate coordinate READ coordinate NOTIFY coordinateChanged)
- Q_PROPERTY(QDateTime timestamp READ timestamp NOTIFY timestampChanged)
- Q_PROPERTY(double speed READ speed NOTIFY speedChanged)
- Q_PROPERTY(bool speedValid READ isSpeedValid NOTIFY speedValidChanged)
- Q_PROPERTY(qreal horizontalAccuracy READ horizontalAccuracy WRITE setHorizontalAccuracy NOTIFY horizontalAccuracyChanged)
- Q_PROPERTY(qreal verticalAccuracy READ verticalAccuracy WRITE setVerticalAccuracy NOTIFY verticalAccuracyChanged)
- Q_PROPERTY(bool horizontalAccuracyValid READ isHorizontalAccuracyValid NOTIFY horizontalAccuracyValidChanged)
- Q_PROPERTY(bool verticalAccuracyValid READ isVerticalAccuracyValid NOTIFY verticalAccuracyValidChanged)
-
- Q_PROPERTY(bool directionValid READ isDirectionValid NOTIFY directionValidChanged REVISION(5, 1))
- Q_PROPERTY(double direction READ direction NOTIFY directionChanged REVISION(5, 1))
- Q_PROPERTY(bool verticalSpeedValid READ isVerticalSpeedValid NOTIFY verticalSpeedValidChanged REVISION(5, 1))
- Q_PROPERTY(double verticalSpeed READ verticalSpeed NOTIFY verticalSpeedChanged REVISION(5, 1))
-
- Q_PROPERTY(double magneticVariation READ magneticVariation NOTIFY magneticVariationChanged REVISION(5, 2))
- Q_PROPERTY(bool magneticVariationValid READ isMagneticVariationValid NOTIFY magneticVariationChanged REVISION(5, 2))
+ Q_PROPERTY(bool latitudeValid READ isLatitudeValid BINDABLE bindableLatitudeValid)
+ Q_PROPERTY(bool longitudeValid READ isLongitudeValid BINDABLE bindableLongitudeValid)
+ Q_PROPERTY(bool altitudeValid READ isAltitudeValid BINDABLE bindableAltitudeValid)
+ Q_PROPERTY(QGeoCoordinate coordinate READ coordinate BINDABLE bindableCoordinate)
+ Q_PROPERTY(QDateTime timestamp READ timestamp BINDABLE bindableTimestamp)
+ Q_PROPERTY(double speed READ speed BINDABLE bindableSpeed)
+ Q_PROPERTY(bool speedValid READ isSpeedValid BINDABLE bindableSpeedValid)
+ Q_PROPERTY(qreal horizontalAccuracy READ horizontalAccuracy BINDABLE bindableHorizontalAccuracy)
+ Q_PROPERTY(qreal verticalAccuracy READ verticalAccuracy BINDABLE binableVerticalAccuracy)
+ Q_PROPERTY(bool horizontalAccuracyValid READ isHorizontalAccuracyValid BINDABLE
+ bindableHorizontalAccuracyValid)
+ Q_PROPERTY(bool verticalAccuracyValid READ isVerticalAccuracyValid BINDABLE
+ bindableVerticalAccuracyValid)
+
+ Q_PROPERTY(bool directionValid READ isDirectionValid BINDABLE bindableDirectionValid
+ REVISION(5, 1))
+ Q_PROPERTY(double direction READ direction BINDABLE bindableDirection REVISION(5, 1))
+ Q_PROPERTY(bool verticalSpeedValid READ isVerticalSpeedValid BINDABLE bindableVerticalSpeedValid
+ REVISION(5, 1))
+ Q_PROPERTY(double verticalSpeed READ verticalSpeed BINDABLE bindableVerticalSpeed
+ REVISION(5, 1))
+
+ Q_PROPERTY(double magneticVariation READ magneticVariation BINDABLE bindableMagneticVariation
+ REVISION(5, 2))
+ Q_PROPERTY(bool magneticVariationValid READ isMagneticVariationValid BINDABLE
+ bindableMagneticVariationValid REVISION(5, 2))
public:
explicit QDeclarativePosition(QObject *parent = 0);
@@ -100,18 +107,14 @@ public:
QGeoCoordinate coordinate();
bool isHorizontalAccuracyValid() const;
qreal horizontalAccuracy() const;
- void setHorizontalAccuracy(qreal horizontalAccuracy);
bool isVerticalAccuracyValid() const;
qreal verticalAccuracy() const;
- void setVerticalAccuracy(qreal verticalAccuracy);
bool isDirectionValid() const;
double direction() const;
- void setDirection(double direction);
bool isVerticalSpeedValid() const;
double verticalSpeed() const;
- void setVerticalSpeed(double speed);
bool isMagneticVariationValid() const;
double magneticVariation() const;
@@ -119,29 +122,79 @@ public:
void setPosition(const QGeoPositionInfo &info);
const QGeoPositionInfo &position() const;
-Q_SIGNALS:
- void latitudeValidChanged();
- void longitudeValidChanged();
- void altitudeValidChanged();
- void timestampChanged();
- void speedChanged();
- void speedValidChanged();
- void coordinateChanged();
- void horizontalAccuracyChanged();
- void horizontalAccuracyValidChanged();
- void verticalAccuracyChanged();
- void verticalAccuracyValidChanged();
-
- Q_REVISION(5, 1) void directionValidChanged();
- Q_REVISION(5, 1) void directionChanged();
- Q_REVISION(5, 1) void verticalSpeedValidChanged();
- Q_REVISION(5, 1) void verticalSpeedChanged();
-
- Q_REVISION(5, 2) void magneticVariationChanged();
- Q_REVISION(5, 2) void magneticVariationValidChanged();
+ QBindable<bool> bindableLatitudeValid() const;
+ QBindable<bool> bindableLongitudeValid() const;
+ QBindable<bool> bindableAltitudeValid() const;
+ QBindable<QGeoCoordinate> bindableCoordinate() const;
+ QBindable<QDateTime> bindableTimestamp() const;
+ QBindable<double> bindableSpeed() const;
+ QBindable<bool> bindableSpeedValid() const;
+ QBindable<qreal> bindableHorizontalAccuracy() const;
+ QBindable<qreal> binableVerticalAccuracy() const;
+ QBindable<bool> bindableHorizontalAccuracyValid() const;
+ QBindable<bool> bindableVerticalAccuracyValid() const;
+ QBindable<bool> bindableDirectionValid() const;
+ QBindable<double> bindableDirection() const;
+ QBindable<bool> bindableVerticalSpeedValid() const;
+ QBindable<double> bindableVerticalSpeed() const;
+ QBindable<double> bindableMagneticVariation() const;
+ QBindable<bool> bindableMagneticVariationValid() const;
private:
+ bool isLatitudeValidActualCalculation() const;
+ bool isLongitudeValidActualCalculation() const;
+ bool isAltitudeValidActualCalculation() const;
+ QGeoCoordinate coordinateActualCalculation() const;
+ QDateTime timestampActualCalculation() const;
+ double speedActualCalculation() const;
+ bool isSpeedValidActualCalculation() const;
+ qreal horizontalAccuracyActualCalculation() const;
+ qreal verticalAccuracyActualCalculation() const;
+ bool isHorizontalAccuracyValidActualCalculation() const;
+ bool isVerticalAccuracyValidActualCalculation() const;
+ bool isDirectionValidActualCalculation() const;
+ double directionActualCalculation() const;
+ bool isVerticalSpeedValidActualCalculation() const;
+ double verticalSpeedActualCalculation() const;
+ double magneticVariationActualCalculation() const;
+ bool isMagneticVariationValidActualCalculation() const;
+
QGeoPositionInfo m_info;
+
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, bool, m_computedLatitudeValid,
+ &QDeclarativePosition::isLatitudeValidActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, bool, m_computedLongitudeValid,
+ &QDeclarativePosition::isLongitudeValidActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, bool, m_computedAltitudeValid,
+ &QDeclarativePosition::isAltitudeValidActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, QGeoCoordinate, m_computedCoordinate,
+ &QDeclarativePosition::coordinateActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, QDateTime, m_computedTimestamp,
+ &QDeclarativePosition::timestampActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, double, m_computedSpeed,
+ &QDeclarativePosition::speedActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, bool, m_computedSpeedValid,
+ &QDeclarativePosition::isSpeedValidActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, qreal, m_computedHorizontalAccuracy,
+ &QDeclarativePosition::horizontalAccuracyActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, qreal, m_computedVerticalAccuracy,
+ &QDeclarativePosition::verticalAccuracyActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, bool, m_computedHorizontalAccuracyValid,
+ &QDeclarativePosition::isHorizontalAccuracyValidActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, bool, m_computedVerticalAccuracyValid,
+ &QDeclarativePosition::isVerticalAccuracyValidActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, bool, m_computedDirectionValid,
+ &QDeclarativePosition::isDirectionValidActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, double, m_computedDirection,
+ &QDeclarativePosition::directionActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, bool, m_computedVerticalSpeedValid,
+ &QDeclarativePosition::isVerticalSpeedValidActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, double, m_computedVerticalSpeed,
+ &QDeclarativePosition::verticalSpeedActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, double, m_computedMagneticVariation,
+ &QDeclarativePosition::magneticVariationActualCalculation)
+ Q_OBJECT_COMPUTED_PROPERTY(QDeclarativePosition, bool, m_computedMagneticVariationValid,
+ &QDeclarativePosition::isMagneticVariationValidActualCalculation)
};
QT_END_NAMESPACE
diff --git a/tests/auto/CMakeLists.txt b/tests/auto/CMakeLists.txt
index b6495691..0fbe1c03 100644
--- a/tests/auto/CMakeLists.txt
+++ b/tests/auto/CMakeLists.txt
@@ -77,6 +77,7 @@ if(TARGET Qt::Quick AND NOT ANDROID)
add_subdirectory(dummypositionplugin)
add_subdirectory(declarative_positioning_core)
add_subdirectory(declarative_geolocation)
+ add_subdirectory(qdeclarativeposition)
endif()
if(NOT ANDROID)
add_subdirectory(positionplugin)
diff --git a/tests/auto/declarative_positioning_core/tst_position.qml b/tests/auto/declarative_positioning_core/tst_position.qml
index 1bde0879..77e6b90c 100644
--- a/tests/auto/declarative_positioning_core/tst_position.qml
+++ b/tests/auto/declarative_positioning_core/tst_position.qml
@@ -37,20 +37,6 @@ TestCase {
Position { id: defaultPosition }
- SignalSpy { id: latitudeValidSpy; target: defaultPosition; signalName: "latitudeValidChanged" }
- SignalSpy { id: longitudeValidSpy; target: defaultPosition; signalName: "longitudeValidChanged" }
- SignalSpy { id: altitudeValidSpy; target: defaultPosition; signalName: "altitudeValidChanged" }
- SignalSpy { id: timestampSpy; target: defaultPosition; signalName: "timestampChanged" }
- SignalSpy { id: speedSpy; target: defaultPosition; signalName: "speedChanged" }
- SignalSpy { id: speedValidSpy; target: defaultPosition; signalName: "speedValidChanged" }
- SignalSpy { id: coordinateSpy; target: defaultPosition; signalName: "coordinateChanged" }
- SignalSpy { id: horizontalAccuracySpy; target: defaultPosition; signalName: "horizontalAccuracyChanged" }
- SignalSpy { id: horizontalAccuracyValidSpy; target: defaultPosition; signalName: "horizontalAccuracyValidChanged" }
- SignalSpy { id: verticalAccuracySpy; target: defaultPosition; signalName: "verticalAccuracyChanged" }
- SignalSpy { id: verticalAccuracyValidSpy; target: defaultPosition; signalName: "verticalAccuracyValidChanged" }
- SignalSpy { id: directionSpy; target: defaultPosition; signalName: "directionChanged" }
- SignalSpy { id: verticalSpeedSpy; target: defaultPosition; signalName: "verticalSpeedChanged" }
-
function test_defaults() {
compare(defaultPosition.latitudeValid, false);
compare(defaultPosition.longitudeValid, false);
@@ -63,37 +49,4 @@ TestCase {
verify(!defaultPosition.verticalSpeedValid);
verify(isNaN(defaultPosition.verticalSpeed));
}
-
- function test_modifiers() {
- latitudeValidSpy.clear();
- longitudeValidSpy.clear();
- altitudeValidSpy.clear();
- timestampSpy.clear();
- speedSpy.clear();
- speedValidSpy.clear();
- coordinateSpy.clear();
- horizontalAccuracySpy.clear();
- horizontalAccuracyValidSpy.clear();
- verticalAccuracySpy.clear();
- verticalAccuracyValidSpy.clear();
- directionSpy.clear();
- verticalSpeedSpy.clear();
-
- defaultPosition.horizontalAccuracy = 10;
- compare(horizontalAccuracySpy.count, 1);
- compare(horizontalAccuracyValidSpy.count, 1);
- compare(defaultPosition.horizontalAccuracy, 10);
- compare(defaultPosition.horizontalAccuracyValid, true);
-
- defaultPosition.verticalAccuracy = 10;
- compare(verticalAccuracySpy.count, 1);
- compare(verticalAccuracyValidSpy.count, 1);
- compare(defaultPosition.verticalAccuracy, 10);
- compare(defaultPosition.verticalAccuracyValid, true);
-
- // some extra precautions
- compare(horizontalAccuracyValidSpy.count, 1);
- compare(speedSpy.count, 0);
- compare(speedValidSpy.count, 0);
- }
}
diff --git a/tests/auto/declarative_positioning_core/tst_positionsource.qml b/tests/auto/declarative_positioning_core/tst_positionsource.qml
index 858ff699..6b30d2ea 100644
--- a/tests/auto/declarative_positioning_core/tst_positionsource.qml
+++ b/tests/auto/declarative_positioning_core/tst_positionsource.qml
@@ -102,9 +102,6 @@ TestCase {
}
PositionSource { id: testingSource; name: "test.source"; updateInterval: 1000 }
- SignalSpy { id: updateSpy; target: testingSource; signalName: "positionChanged" }
- SignalSpy { id: directionValidSpy; target: testingSource.position; signalName: "directionValidChanged" }
- SignalSpy { id: directionSpy; target: testingSource.position; signalName: "directionChanged" }
PositionSource {
id: testingSourceWParams
@@ -117,14 +114,37 @@ TestCase {
}
}
+ // use property bindings instead of SignalSpy
+ property bool directionWParamsValid: testingSourceWParams.position.directionValid
+ property int directionWParamsValidChangedCount: 0
+ onDirectionWParamsValidChanged: {
+ ++directionWParamsValidChangedCount
+ }
+
+ property real directionWParams: testingSourceWParams.position.direction
+ property int directionWParamsChangedCount: 0
+ onDirectionWParamsChanged: {
+ ++directionWParamsChangedCount
+ }
+
SignalSpy { id: updateSpyWParams; target: testingSourceWParams; signalName: "positionChanged" }
- SignalSpy { id: directionValidSpyWParams; target: testingSourceWParams.position; signalName: "directionValidChanged" }
- SignalSpy { id: directionSpyWParams; target: testingSourceWParams.position; signalName: "directionChanged" }
PositionSource { id: testingSourceV1; name: "test.source"; updateInterval: 1000 }
+
+ // use property bindings instead of SignalSpy
+ property bool directionV1Valid: testingSourceV1.position.directionValid
+ property int directionV1ValidChangedCount: 0
+ onDirectionV1ValidChanged: {
+ ++directionV1ValidChangedCount
+ }
+
+ property real directionV1: testingSourceV1.position.direction
+ property int directionV1ChangedCount: 0
+ onDirectionV1Changed: {
+ ++directionV1ChangedCount
+ }
+
SignalSpy { id: updateSpyV1; target: testingSourceV1; signalName: "positionChanged" }
- SignalSpy { id: directionValidSpyV1; target: testingSourceV1.position; signalName: "directionValidChanged" }
- SignalSpy { id: directionSpyV1; target: testingSourceV1.position; signalName: "directionChanged" }
function test_updateInterval() {
testingSource.updateInterval = 1000;
@@ -147,16 +167,16 @@ TestCase {
function test_updates() {
updateSpyV1.clear();
- compare(directionValidSpyV1.count, 0)
- compare(directionSpyV1.count, 0)
+ directionV1ChangedCount = 0
+ directionV1ValidChangedCount = 0
testingSourceV1.active = true;
tryCompare(updateSpyV1, "count", 1, 1500);
compare(testingSourceV1.position.coordinate.longitude, 0.1);
compare(testingSourceV1.position.coordinate.latitude, 0.1);
- compare(directionValidSpyV1.count, 1)
- compare(directionSpyV1.count, 1)
+ compare(directionV1ValidChangedCount, 1)
+ compare(directionV1ChangedCount, 1)
fuzzyCompare(testingSourceV1.position.direction, 45, 0.1)
verify(!testingSourceV1.position.speedValid)
verify(isNaN(testingSourceV1.position.speed))
@@ -164,8 +184,8 @@ TestCase {
tryCompare(updateSpyV1, "count", 2, 1500);
compare(testingSourceV1.position.coordinate.longitude, 0.2);
compare(testingSourceV1.position.coordinate.latitude, 0.2);
- compare(directionValidSpyV1.count, 1)
- compare(directionSpyV1.count, 2)
+ compare(directionV1ValidChangedCount, 1)
+ compare(directionV1ChangedCount, 2)
fuzzyCompare(testingSourceV1.position.direction, 45, 0.1)
verify(testingSourceV1.position.speedValid)
verify(testingSourceV1.position.speed > 10000)
@@ -175,8 +195,8 @@ TestCase {
compare(updateSpyV1.count, 2);
compare(testingSourceV1.position.coordinate.longitude, 0.2);
compare(testingSourceV1.position.coordinate.latitude, 0.2);
- compare(directionValidSpyV1.count, 1)
- compare(directionSpyV1.count, 2)
+ compare(directionV1ValidChangedCount, 1)
+ compare(directionV1ChangedCount, 2)
fuzzyCompare(testingSourceV1.position.direction, 45, 0.1)
verify(testingSourceV1.position.speedValid)
verify(testingSourceV1.position.speed > 10000)
@@ -185,8 +205,8 @@ TestCase {
function test_updates_w_params() {
updateSpyWParams.clear();
- compare(directionValidSpyWParams.count, 0)
- compare(directionSpyWParams.count, 0)
+ directionWParamsChangedCount = 0
+ directionWParamsValidChangedCount = 0
compare(testingSourceWParams.backendProperty("altitude"), altitudeParameter.value)
testingSourceWParams.active = true;
@@ -194,8 +214,8 @@ TestCase {
compare(testingSourceWParams.position.coordinate.longitude, 0.1);
compare(testingSourceWParams.position.coordinate.latitude, 0.1);
compare(testingSourceWParams.position.coordinate.altitude, altitudeParameter.value);
- compare(directionValidSpyWParams.count, 1)
- compare(directionSpyWParams.count, 1)
+ compare(directionWParamsValidChangedCount, 1)
+ compare(directionWParamsChangedCount, 1)
fuzzyCompare(testingSourceWParams.position.direction, 45, 0.1)
verify(!testingSourceWParams.position.speedValid)
verify(isNaN(testingSourceWParams.position.speed))
@@ -205,8 +225,8 @@ TestCase {
compare(testingSourceWParams.position.coordinate.longitude, 0.2);
compare(testingSourceWParams.position.coordinate.latitude, 0.2);
compare(testingSourceWParams.position.coordinate.altitude, 24.24);
- compare(directionValidSpyWParams.count, 1)
- compare(directionSpyWParams.count, 2)
+ compare(directionWParamsValidChangedCount, 1)
+ compare(directionWParamsChangedCount, 2)
fuzzyCompare(testingSourceWParams.position.direction, 45, 0.1)
verify(testingSourceWParams.position.speedValid)
verify(testingSourceWParams.position.speed > 10000)
@@ -218,8 +238,8 @@ TestCase {
compare(testingSourceWParams.position.coordinate.longitude, 0.2);
compare(testingSourceWParams.position.coordinate.latitude, 0.2);
compare(testingSourceWParams.position.coordinate.altitude, 24.24);
- compare(directionValidSpyWParams.count, 1)
- compare(directionSpyWParams.count, 2)
+ compare(directionWParamsValidChangedCount, 1)
+ compare(directionWParamsChangedCount, 2)
fuzzyCompare(testingSourceWParams.position.direction, 45, 0.1)
verify(testingSourceWParams.position.speedValid)
verify(testingSourceWParams.position.speed > 10000)
diff --git a/tests/auto/qdeclarativeposition/CMakeLists.txt b/tests/auto/qdeclarativeposition/CMakeLists.txt
new file mode 100644
index 00000000..f5c132c2
--- /dev/null
+++ b/tests/auto/qdeclarativeposition/CMakeLists.txt
@@ -0,0 +1,8 @@
+qt_internal_add_test(tst_qdeclarativeposition
+ SOURCES
+ tst_qdeclarativeposition.cpp
+ LIBRARIES
+ Qt::Core
+ Qt::PositioningQuickPrivate
+ Qt::TestPrivate
+)
diff --git a/tests/auto/qdeclarativeposition/tst_qdeclarativeposition.cpp b/tests/auto/qdeclarativeposition/tst_qdeclarativeposition.cpp
new file mode 100644
index 00000000..2e396475
--- /dev/null
+++ b/tests/auto/qdeclarativeposition/tst_qdeclarativeposition.cpp
@@ -0,0 +1,225 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+#include <QtTest/private/qpropertytesthelper_p.h>
+#include <QtPositioningQuick/private/qdeclarativeposition_p.h>
+
+QT_USE_NAMESPACE
+
+class tst_QDeclarativePosition : public QObject
+{
+ Q_OBJECT
+
+private slots:
+ void initTestCase();
+ void init();
+
+ void latitudeValidBinding();
+ void longitudeValidBinding();
+ void altitudeValidBinding();
+ void coordinateBinding();
+ void timestampBinding();
+ void speedBinding();
+ void speedValidBinding();
+ void horizontalAccuracyValidBinding();
+ void horizontalAccuracyBinding();
+ void verticalAccuracyValidBinding();
+ void verticalAccuracyBinding();
+ void directionValidBinding();
+ void directionBinding();
+ void verticalSpeedValidBinding();
+ void verticalSpeedBinding();
+ void magneticVariationValidBinding();
+ void magneticVariationBinding();
+
+private:
+ QDeclarativePosition m_declarativePosition;
+ QGeoPositionInfo m_positionInfo;
+ std::function<void()> m_mutatorFunc = nullptr;
+ std::function<bool(const double &, const double &)> m_doubleComparator = nullptr;
+};
+
+void tst_QDeclarativePosition::initTestCase()
+{
+ m_mutatorFunc = [&]() { m_declarativePosition.setPosition(m_positionInfo); };
+ m_doubleComparator = [](const double &lhs, const double &rhs) {
+ return (qIsNaN(lhs) && qIsNaN(rhs)) || qFuzzyCompare(lhs, rhs);
+ };
+}
+
+void tst_QDeclarativePosition::init()
+{
+ // reset position before each test
+ m_declarativePosition.setPosition(QGeoPositionInfo());
+}
+
+void tst_QDeclarativePosition::latitudeValidBinding()
+{
+ QCOMPARE(m_declarativePosition.isLatitudeValid(), false);
+ m_positionInfo.setCoordinate(QGeoCoordinate(1.0, 2.0));
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, bool>(
+ m_declarativePosition, false, true, "latitudeValid", m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::longitudeValidBinding()
+{
+ QCOMPARE(m_declarativePosition.isLongitudeValid(), false);
+ m_positionInfo.setCoordinate(QGeoCoordinate(1.0, 2.0));
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, bool>(
+ m_declarativePosition, false, true, "longitudeValid", m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::altitudeValidBinding()
+{
+ QCOMPARE(m_declarativePosition.isAltitudeValid(), false);
+ m_positionInfo.setCoordinate(QGeoCoordinate(1.0, 2.0, 3.0));
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, bool>(
+ m_declarativePosition, false, true, "altitudeValid", m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::coordinateBinding()
+{
+ QCOMPARE(m_declarativePosition.coordinate(), QGeoCoordinate());
+ m_positionInfo.setCoordinate(QGeoCoordinate(1.0, 2.0, 3.0));
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, QGeoCoordinate>(
+ m_declarativePosition, QGeoCoordinate(), QGeoCoordinate(1.0, 2.0, 3.0), "coordinate",
+ m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::timestampBinding()
+{
+ QCOMPARE(m_declarativePosition.timestamp(), QDateTime());
+ const auto timestamp = QDateTime::currentDateTimeUtc();
+ m_positionInfo.setTimestamp(timestamp);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, QDateTime>(
+ m_declarativePosition, QDateTime(), timestamp, "timestamp", m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::speedBinding()
+{
+ QCOMPARE(m_declarativePosition.speed(), qQNaN());
+ m_positionInfo.setAttribute(QGeoPositionInfo::GroundSpeed, 10.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, double>(
+ m_declarativePosition, qQNaN(), 10.0, "speed", m_mutatorFunc, m_doubleComparator);
+}
+
+void tst_QDeclarativePosition::speedValidBinding()
+{
+ QCOMPARE(m_declarativePosition.isSpeedValid(), false);
+ m_positionInfo.setAttribute(QGeoPositionInfo::GroundSpeed, 10.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, bool>(
+ m_declarativePosition, false, true, "speedValid", m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::horizontalAccuracyValidBinding()
+{
+ QCOMPARE(m_declarativePosition.isHorizontalAccuracyValid(), false);
+ m_positionInfo.setAttribute(QGeoPositionInfo::HorizontalAccuracy, 1.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, bool>(
+ m_declarativePosition, false, true, "horizontalAccuracyValid", m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::horizontalAccuracyBinding()
+{
+ QCOMPARE(m_declarativePosition.horizontalAccuracy(), qQNaN());
+ m_positionInfo.setAttribute(QGeoPositionInfo::HorizontalAccuracy, 10.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, double>(
+ m_declarativePosition, qQNaN(), 10.0, "horizontalAccuracy", m_mutatorFunc,
+ m_doubleComparator);
+}
+
+void tst_QDeclarativePosition::verticalAccuracyValidBinding()
+{
+ QCOMPARE(m_declarativePosition.isVerticalAccuracyValid(), false);
+ m_positionInfo.setAttribute(QGeoPositionInfo::VerticalAccuracy, 1.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, bool>(
+ m_declarativePosition, false, true, "verticalAccuracyValid", m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::verticalAccuracyBinding()
+{
+ QCOMPARE(m_declarativePosition.verticalAccuracy(), qQNaN());
+ m_positionInfo.setAttribute(QGeoPositionInfo::VerticalAccuracy, 10.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, double>(
+ m_declarativePosition, qQNaN(), 10.0, "verticalAccuracy", m_mutatorFunc,
+ m_doubleComparator);
+}
+
+void tst_QDeclarativePosition::directionValidBinding()
+{
+ QCOMPARE(m_declarativePosition.isDirectionValid(), false);
+ m_positionInfo.setAttribute(QGeoPositionInfo::Direction, 1.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, bool>(
+ m_declarativePosition, false, true, "directionValid", m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::directionBinding()
+{
+ QCOMPARE(m_declarativePosition.direction(), qQNaN());
+ m_positionInfo.setAttribute(QGeoPositionInfo::Direction, 10.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, double>(
+ m_declarativePosition, qQNaN(), 10.0, "direction", m_mutatorFunc, m_doubleComparator);
+}
+
+void tst_QDeclarativePosition::verticalSpeedValidBinding()
+{
+ QCOMPARE(m_declarativePosition.isVerticalSpeedValid(), false);
+ m_positionInfo.setAttribute(QGeoPositionInfo::VerticalSpeed, 1.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, bool>(
+ m_declarativePosition, false, true, "verticalSpeedValid", m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::verticalSpeedBinding()
+{
+ QCOMPARE(m_declarativePosition.verticalSpeed(), qQNaN());
+ m_positionInfo.setAttribute(QGeoPositionInfo::VerticalSpeed, 10.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, double>(
+ m_declarativePosition, qQNaN(), 10.0, "verticalSpeed", m_mutatorFunc,
+ m_doubleComparator);
+}
+
+void tst_QDeclarativePosition::magneticVariationValidBinding()
+{
+ QCOMPARE(m_declarativePosition.isMagneticVariationValid(), false);
+ m_positionInfo.setAttribute(QGeoPositionInfo::MagneticVariation, 1.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, bool>(
+ m_declarativePosition, false, true, "magneticVariationValid", m_mutatorFunc);
+}
+
+void tst_QDeclarativePosition::magneticVariationBinding()
+{
+ QCOMPARE(m_declarativePosition.magneticVariation(), qQNaN());
+ m_positionInfo.setAttribute(QGeoPositionInfo::MagneticVariation, 10.0);
+ QTestPrivate::testReadOnlyPropertyBasics<QDeclarativePosition, double>(
+ m_declarativePosition, qQNaN(), 10.0, "magneticVariation", m_mutatorFunc,
+ m_doubleComparator);
+}
+
+QTEST_GUILESS_MAIN(tst_QDeclarativePosition)
+#include "tst_qdeclarativeposition.moc"