diff options
author | Ivan Solovev <ivan.solovev@qt.io> | 2021-04-08 18:31:29 +0200 |
---|---|---|
committer | Ivan Solovev <ivan.solovev@qt.io> | 2021-04-27 11:10:56 +0200 |
commit | 4258f337f5c550c86256e4f5494a2bb9f7eedf0f (patch) | |
tree | 78178cec3d4d4c3a7e125484c19a38b44d61139e | |
parent | d0e4e0c47c98634bade7025567e25c12ff578c67 (diff) | |
download | qtlocation-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.cpp | 305 | ||||
-rw-r--r-- | src/positioningquick/qdeclarativeposition_p.h | 139 | ||||
-rw-r--r-- | tests/auto/CMakeLists.txt | 1 | ||||
-rw-r--r-- | tests/auto/declarative_positioning_core/tst_position.qml | 47 | ||||
-rw-r--r-- | tests/auto/declarative_positioning_core/tst_positionsource.qml | 66 | ||||
-rw-r--r-- | tests/auto/qdeclarativeposition/CMakeLists.txt | 8 | ||||
-rw-r--r-- | tests/auto/qdeclarativeposition/tst_qdeclarativeposition.cpp | 225 |
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" |