diff options
Diffstat (limited to 'tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp')
| -rw-r--r-- | tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp | 278 |
1 files changed, 278 insertions, 0 deletions
diff --git a/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp b/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp new file mode 100644 index 00000000..32d82348 --- /dev/null +++ b/tests/auto/qml/qml_cpp/tst_sensors_qmlcpp.cpp @@ -0,0 +1,278 @@ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QtTest/QtTest> +#include <QtTest/QSignalSpy> +#include <QtCore/QDebug> + +#include <QtTest/private/qpropertytesthelper_p.h> +#include <QtSensorsQuick/private/qmlsensor_p.h> +#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/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/qmlambienttemperaturesensor_p.h> +#include <QtSensorsQuick/private/qmllightsensor_p.h> +#include <QtSensorsQuick/private/qmlirproximitysensor_p.h> + +QT_USE_NAMESPACE + +QT_BEGIN_NAMESPACE + +class tst_sensors_qmlcpp : public QObject +{ + Q_OBJECT + +private slots: + void initTestCase(); + void testReadingBindings(); + // void testGesture(); + void testSensorRanges(); +}; + +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<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<QmlAmbientTemperatureSensor, QmlAmbientTemperatureReading, qreal>( + "QAmbientTemperatureSensor", + {{"temperature", QVariantList{30.0, 40.0}}}); + testSensorReadings<QmlLightSensor, QmlLightSensorReading, qreal>( + "QLightSensor", + {{"illuminance", QVariantList{1.0, 2.0}}}); + 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(); +} + +class QDummySensorBackend : public QSensorBackend +{ + Q_OBJECT +public: + QDummySensorBackend(QSensor *sensor) : QSensorBackend(sensor) + { + addDataRate(2, 3); + addDataRate(5, 7); + addOutputRange(100, 200, 1); + addOutputRange(600, 700, 10); + addOutputRange(0, 1, 2); + } + + void start() override {} + void stop() override {} +}; + +class QDummySensorReading : public QSensorReading +{ + Q_OBJECT +public: + QDummySensorReading(QObject *parent) : QSensorReading(parent, nullptr) {} +}; + +class QmlDummySensorReading : public QmlSensorReading +{ + Q_OBJECT +public: + QmlDummySensorReading() : + m_reading(new QDummySensorReading(this)) + {} + + QSensorReading *reading() const override { return m_reading; } + void readingUpdate() override {} + +private: + QSensorReading *m_reading = nullptr; +}; + +class QmlDummySensor : public QmlSensor +{ + Q_OBJECT +public: + QmlDummySensor(QObject *parent = nullptr) : + QmlSensor(parent), + m_sensor(new QSensor("dummy", this)) + { + QDummySensorBackend b(m_sensor); + Q_UNUSED(b); + } + + QSensor *sensor() const override { return m_sensor; } + QmlSensorReading *createReading() const override { return new QmlDummySensorReading(); } + + void componentComplete() override { QmlSensor::componentComplete(); } + +private: + QSensor *m_sensor = nullptr; +}; + +void tst_sensors_qmlcpp::testSensorRanges() +{ + QScopedPointer<QmlDummySensor> qmlSensor(new QmlDummySensor); + qmlSensor->componentComplete(); + + auto ranges = qmlSensor->availableDataRates(); + QCOMPARE(ranges.count(&ranges), 2); + + const auto range0 = ranges.at(&ranges, 0); + QCOMPARE(range0->minimum(), 2); + QCOMPARE(range0->maximum(), 3); + QSignalSpy range0Spy(range0, SIGNAL(destroyed())); + + const auto range1 = ranges.at(&ranges, 1); + QCOMPARE(range1->minimum(), 5); + QCOMPARE(range1->maximum(), 7); + QSignalSpy range1Spy(range1, SIGNAL(destroyed())); + + auto outputs = qmlSensor->outputRanges(); + QCOMPARE(outputs.count(&outputs), 3); + + const auto output0 = outputs.at(&outputs, 0); + QCOMPARE(output0->minimum(), 100); + QCOMPARE(output0->maximum(), 200); + QCOMPARE(output0->accuracy(), 1); + QSignalSpy output0Spy(output0, SIGNAL(destroyed())); + + const auto output1 = outputs.at(&outputs, 1); + QCOMPARE(output1->minimum(), 600); + QCOMPARE(output1->maximum(), 700); + QCOMPARE(output1->accuracy(), 10); + QSignalSpy output1Spy(output1, SIGNAL(destroyed())); + + const auto output2 = outputs.at(&outputs, 2); + QCOMPARE(output2->minimum(), 0); + QCOMPARE(output2->maximum(), 1); + QCOMPARE(output2->accuracy(), 2); + QSignalSpy output2Spy(output2, SIGNAL(destroyed())); + + qmlSensor.reset(); + QCOMPARE(range0Spy.size(), 1); + QCOMPARE(range1Spy.size(), 1); + QCOMPARE(output0Spy.size(), 1); + QCOMPARE(output1Spy.size(), 1); + QCOMPARE(output2Spy.size(), 1); +} + +QT_END_NAMESPACE + +QTEST_MAIN(tst_sensors_qmlcpp) +#include "tst_sensors_qmlcpp.moc" |