diff options
Diffstat (limited to 'tests/auto/common')
| -rw-r--r-- | tests/auto/common/test_backends.cpp | 160 | ||||
| -rw-r--r-- | tests/auto/common/test_backends.h | 144 |
2 files changed, 304 insertions, 0 deletions
diff --git a/tests/auto/common/test_backends.cpp b/tests/auto/common/test_backends.cpp new file mode 100644 index 00000000..92e69bb3 --- /dev/null +++ b/tests/auto/common/test_backends.cpp @@ -0,0 +1,160 @@ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <QtCore/QList> +#include <QtCore/QMap> +#include <QtCore/QVariantMap> +#include "qsensorbackend.h" + + +typedef QSensorBackend* (*CreateFunc) (QSensor *sensor); +class Record +{ +public: + QByteArray type; + CreateFunc func; +}; +static QList<Record> records; + +static bool registerTestBackend(const char *className, CreateFunc func) +{ + Record record; + record.type = className; + record.func = func; + records << record; + return true; +} + +#define REGISTER_TOO +#include "test_backends.h" +#include <QDebug> + +// The sensor-to-backend mapping is maintained in order to be able to change +// the sensor reading values in the backend +static QMap<QSensor*, QSensorBackend*> sensorToBackend; + +void set_test_backend_busy(QSensor* sensor, bool busy) +{ + Q_ASSERT(sensor->isConnectedToBackend()); + QSensorBackend* backend = sensorToBackend.value(sensor); + backend->sensorBusy(busy); +} + +void set_test_backend_reading(QSensor* sensor, const QVariantMap& values) +{ + Q_ASSERT(sensor->isConnectedToBackend()); + QSensorBackend* backend = sensorToBackend.value(sensor); + // 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()); + 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()); + 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()); + 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()); + 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()); + 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"].value<bool>()); + backend->newReadingAvailable(); + } else if (sensor->type() == "QOrientationSensor") { + QOrientationReading* reading = static_cast<QOrientationReading*>(backend->reading()); + reading->setOrientation(QOrientationReading::Orientation(values["orientation"].toInt())); + backend->newReadingAvailable(); + } else if (sensor->type() == "QAmbientLightSensor") { + QAmbientLightReading* reading = static_cast<QAmbientLightReading*>(backend->reading()); + reading->setLightLevel(QAmbientLightReading::LightLevel(values["lightLevel"].toInt())); + backend->newReadingAvailable(); + } else if (sensor->type() == "QMagnetometer") { + QMagnetometerReading* reading = static_cast<QMagnetometerReading*>(backend->reading()); + 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()); + 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()); + 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"].value<qreal>(), values["y"].value<qreal>(), values["z"].value<qreal>()); + backend->newReadingAvailable(); + } else if (sensor->type() == "QHumiditySensor") { + QHumidityReading* reading = static_cast<QHumidityReading*>(backend->reading()); + 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() == "QAmbientTemperatureSensor") { + QAmbientTemperatureReading* reading = static_cast<QAmbientTemperatureReading*>(backend->reading()); + reading->setTemperature(values["temperature"].value<qreal>()); + backend->newReadingAvailable(); + } else if (sensor->type() == "QLightSensor") { + QLightReading* reading = static_cast<QLightReading*>(backend->reading()); + reading->setLux(values["illuminance"].value<qreal>()); + backend->newReadingAvailable(); + } else if (sensor->type() == "QIRProximitySensor") { + QIRProximityReading* reading = static_cast<QIRProximityReading*>(backend->reading()); + reading->setReflectance(values["reflectance"].value<qreal>()); + backend->newReadingAvailable(); + } else { + qWarning() << "Unsupported test sensor backend:" << sensor->type(); + } +} + +class BackendFactory : public QSensorBackendFactory +{ + QSensorBackend *createBackend(QSensor *sensor) override + { + for (const Record &record : records) { + if (sensor->identifier() == record.type) { + QSensorBackend* backend = record.func(sensor); + sensorToBackend.insert(sensor, backend); + return backend; + } + } + return nullptr; + } +}; +static BackendFactory factory; + +void register_test_backends() +{ + sensorToBackend.clear(); + for (const Record &record : records) + QSensorManager::registerBackend(record.type, record.type, &factory); +} + +void unregister_test_backends() +{ + sensorToBackend.clear(); + for (const Record &record : records) + QSensorManager::unregisterBackend(record.type, record.type); +} diff --git a/tests/auto/common/test_backends.h b/tests/auto/common/test_backends.h new file mode 100644 index 00000000..06d827b7 --- /dev/null +++ b/tests/auto/common/test_backends.h @@ -0,0 +1,144 @@ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#ifndef TEST_BACKENDS_H +#define TEST_BACKENDS_H + +#include <qsensorbackend.h> +#include <QtCore/QJsonObject> + +void register_test_backends(); +void unregister_test_backends(); +void set_test_backend_reading(QSensor* sensor, const QVariantMap& values); +void set_test_backend_busy(QSensor* sensor, bool busy); + +#include <qaccelerometer.h> +#include <qambientlightsensor.h> +#include <qambienttemperaturesensor.h> +#include <qcompass.h> +#include <qgyroscope.h> +#include <qlightsensor.h> +#include <qmagnetometer.h> +#include <qorientationsensor.h> +#include <qpressuresensor.h> +#include <qproximitysensor.h> +#include <qrotationsensor.h> +#include <qtapsensor.h> +#include <qirproximitysensor.h> +#include <qtiltsensor.h> +#include <qlidsensor.h> +#include <qhumiditysensor.h> + +#define PREPARE_SENSORINTERFACE_DECLS(SensorClass, ReadingClass, FilterClass, readingcode)\ + class SensorClass ## _impl : public QSensorBackend\ + {\ + public:\ + SensorClass ## _impl(QSensor *sensor);\ + void start() override;\ + void stop() override;\ + bool isFeatureSupported(QSensor::Feature feature) const override;\ + };\ + class SensorClass ## _testfilter : public FilterClass { bool filter(ReadingClass *) override; }; + +#define PREPARE_SENSORINTERFACE_IMPLS(SensorClass, ReadingClass, FilterClass, readingcode)\ + SensorClass ## _impl::SensorClass ##_impl(QSensor *sensor) : QSensorBackend(sensor) {}\ + void SensorClass ## _impl::start() {\ + ReadingClass *reading = setReading<ReadingClass>(0);\ + readingcode\ + newReadingAvailable();\ + }\ + void SensorClass ##_impl::stop() {}\ + bool SensorClass ##_impl::isFeatureSupported(QSensor::Feature feature) const { \ + if (feature == QSensor::Feature::SkipDuplicates) \ + return true; \ + return false; \ + } \ + bool SensorClass ## _testfilter::filter(ReadingClass *) { return true; }\ + static QSensorBackend *create_ ## SensorClass ## _impl(QSensor *sensor) { return new SensorClass ## _impl(sensor); }\ + static bool registered_ ## SensorClass = registerTestBackend(#SensorClass, create_ ## SensorClass ## _impl); + +#ifdef REGISTER_TOO +#define PREPARE_SENSORINTERFACE(SensorClass, ReadingClass, FilterClass, readingcode)\ + PREPARE_SENSORINTERFACE_DECLS(SensorClass, ReadingClass, FilterClass, readingcode)\ + PREPARE_SENSORINTERFACE_IMPLS(SensorClass, ReadingClass, FilterClass, readingcode) +#else +#define PREPARE_SENSORINTERFACE(SensorClass, ReadingClass, FilterClass, readingcode)\ + PREPARE_SENSORINTERFACE_DECLS(SensorClass, ReadingClass, FilterClass, readingcode) +#endif + +PREPARE_SENSORINTERFACE(QAccelerometer, QAccelerometerReading, QAccelerometerFilter, { + reading->setTimestamp(1); + reading->setX(1.0); + reading->setY(1.0); + reading->setZ(1.0); +}) +PREPARE_SENSORINTERFACE(QAmbientLightSensor, QAmbientLightReading, QAmbientLightFilter, { + reading->setLightLevel(QAmbientLightReading::Twilight); +}) +PREPARE_SENSORINTERFACE(QAmbientTemperatureSensor, QAmbientTemperatureReading, QAmbientTemperatureFilter, { + reading->setTemperature(30); +}) +PREPARE_SENSORINTERFACE(QCompass, QCompassReading, QCompassFilter, { + reading->setAzimuth(1.0); + reading->setCalibrationLevel(1.0); +}) +PREPARE_SENSORINTERFACE(QGyroscope, QGyroscopeReading, QGyroscopeFilter, { + reading->setX(1.0); + reading->setY(1.0); + reading->setZ(1.0); +}) +PREPARE_SENSORINTERFACE(QLightSensor, QLightReading, QLightFilter, { + reading->setLux(1.0); +}) +PREPARE_SENSORINTERFACE(QMagnetometer, QMagnetometerReading, QMagnetometerFilter, { + reading->setX(1.0); + reading->setY(1.0); + reading->setZ(1.0); + reading->setCalibrationLevel(1.0); +}) +PREPARE_SENSORINTERFACE(QOrientationSensor, QOrientationReading, QOrientationFilter, { + reading->setOrientation(QOrientationReading::LeftUp); +}) +PREPARE_SENSORINTERFACE(QPressureSensor, QPressureReading, QPressureFilter, { + reading->setPressure(1.0); + reading->setTemperature(1.0); +}) +PREPARE_SENSORINTERFACE(QProximitySensor, QProximityReading, QProximityFilter, { + reading->setClose(true); +}) +PREPARE_SENSORINTERFACE(QRotationSensor, QRotationReading, QRotationFilter, { + reading->setFromEuler(1.0, 1.0, 1.0); +}) +PREPARE_SENSORINTERFACE(QTapSensor, QTapReading, QTapFilter, { + reading->setTapDirection(QTapReading::Z_Both); + reading->setDoubleTap(true); +}) +PREPARE_SENSORINTERFACE(QIRProximitySensor, QIRProximityReading, QIRProximityFilter, { + reading->setReflectance(0.5); +}) +PREPARE_SENSORINTERFACE(QTiltSensor, QTiltReading, QTiltFilter, { + reading->setYRotation(1.0); + reading->setXRotation(1.0); +}) +PREPARE_SENSORINTERFACE(QLidSensor, QLidReading, QLidFilter, { + reading->setBackLidClosed(true); + reading->setFrontLidClosed(true); +}) +PREPARE_SENSORINTERFACE(QHumiditySensor, QHumidityReading, QHumidityFilter, { + reading->setRelativeHumidity(1.0); + reading->setAbsoluteHumidity(1.0); +}) + + +#define TEST_SENSORINTERFACE(SensorClass, ReadingClass, readingcode)\ + do {\ + SensorClass sensor;\ + sensor.setIdentifier(#SensorClass); \ + SensorClass ## _testfilter filter;\ + sensor.addFilter(&filter);\ + sensor.start();\ + ReadingClass *reading = sensor.reading();\ + readingcode\ + } while (0); + +#endif |