summaryrefslogtreecommitdiffstats
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/auto/common/test_backends.cpp66
-rw-r--r--tests/auto/common/test_backends.h3
-rw-r--r--tests/auto/qml/qml_cpp/CMakeLists.txt6
-rw-r--r--tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp149
-rw-r--r--tests/auto/qml/qml_quick/tst_sensors_basic.qml2
-rw-r--r--tests/auto/qml/qml_quick/tst_sensors_qmlquick.cpp2
6 files changed, 190 insertions, 38 deletions
diff --git a/tests/auto/common/test_backends.cpp b/tests/auto/common/test_backends.cpp
index 15419b0e..a8ce7f3f 100644
--- a/tests/auto/common/test_backends.cpp
+++ b/tests/auto/common/test_backends.cpp
@@ -62,41 +62,43 @@ void set_test_backend_busy(QSensor* sensor, bool busy)
backend->sensorBusy(busy);
}
-void set_test_backend_reading(QSensor* sensor, const QJsonObject& values)
+void set_test_backend_reading(QSensor* sensor, const QVariantMap& values)
{
Q_ASSERT(sensor->isConnectedToBackend());
QSensorBackend* backend = sensorToBackend.value(sensor);
- backend->reading()->setTimestamp(values["timestamp"].toInt()); // timestamp is common to all
+ // timestamp is common to all readings
+ if (values.contains("timestamp"))
+ backend->reading()->setTimestamp(values["timestamp"].toInt());
if (sensor->type() == "QAccelerometer") {
QAccelerometerReading* reading = static_cast<QAccelerometerReading*>(backend->reading());
- reading->setX(values["x"].toDouble());
- reading->setY(values["y"].toDouble());
- reading->setZ(values["z"].toDouble());
+ if (values.contains("x")) reading->setX(values["x"].value<qreal>());
+ if (values.contains("y")) reading->setY(values["y"].value<qreal>());
+ if (values.contains("z")) reading->setZ(values["z"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QPressureSensor") {
QPressureReading* reading = static_cast<QPressureReading*>(backend->reading());
- reading->setPressure(values["pressure"].toDouble());
- reading->setTemperature(values["temperature"].toDouble());
+ if (values.contains("pressure")) reading->setPressure(values["pressure"].value<qreal>());
+ if (values.contains("temperature")) reading->setTemperature(values["temperature"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QGyroscope") {
QGyroscopeReading* reading = static_cast<QGyroscopeReading*>(backend->reading());
- reading->setX(values["x"].toDouble());
- reading->setY(values["y"].toDouble());
- reading->setZ(values["z"].toDouble());
+ if (values.contains("x")) reading->setX(values["x"].value<qreal>());
+ if (values.contains("y")) reading->setY(values["y"].value<qreal>());
+ if (values.contains("z")) reading->setZ(values["z"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QTapSensor") {
QTapReading* reading = static_cast<QTapReading*>(backend->reading());
- reading->setDoubleTap(values["doubleTap"].toBool());
- reading->setTapDirection(QTapReading::TapDirection(values["tapDirection"].toInt()));
+ if (values.contains("doubleTap")) reading->setDoubleTap(values["doubleTap"].value<bool>());
+ if (values.contains("tapDirection")) reading->setTapDirection(QTapReading::TapDirection(values["tapDirection"].toInt()));
backend->newReadingAvailable();
} else if (sensor->type() == "QCompass") {
QCompassReading* reading = static_cast<QCompassReading*>(backend->reading());
- reading->setAzimuth(values["azimuth"].toDouble());
- reading->setCalibrationLevel(values["calibrationLevel"].toDouble());
+ if (values.contains("azimuth")) reading->setAzimuth(values["azimuth"].value<qreal>());
+ if (values.contains("calibrationLevel")) reading->setCalibrationLevel(values["calibrationLevel"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QProximitySensor") {
QProximityReading* reading = static_cast<QProximityReading*>(backend->reading());
- reading->setClose(values["near"].toBool());
+ reading->setClose(values["near"].value<bool>());
backend->newReadingAvailable();
} else if (sensor->type() == "QOrientationSensor") {
QOrientationReading* reading = static_cast<QOrientationReading*>(backend->reading());
@@ -104,7 +106,7 @@ void set_test_backend_reading(QSensor* sensor, const QJsonObject& values)
backend->newReadingAvailable();
} else if (sensor->type() == "QDistanceSensor") {
QDistanceReading* reading = static_cast<QDistanceReading*>(backend->reading());
- reading->setDistance(values["distance"].toDouble());
+ reading->setDistance(values["distance"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QAmbientLightSensor") {
QAmbientLightReading* reading = static_cast<QAmbientLightReading*>(backend->reading());
@@ -112,49 +114,49 @@ void set_test_backend_reading(QSensor* sensor, const QJsonObject& values)
backend->newReadingAvailable();
} else if (sensor->type() == "QMagnetometer") {
QMagnetometerReading* reading = static_cast<QMagnetometerReading*>(backend->reading());
- reading->setX(values["x"].toDouble());
- reading->setY(values["y"].toDouble());
- reading->setZ(values["z"].toDouble());
- reading->setCalibrationLevel(values["calibrationLevel"].toDouble());
+ if (values.contains("x")) reading->setX(values["x"].value<qreal>());
+ if (values.contains("y")) reading->setY(values["y"].value<qreal>());
+ if (values.contains("z")) reading->setZ(values["z"].value<qreal>());
+ if (values.contains("calibrationLevel")) reading->setCalibrationLevel(values["calibrationLevel"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QLidSensor") {
QLidReading* reading = static_cast<QLidReading*>(backend->reading());
- reading->setBackLidClosed(values["backLidClosed"].toBool());
- reading->setFrontLidClosed(values["frontLidClosed"].toBool());
+ if (values.contains("backLidClosed")) reading->setBackLidClosed(values["backLidClosed"].value<bool>());
+ if (values.contains("frontLidClosed")) reading->setFrontLidClosed(values["frontLidClosed"].value<bool>());
backend->newReadingAvailable();
} else if (sensor->type() == "QTiltSensor") {
QTiltReading* reading = static_cast<QTiltReading*>(backend->reading());
- reading->setYRotation(values["yRotation"].toDouble());
- reading->setXRotation(values["xRotation"].toDouble());
+ if (values.contains("yRotation")) reading->setYRotation(values["yRotation"].value<qreal>());
+ if (values.contains("xRotation")) reading->setXRotation(values["xRotation"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QRotationSensor") {
QRotationReading* reading = static_cast<QRotationReading*>(backend->reading());
- reading->setFromEuler(values["x"].toDouble(), values["y"].toDouble(), values["z"].toDouble());
+ reading->setFromEuler(values["x"].value<qreal>(), values["y"].value<qreal>(), values["z"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QHumiditySensor") {
QHumidityReading* reading = static_cast<QHumidityReading*>(backend->reading());
- reading->setRelativeHumidity(values["relativeHumidity"].toDouble());
- reading->setAbsoluteHumidity(values["absoluteHumidity"].toDouble());
+ if (values.contains("relativeHumidity")) reading->setRelativeHumidity(values["relativeHumidity"].value<qreal>());
+ if (values.contains("absoluteHumidity")) reading->setAbsoluteHumidity(values["absoluteHumidity"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QHolsterSensor") {
QHolsterReading* reading = static_cast<QHolsterReading*>(backend->reading());
- reading->setHolstered(values["holstered"].toBool());
+ reading->setHolstered(values["holstered"].value<bool>());
backend->newReadingAvailable();
} else if (sensor->type() == "QAmbientTemperatureSensor") {
QAmbientTemperatureReading* reading = static_cast<QAmbientTemperatureReading*>(backend->reading());
- reading->setTemperature(values["temperature"].toDouble());
+ reading->setTemperature(values["temperature"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QLightSensor") {
QLightReading* reading = static_cast<QLightReading*>(backend->reading());
- reading->setLux(values["illuminance"].toDouble());
+ reading->setLux(values["illuminance"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QAltimeter") {
QAltimeterReading* reading = static_cast<QAltimeterReading*>(backend->reading());
- reading->setAltitude(values["altitude"].toDouble());
+ reading->setAltitude(values["altitude"].value<qreal>());
backend->newReadingAvailable();
} else if (sensor->type() == "QIRProximitySensor") {
QIRProximityReading* reading = static_cast<QIRProximityReading*>(backend->reading());
- reading->setReflectance(values["reflectance"].toDouble());
+ reading->setReflectance(values["reflectance"].value<qreal>());
backend->newReadingAvailable();
} else {
qWarning() << "Unsupported test sensor backend:" << sensor->type();
diff --git a/tests/auto/common/test_backends.h b/tests/auto/common/test_backends.h
index 66699b5c..80d6913c 100644
--- a/tests/auto/common/test_backends.h
+++ b/tests/auto/common/test_backends.h
@@ -34,7 +34,7 @@
void register_test_backends();
void unregister_test_backends();
-void set_test_backend_reading(QSensor* sensor, const QJsonObject& values);
+void set_test_backend_reading(QSensor* sensor, const QVariantMap& values);
void set_test_backend_busy(QSensor* sensor, bool busy);
#include <qaccelerometer.h>
@@ -89,6 +89,7 @@ void set_test_backend_busy(QSensor* sensor, bool busy);
#endif
PREPARE_SENSORINTERFACE(QAccelerometer, QAccelerometerReading, QAccelerometerFilter, {
+ reading->setTimestamp(1);
reading->setX(1.0);
reading->setY(1.0);
reading->setZ(1.0);
diff --git a/tests/auto/qml/qml_cpp/CMakeLists.txt b/tests/auto/qml/qml_cpp/CMakeLists.txt
index 1ceb7662..45c3230d 100644
--- a/tests/auto/qml/qml_cpp/CMakeLists.txt
+++ b/tests/auto/qml/qml_cpp/CMakeLists.txt
@@ -1,12 +1,12 @@
-
qt_internal_add_test(tst_sensors_qmlcpp
SOURCES
+ ../../common/test_backends.cpp ../../common/test_backends.h
qtemplategestureplugin.cpp qtemplategestureplugin.h
qtemplaterecognizer.cpp qtemplaterecognizer.h
tst_sensors_qmlcpp.cpp
- PUBLIC_LIBRARIES
- Qt::Qml
LIBRARIES
+ Qt::Qml
Qt::SensorsPrivate
Qt::SensorsQuickPrivate
+ Qt::TestPrivate
)
diff --git a/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp b/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp
index acc4d924..4b81aad6 100644
--- a/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp
+++ b/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp
@@ -30,6 +30,7 @@
#include <QtTest/QSignalSpy>
#include <QtCore/QDebug>
+#include <QtTest/private/qpropertytesthelper_p.h>
#include <QtSensorsQuick/private/qmlsensor_p.h>
#include <QtSensorsQuick/private/qmlsensorgesture_p.h>
@@ -39,6 +40,27 @@
#include <qsensorbackend.h>
#include "qsensormanager.h"
+#include "../../common/test_backends.h"
+#include <QtSensorsQuick/private/qmlaccelerometer_p.h>
+#include <QtSensorsQuick/private/qmlpressuresensor_p.h>
+#include <QtSensorsQuick/private/qmlgyroscope_p.h>
+#include <QtSensorsQuick/private/qmltapsensor_p.h>
+#include <QtSensorsQuick/private/qmlcompass_p.h>
+#include <QtSensorsQuick/private/qmlproximitysensor_p.h>
+#include <QtSensorsQuick/private/qmlorientationsensor_p.h>
+#include <QtSensorsQuick/private/qmldistancesensor_p.h>
+#include <QtSensorsQuick/private/qmlambientlightsensor_p.h>
+#include <QtSensorsQuick/private/qmlmagnetometer_p.h>
+#include <QtSensorsQuick/private/qmllidsensor_p.h>
+#include <QtSensorsQuick/private/qmltiltsensor_p.h>
+#include <QtSensorsQuick/private/qmlrotationsensor_p.h>
+#include <QtSensorsQuick/private/qmlhumiditysensor_p.h>
+#include <QtSensorsQuick/private/qmlholstersensor_p.h>
+#include <QtSensorsQuick/private/qmlambienttemperaturesensor_p.h>
+#include <QtSensorsQuick/private/qmllightsensor_p.h>
+#include <QtSensorsQuick/private/qmlaltimeter_p.h>
+#include <QtSensorsQuick/private/qmlirproximitysensor_p.h>
+
QT_USE_NAMESPACE
QT_BEGIN_NAMESPACE
@@ -49,6 +71,7 @@ class tst_sensors_qmlcpp : public QObject
private slots:
void initTestCase();
+ void testReadingBindings();
void testGesture();
void testSensorRanges();
};
@@ -58,6 +81,132 @@ void tst_sensors_qmlcpp::initTestCase()
qputenv("QT_SENSORS_LOAD_PLUGINS", "0"); // Do not load plugins
}
+template<typename SensorClass, typename ReadingClass, typename ValueType>
+void testSensorReadings(const char* identifier, const QVariantMap& values)
+{
+ SensorClass sensor;
+ sensor.setIdentifier(identifier);
+ sensor.componentComplete();
+ sensor.start();
+
+ for (const auto& key : values.keys()) {
+ ValueType initialValue = values[key].toList()[0].value<ValueType>();
+ ValueType changedValue = values[key].toList()[1].value<ValueType>();
+ QTestPrivate::testReadOnlyPropertyBasics<ReadingClass, ValueType>(
+ *static_cast<ReadingClass*>(sensor.reading()),
+ initialValue, changedValue, key.toStdString().c_str(),
+ [&](){ set_test_backend_reading(sensor.sensor(), {{key, changedValue}}); });
+ if (QTest::currentTestFailed()) {
+ qWarning() << identifier << "::" << key << "test failed.";
+ return;
+ }
+ }
+}
+
+void tst_sensors_qmlcpp::testReadingBindings()
+{
+ register_test_backends();
+
+ testSensorReadings<QmlAccelerometer, QmlAccelerometerReading, qreal>(
+ "QAccelerometer",
+ {{"x", QVariantList{1.0, 2.0}},
+ {"y", QVariantList{1.0, 2.0}},
+ {"z", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlAccelerometer, QmlAccelerometerReading, quint64>(
+ "QAccelerometer",
+ {{"timestamp", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlAmbientLightSensor, QmlAmbientLightSensorReading, QAmbientLightReading::LightLevel>(
+ "QAmbientLightSensor",
+ {{"lightLevel", QVariantList{QAmbientLightReading::Twilight, QAmbientLightReading::Sunny}}});
+ testSensorReadings<QmlPressureSensor, QmlPressureReading, qreal>(
+ "QPressureSensor",
+ {{"pressure", QVariantList{1.0, 2.0}},
+ {"temperature", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlGyroscope, QmlGyroscopeReading, qreal>(
+ "QGyroscope",
+ {{"x", QVariantList{1.0, 2.0}},
+ {"y", QVariantList{1.0, 2.0}},
+ {"z", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlTapSensor, QmlTapSensorReading, bool>(
+ "QTapSensor",
+ {{"doubleTap", QVariantList{true, false}}});
+ testSensorReadings<QmlTapSensor, QmlTapSensorReading, QTapReading::TapDirection>(
+ "QTapSensor",
+ {{"tapDirection", QVariantList{QTapReading::Z_Both, QTapReading::X_Both}}});
+ testSensorReadings<QmlCompass, QmlCompassReading, qreal>(
+ "QCompass",
+ {{"azimuth", QVariantList{1.0, 2.0}},
+ {"calibrationLevel", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlProximitySensor, QmlProximitySensorReading, bool>(
+ "QProximitySensor",
+ {{"near", QVariantList{true, false}}});
+ testSensorReadings<QmlOrientationSensor, QmlOrientationSensorReading, QOrientationReading::Orientation>(
+ "QOrientationSensor",
+ {{"orientation", QVariantList{QOrientationReading::LeftUp, QOrientationReading::RightUp}}});
+ testSensorReadings<QmlDistanceSensor, QmlDistanceReading, qreal>(
+ "QDistanceSensor",
+ {{"distance", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlMagnetometer, QmlMagnetometerReading, qreal>(
+ "QMagnetometer",
+ {{"x", QVariantList{1.0, 2.0}},
+ {"y", QVariantList{1.0, 2.0}},
+ {"z", QVariantList{1.0, 2.0}},
+ {"calibrationLevel", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlLidSensor, QmlLidReading, bool>(
+ "QLidSensor",
+ {{"backLidClosed", QVariantList{true, false}},
+ {"frontLidClosed", QVariantList{true, false}}});
+ testSensorReadings<QmlTiltSensor, QmlTiltSensorReading, qreal>(
+ "QTiltSensor",
+ {{"yRotation", QVariantList{1.0, 2.0}},
+ {"xRotation", QVariantList{1.0, 2.0}}});
+ // rotation sensor properties need to be tested separately because the setter function is
+ // not symmetric with getter functions ("setFromEuler()" vs. "x() & y() & z()")
+ testSensorReadings<QmlRotationSensor, QmlRotationSensorReading, qreal>(
+ "QRotationSensor",
+ {{"x", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlRotationSensor, QmlRotationSensorReading, qreal>(
+ "QRotationSensor",
+ {{"y", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlRotationSensor, QmlRotationSensorReading, qreal>(
+ "QRotationSensor",
+ {{"z", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlHumiditySensor, QmlHumidityReading, qreal>(
+ "QHumiditySensor",
+ {{"relativeHumidity", QVariantList{1.0, 2.0}},
+ {"absoluteHumidity", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlHolsterSensor, QmlHolsterReading, bool>(
+ "QHolsterSensor",
+ {{"holstered", QVariantList{true, false}}});
+ testSensorReadings<QmlAmbientTemperatureSensor, QmlAmbientTemperatureReading, qreal>(
+ "QAmbientTemperatureSensor",
+ {{"temperature", QVariantList{30.0, 40.0}}});
+ testSensorReadings<QmlLightSensor, QmlLightSensorReading, qreal>(
+ "QLightSensor",
+ {{"illuminance", QVariantList{1.0, 2.0}}});
+ testSensorReadings<QmlAltimeter, QmlAltimeterReading, qreal>(
+ "QAltimeter",
+ {{"altitude", QVariantList{8848, 9959}}});
+ testSensorReadings<QmlIRProximitySensor, QmlIRProximitySensorReading, qreal>(
+ "QIRProximitySensor",
+ {{"reflectance", QVariantList{0.5, 0.6}}});
+
+ // The following tests QmlSensor (the baseclass) 'readingChanged' which is
+ // emitted every time a sensor value changes. For that we instantiate a
+ // concrete sensor. The actual 'reading' value (a QObject pointer) of the
+ // 'readingChanged' property will not change, but rather the
+ // 'readingChanged' is used to indicate that the value it contains has changed.
+ QmlAccelerometer accelerometer;
+ accelerometer.setIdentifier("QAccelerometer");
+ accelerometer.componentComplete();
+ accelerometer.start();
+ QTestPrivate::testReadOnlyPropertyBasics<QmlSensor, QmlSensorReading*>(
+ accelerometer, accelerometer.reading(), accelerometer.reading(), "reading",
+ [&](){ set_test_backend_reading(accelerometer.sensor(), {{"x", 2.0}}); });
+
+ unregister_test_backends();
+}
+
void tst_sensors_qmlcpp::testGesture()
{
QTemplateGesturePlugin* plugin = new QTemplateGesturePlugin();
diff --git a/tests/auto/qml/qml_quick/tst_sensors_basic.qml b/tests/auto/qml/qml_quick/tst_sensors_basic.qml
index 37895ba0..f6553df4 100644
--- a/tests/auto/qml/qml_quick/tst_sensors_basic.qml
+++ b/tests/auto/qml/qml_quick/tst_sensors_basic.qml
@@ -208,7 +208,7 @@ TestCase {
function test_reading_data() {
return [
- {tag: "Accelerometer", initialReading: {timestamp: 0, x: 1.0, y: 1.0, z: 1.0}, newReading: {timestamp: 1, x: 2.0, y: 3.0, z: 4.0}},
+ {tag: "Accelerometer", initialReading: {timestamp: 1, x: 1.0, y: 1.0, z: 1.0}, newReading: {timestamp: 2, x: 2.0, y: 3.0, z: 4.0}},
{tag: "PressureSensor", initialReading: {pressure: 1.0, temperature: 1.0}, newReading: {pressure: 2.0, temperature: 3.0}},
{tag: "Gyroscope", initialReading: {x : 1.0, y: 1.0, z: 1.0}, newReading: {x : 2.0, y: 3.0, z: 4.0}},
{tag: "TapSensor", initialReading: {doubleTap: true, tapDirection: TapReading.Z_Both}, newReading: {doubleTap: false, tapDirection: TapReading.X_Both}},
diff --git a/tests/auto/qml/qml_quick/tst_sensors_qmlquick.cpp b/tests/auto/qml/qml_quick/tst_sensors_qmlquick.cpp
index 8162601d..9bab11f8 100644
--- a/tests/auto/qml/qml_quick/tst_sensors_qmlquick.cpp
+++ b/tests/auto/qml/qml_quick/tst_sensors_qmlquick.cpp
@@ -52,7 +52,7 @@ public slots:
unregister_test_backends();
}
- void setSensorReading(const QmlSensor* qmlSensor, const QJsonObject& values) {
+ void setSensorReading(const QmlSensor* qmlSensor, const QVariantMap& values) {
set_test_backend_reading(qmlSensor->sensor(), values);
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-08 22:50:49 +0000