Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QtTest/QtTest>
#include <QDebug>
#include <QVariant>
#include <QList>
#include <QLoggingCategory>
#include "../../shared/bttestutil_p.h"
#include <private/qtbluetoothglobal_p.h>
#include <qbluetoothaddress.h>
#include <qbluetoothdevicediscoveryagent.h>
#include <qbluetoothlocaldevice.h>
#if QT_CONFIG(permissions)
#include <QtCore/qcoreapplication.h>
#include <QtCore/qpermissions.h>
#include <QtCore/qnamespace.h>
#endif // permissions
#ifdef Q_OS_ANDROID
#include <QtCore/qjnienvironment.h>
#endif
#ifdef Q_OS_WIN
#include <objbase.h> // for CoInitializeEx() and friends
#endif
#include <memory>
using namespace Qt::StringLiterals;
QT_USE_NAMESPACE
/*
* Some parts of this test require a remote and discoverable Bluetooth
* device. Setting the BT_TEST_DEVICE environment variable will
* set the test up to fail if it cannot find a remote device.
* BT_TEST_DEVICE should contain the address of the device the
* test expects to find. Ensure that the device is running
* in discovery mode.
**/
// Maximum time to for bluetooth device scan
const int MaxScanTime = 5 * 60 * 1000; // 5 minutes in ms
//Bluez needs at least 10s for a device discovery to be cancelled
const int MaxWaitForCancelTime = 15 * 1000; // 15 seconds in ms
#ifdef Q_OS_ANDROID
// Android is sometimes unable to cancel immediately
const int WaitBeforeStopTime = 200;
extern void testEnumToString(std::function<void(const char*, int)> callback);
extern void parseScanRecord(QBluetoothDeviceInfo &, jbyteArray);
#endif
class tst_QBluetoothDeviceDiscoveryAgent : public QObject
{
Q_OBJECT
public:
tst_QBluetoothDeviceDiscoveryAgent();
~tst_QBluetoothDeviceDiscoveryAgent();
public slots:
void deviceDiscoveryDebug(const QBluetoothDeviceInfo &info);
void finished();
private slots:
void initTestCase();
void tst_invalidBtAddress();
void tst_startStopDeviceDiscoveries();
void tst_deviceDiscovery();
void tst_discoveryTimeout();
void tst_discoveryMethods();
void tst_majorMinorMapping();
void tst_androidScanRecordParsing_data();
void tst_androidScanRecordParsing();
void tst_windowsDiscoveryInThread_data();
void tst_windowsDiscoveryInThread();
private:
qsizetype noOfLocalDevices;
using DiscoveryAgentPtr = std::unique_ptr<QBluetoothDeviceDiscoveryAgent>;
#if QT_CONFIG(permissions)
Qt::PermissionStatus permissionStatus = Qt::PermissionStatus::Undetermined;
#endif
};
tst_QBluetoothDeviceDiscoveryAgent::tst_QBluetoothDeviceDiscoveryAgent()
{
QLoggingCategory::setFilterRules(QStringLiteral("qt.bluetooth* = true"));
qRegisterMetaType<QBluetoothDeviceDiscoveryAgent::Error>();
#if QT_CONFIG(permissions)
permissionStatus = qApp->checkPermission(QBluetoothPermission{});
const bool ciRun = qEnvironmentVariable("QTEST_ENVIRONMENT").split(' ').contains("ci");
if (!ciRun && permissionStatus == Qt::PermissionStatus::Undetermined) {
QTestEventLoop loop;
qApp->requestPermission(QBluetoothPermission{},
&loop, [this, &loop](const QPermission &permission) {
permissionStatus = permission.status();
loop.exitLoop();
});
if (permissionStatus == Qt::PermissionStatus::Undetermined)
loop.enterLoopMSecs(30000);
}
#endif // QT_CONFIG(permissions)
}
tst_QBluetoothDeviceDiscoveryAgent::~tst_QBluetoothDeviceDiscoveryAgent()
{
}
void tst_QBluetoothDeviceDiscoveryAgent::initTestCase()
{
qRegisterMetaType<QBluetoothDeviceInfo>();
noOfLocalDevices = QBluetoothLocalDevice::allDevices().size();
if (!noOfLocalDevices)
return;
// turn on BT in case it is not on
QBluetoothLocalDevice *device = new QBluetoothLocalDevice();
if (device->hostMode() == QBluetoothLocalDevice::HostPoweredOff) {
QSignalSpy hostModeSpy(device, SIGNAL(hostModeStateChanged(QBluetoothLocalDevice::HostMode)));
QVERIFY(hostModeSpy.isEmpty());
device->powerOn();
int connectTime = 5000; // ms
while (hostModeSpy.isEmpty() && connectTime > 0) {
QTest::qWait(500);
connectTime -= 500;
}
QVERIFY(!hostModeSpy.isEmpty());
}
QBluetoothLocalDevice::HostMode hostMode= device->hostMode();
QVERIFY(hostMode == QBluetoothLocalDevice::HostConnectable
|| hostMode == QBluetoothLocalDevice::HostDiscoverable
|| hostMode == QBluetoothLocalDevice::HostDiscoverableLimitedInquiry);
delete device;
}
void tst_QBluetoothDeviceDiscoveryAgent::tst_invalidBtAddress()
{
DiscoveryAgentPtr discoveryAgent(new QBluetoothDeviceDiscoveryAgent(
QBluetoothAddress(QStringLiteral("11:11:11:11:11:11"))));
QCOMPARE(discoveryAgent->error(), QBluetoothDeviceDiscoveryAgent::InvalidBluetoothAdapterError);
discoveryAgent->start();
QCOMPARE(discoveryAgent->isActive(), false);
#if QT_CONFIG(permissions)
if (permissionStatus != Qt::PermissionStatus::Granted)
return;
#endif
discoveryAgent.reset(new QBluetoothDeviceDiscoveryAgent(QBluetoothAddress()));
QCOMPARE(discoveryAgent->error(), QBluetoothDeviceDiscoveryAgent::NoError);
if (!QBluetoothLocalDevice::allDevices().isEmpty()) {
discoveryAgent->start();
QCOMPARE(discoveryAgent->isActive(), true);
}
}
void tst_QBluetoothDeviceDiscoveryAgent::deviceDiscoveryDebug(const QBluetoothDeviceInfo &info)
{
qDebug() << "Discovered device:" << info.address().toString() << info.name();
}
void tst_QBluetoothDeviceDiscoveryAgent::tst_startStopDeviceDiscoveries()
{
QBluetoothDeviceDiscoveryAgent discoveryAgent;
QVERIFY(discoveryAgent.error() == discoveryAgent.NoError);
QVERIFY(discoveryAgent.errorString().isEmpty());
QVERIFY(!discoveryAgent.isActive());
QVERIFY(discoveryAgent.discoveredDevices().isEmpty());
QSignalSpy finishedSpy(&discoveryAgent, SIGNAL(finished()));
QSignalSpy cancelSpy(&discoveryAgent, SIGNAL(canceled()));
QSignalSpy errorSpy(&discoveryAgent,
SIGNAL(errorOccurred(QBluetoothDeviceDiscoveryAgent::Error)));
// Starting case 1: start-stop, expecting cancel signal
// we should have no errors at this point.
QVERIFY(errorSpy.isEmpty());
discoveryAgent.start();
#if QT_CONFIG(permissions)
if (permissionStatus != Qt::PermissionStatus::Granted) {
// If bluetooth is OFF, the permission does not get checked (e.g. on Darwin),
// but not to depend on the order in which errors generated, we
// do not compare error value with MissionPermissionsError here.
return;
}
#endif
if (errorSpy.isEmpty()) {
QVERIFY(discoveryAgent.isActive());
QCOMPARE(discoveryAgent.errorString(), QString());
QCOMPARE(discoveryAgent.error(), QBluetoothDeviceDiscoveryAgent::NoError);
} else {
QCOMPARE(noOfLocalDevices, 0);
QVERIFY(!discoveryAgent.isActive());
QVERIFY(!discoveryAgent.errorString().isEmpty());
QVERIFY(discoveryAgent.error() != QBluetoothDeviceDiscoveryAgent::NoError);
QSKIP("No local Bluetooth device available. Skipping remaining part of test.");
}
// cancel current request.
#ifdef Q_OS_ANDROID
// Android sometimes can't cancel immediately (~on the same millisecond),
// but instead a "pending cancel" happens, which means the discovery will be
// canceled at a later point in time. When this happens the Android backend
// also emits an immediate errorOccurred(). While this seems to be as intended,
// as a result many parts of this test function may fail (not always).
//
// In this test function we wait some milliseconds between start() and stop() to
// bypass this behavior difference. This is to avoid complex iffery (Android itself
// can behave differently every time) and ifdeffery (Q_OS_ANDROID) in the test
QTest::qWait(WaitBeforeStopTime);
#endif
discoveryAgent.stop();
// Wait for up to MaxWaitForCancelTime for the cancel to finish
QTRY_VERIFY_WITH_TIMEOUT(!cancelSpy.isEmpty(), MaxWaitForCancelTime);
// we should not be active anymore
QVERIFY(!discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
QCOMPARE(cancelSpy.size(), 1);
cancelSpy.clear();
// Starting case 2: start-start-stop, expecting cancel signal
discoveryAgent.start();
// we should be active now
QVERIFY(discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
// start again. should this be error?
discoveryAgent.start();
QVERIFY(discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
// stop
#ifdef Q_OS_ANDROID
QTest::qWait(WaitBeforeStopTime);
#endif
discoveryAgent.stop();
// Wait for up to MaxWaitForCancelTime for the cancel to finish
QTRY_VERIFY_WITH_TIMEOUT(!cancelSpy.isEmpty(), MaxWaitForCancelTime);
// we should not be active anymore
QVERIFY(!discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
QCOMPARE(cancelSpy.size(), 1);
cancelSpy.clear();
// Starting case 3: stop
discoveryAgent.stop();
QVERIFY(!discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
// Don't expect finished signal and no error
QVERIFY(finishedSpy.isEmpty());
QVERIFY(discoveryAgent.error() == discoveryAgent.NoError);
QVERIFY(discoveryAgent.errorString().isEmpty());
/*
Starting case 4: start-stop-start-stop:
We are testing that two subsequent stop() calls reduce total number
of cancel() signals to 1 if the true cancellation requires
asynchronous function calls (signal consolidation); otherwise we
expect 2x cancel() signal.
Examples are:
- Bluez4 (event loop needs to run for cancel)
- Bluez5 (no event loop required)
*/
bool immediateSignal = false;
discoveryAgent.start();
QVERIFY(discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
// cancel current request.
#ifdef Q_OS_ANDROID
QTest::qWait(WaitBeforeStopTime);
#endif
discoveryAgent.stop();
//should only have triggered cancel() if stop didn't involve the event loop
if (cancelSpy.size() == 1) immediateSignal = true;
// start a new one
discoveryAgent.start();
// we should be active now
QVERIFY(discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
// stop
#ifdef Q_OS_ANDROID
QTest::qWait(WaitBeforeStopTime);
#endif
discoveryAgent.stop();
if (immediateSignal)
QCOMPARE(cancelSpy.size(), 2);
// Wait for up to MaxWaitForCancelTime for the cancel to finish
QTRY_VERIFY_WITH_TIMEOUT(!cancelSpy.isEmpty(), MaxWaitForCancelTime);
// we should not be active anymore
QVERIFY(!discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
// should only have 1 cancel
if (immediateSignal)
QCOMPARE(cancelSpy.size(), 2);
else
QCOMPARE(cancelSpy.size(), 1);
cancelSpy.clear();
// Starting case 5: start-stop-start: expecting finished signal & no cancel
discoveryAgent.start();
QVERIFY(discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
// cancel current request.
#ifdef Q_OS_ANDROID
QTest::qWait(WaitBeforeStopTime);
#endif
discoveryAgent.stop();
// start a new one
discoveryAgent.start();
// we should be active now
QVERIFY(discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
// Wait for up to MaxScanTime for the scan to finish
QTRY_VERIFY_WITH_TIMEOUT(!finishedSpy.isEmpty(), MaxScanTime);
// we should not be active anymore
QVERIFY(!discoveryAgent.isActive());
QVERIFY(errorSpy.isEmpty());
// should only have 1 cancel
QCOMPARE(finishedSpy.size(), 1);
// On OS X, stop is synchronous (signal will be emitted immediately).
if (!immediateSignal)
QVERIFY(cancelSpy.isEmpty());
}
void tst_QBluetoothDeviceDiscoveryAgent::finished()
{
qDebug() << "Finished called";
}
void tst_QBluetoothDeviceDiscoveryAgent::tst_deviceDiscovery()
{
{
//Run test in case of multiple Bluetooth adapters
QBluetoothLocalDevice localDevice;
//We will use default adapter if there is no other adapter
QBluetoothAddress address = localDevice.address();
QBluetoothDeviceDiscoveryAgent discoveryAgent(address);
QVERIFY(discoveryAgent.error() == discoveryAgent.NoError);
QVERIFY(discoveryAgent.errorString().isEmpty());
QVERIFY(!discoveryAgent.isActive());
QVERIFY(discoveryAgent.discoveredDevices().isEmpty());
QSignalSpy finishedSpy(&discoveryAgent, SIGNAL(finished()));
QSignalSpy errorSpy(&discoveryAgent,
SIGNAL(errorOccurred(QBluetoothDeviceDiscoveryAgent::Error)));
QSignalSpy discoveredSpy(&discoveryAgent, SIGNAL(deviceDiscovered(QBluetoothDeviceInfo)));
// connect(&discoveryAgent, SIGNAL(finished()), this, SLOT(finished()));
// connect(&discoveryAgent, SIGNAL(deviceDiscovered(QBluetoothDeviceInfo)),
// this, SLOT(deviceDiscoveryDebug(QBluetoothDeviceInfo)));
discoveryAgent.start();
if (!errorSpy.isEmpty()) {
#if QT_CONFIG(permissions)
if (permissionStatus == Qt::PermissionStatus::Granted)
#endif
QCOMPARE(noOfLocalDevices, 0);
QVERIFY(!discoveryAgent.isActive());
QSKIP("No local Bluetooth device available. Skipping remaining part of test.");
}
QVERIFY(discoveryAgent.isActive());
// Wait for up to MaxScanTime for the scan to finish
int scanTime = MaxScanTime;
while (finishedSpy.isEmpty() && scanTime > 0) {
QTest::qWait(15000);
scanTime -= 15000;
}
// verify that we are finished
QVERIFY(!discoveryAgent.isActive());
// stop
discoveryAgent.stop();
QVERIFY(!discoveryAgent.isActive());
qDebug() << "Scan time left:" << scanTime;
// Expect finished signal with no error
QVERIFY(finishedSpy.size() == 1);
QVERIFY(errorSpy.isEmpty());
QVERIFY(discoveryAgent.error() == discoveryAgent.NoError);
QVERIFY(discoveryAgent.errorString().isEmpty());
// verify that the list is as big as the signals received.
// discoveredSpy might have more events as some devices are found multiple times,
// leading to messages like
// "Almost Duplicate "88:C6:26:F5:3E:E2" "88-C6-26-F5-3E-E2" - replacing in place"
QVERIFY(discoveredSpy.size() >= discoveryAgent.discoveredDevices().size());
// verify that there really was some devices in the array
const QString remote = qEnvironmentVariable("BT_TEST_DEVICE");
QBluetoothAddress remoteDevice;
if (!remote.isEmpty()) {
remoteDevice = QBluetoothAddress(remote);
QVERIFY2(!remote.isNull(), "Expecting valid Bluetooth address to be passed via BT_TEST_DEVICE");
} else {
qWarning() << "Not using a remote device for testing. Set BT_TEST_DEVICE env to run extended tests involving a remote device";
}
if (!remoteDevice.isNull())
QVERIFY(!discoveredSpy.isEmpty());
// All returned QBluetoothDeviceInfo should be valid.
while (!discoveredSpy.isEmpty()) {
const QBluetoothDeviceInfo info =
qvariant_cast<QBluetoothDeviceInfo>(discoveredSpy.takeFirst().at(0));
QVERIFY(info.isValid());
}
}
}
void tst_QBluetoothDeviceDiscoveryAgent::tst_discoveryTimeout()
{
QBluetoothDeviceDiscoveryAgent agent;
// check default values
#if defined(Q_OS_MACOS) || defined(Q_OS_IOS) || defined(Q_OS_ANDROID) || QT_CONFIG(winrt_bt) \
|| QT_CONFIG(bluez)
QCOMPARE(agent.lowEnergyDiscoveryTimeout(), 40000);
agent.setLowEnergyDiscoveryTimeout(-1); // negative ignored
QCOMPARE(agent.lowEnergyDiscoveryTimeout(), 40000);
agent.setLowEnergyDiscoveryTimeout(20000);
QCOMPARE(agent.lowEnergyDiscoveryTimeout(), 20000);
#else
QCOMPARE(agent.lowEnergyDiscoveryTimeout(), -1);
agent.setLowEnergyDiscoveryTimeout(20000); // feature not supported -> ignored
QCOMPARE(agent.lowEnergyDiscoveryTimeout(), -1);
#endif
}
void tst_QBluetoothDeviceDiscoveryAgent::tst_discoveryMethods()
{
const QBluetoothLocalDevice localDevice;
if (localDevice.allDevices().size() != 1) {
// On iOS it returns 0 but we still have working BT.
#ifndef Q_OS_IOS
QSKIP("This test expects exactly one local device working");
#endif
}
const QBluetoothDeviceDiscoveryAgent::DiscoveryMethods
supportedMethods = QBluetoothDeviceDiscoveryAgent::supportedDiscoveryMethods();
QVERIFY(supportedMethods != QBluetoothDeviceDiscoveryAgent::NoMethod);
QBluetoothDeviceDiscoveryAgent::DiscoveryMethod
unsupportedMethods = QBluetoothDeviceDiscoveryAgent::NoMethod;
QBluetoothDeviceInfo::CoreConfiguration
expectedConfiguration = QBluetoothDeviceInfo::BaseRateAndLowEnergyCoreConfiguration;
if (supportedMethods == QBluetoothDeviceDiscoveryAgent::ClassicMethod) {
unsupportedMethods = QBluetoothDeviceDiscoveryAgent::LowEnergyMethod;
expectedConfiguration = QBluetoothDeviceInfo::BaseRateCoreConfiguration;
} else if (supportedMethods == QBluetoothDeviceDiscoveryAgent::LowEnergyMethod) {
unsupportedMethods = QBluetoothDeviceDiscoveryAgent::ClassicMethod;
expectedConfiguration = QBluetoothDeviceInfo::LowEnergyCoreConfiguration;
}
QBluetoothDeviceDiscoveryAgent agent;
QSignalSpy finishedSpy(&agent, SIGNAL(finished()));
QSignalSpy errorSpy(&agent, SIGNAL(errorOccurred(QBluetoothDeviceDiscoveryAgent::Error)));
QSignalSpy discoveredSpy(&agent, SIGNAL(deviceDiscovered(QBluetoothDeviceInfo)));
// NoMethod - should just immediately return:
agent.start(QBluetoothDeviceDiscoveryAgent::NoMethod);
QCOMPARE(agent.error(), QBluetoothDeviceDiscoveryAgent::NoError);
QVERIFY(!agent.isActive());
QCOMPARE(finishedSpy.size(), 0);
QCOMPARE(errorSpy.size(), 0);
QCOMPARE(discoveredSpy.size(), 0);
if (unsupportedMethods != QBluetoothDeviceDiscoveryAgent::NoMethod) {
agent.start(unsupportedMethods);
QCOMPARE(agent.error(), QBluetoothDeviceDiscoveryAgent::UnsupportedDiscoveryMethod);
QVERIFY(!agent.isActive());
QVERIFY(finishedSpy.isEmpty());
QCOMPARE(errorSpy.size(), 1);
errorSpy.clear();
QVERIFY(discoveredSpy.isEmpty());
}
// Start discovery, probably both Classic and LE methods:
agent.start(supportedMethods);
#if QT_CONFIG(permissions)
if (permissionStatus != Qt::PermissionStatus::Granted) {
QCOMPARE(agent.error(), QBluetoothDeviceDiscoveryAgent::MissingPermissionsError);
QSKIP("The remaining test requires the Bluetooth permission granted");
}
#endif
QVERIFY(agent.isActive());
QVERIFY(errorSpy.isEmpty());
#define RUN_DISCOVERY(maxTimeout, step, condition) \
for (int scanTime = maxTimeout; (condition) && scanTime > 0; scanTime -= step) \
QTest::qWait(step);
// Wait for up to MaxScanTime for the scan to finish
const int timeStep = 15000;
RUN_DISCOVERY(MaxScanTime, timeStep, finishedSpy.isEmpty())
QVERIFY(!agent.isActive());
QVERIFY(errorSpy.size() <= 1);
if (errorSpy.size()) {
// For example, old iOS device could report it supports LE method,
// but it actually does not.
QVERIFY(supportedMethods == QBluetoothDeviceDiscoveryAgent::LowEnergyMethod);
QCOMPARE(agent.error(), QBluetoothDeviceDiscoveryAgent::UnsupportedDiscoveryMethod);
} else {
QVERIFY(finishedSpy.size() == 1);
QVERIFY(agent.error() == QBluetoothDeviceDiscoveryAgent::NoError);
QVERIFY(agent.errorString().isEmpty());
while (!discoveredSpy.isEmpty()) {
const QBluetoothDeviceInfo info =
qvariant_cast<QBluetoothDeviceInfo>(discoveredSpy.takeFirst().at(0));
QVERIFY(info.isValid());
// on Android we do find devices with unknown configuration
if (info.coreConfigurations() != QBluetoothDeviceInfo::UnknownCoreConfiguration)
QVERIFY(info.coreConfigurations() & expectedConfiguration);
}
}
if (unsupportedMethods != QBluetoothDeviceDiscoveryAgent::NoMethod)
return;
// Both methods were reported as supported. We already tested them
// above, now let's test first Classic then LE.
finishedSpy.clear();
errorSpy.clear();
discoveredSpy.clear();
agent.start(QBluetoothDeviceDiscoveryAgent::ClassicMethod);
QVERIFY(agent.isActive());
QVERIFY(errorSpy.isEmpty());
QCOMPARE(agent.error(), QBluetoothDeviceDiscoveryAgent::NoError);
RUN_DISCOVERY(MaxScanTime, timeStep, finishedSpy.isEmpty())
QVERIFY(!agent.isActive());
QVERIFY(errorSpy.isEmpty());
QCOMPARE(finishedSpy.size(), 1);
finishedSpy.clear();
discoveredSpy.clear();
agent.start(QBluetoothDeviceDiscoveryAgent::LowEnergyMethod);
QVERIFY(agent.isActive());
QVERIFY(errorSpy.isEmpty());
RUN_DISCOVERY(MaxScanTime, timeStep, finishedSpy.isEmpty() && errorSpy.isEmpty())
QVERIFY(!agent.isActive());
QVERIFY(errorSpy.size() <= 1);
if (errorSpy.size()) {
QCOMPARE(agent.error(), QBluetoothDeviceDiscoveryAgent::UnsupportedDiscoveryMethod);
qDebug() << "QBluetoothDeviceDiscoveryAgent::supportedDiscoveryMethods is inaccurate"
" on your platform/with your device, LowEnergyMethod is not supported";
} else {
QCOMPARE(agent.error(), QBluetoothDeviceDiscoveryAgent::NoError);
QCOMPARE(finishedSpy.size(), 1);
}
}
void tst_QBluetoothDeviceDiscoveryAgent::tst_majorMinorMapping()
{
#if !defined(Q_OS_ANDROID)
QSKIP("This test is only pertinent to Android!");
#else
const QMap<QLatin1StringView, int> expectedMapping = {
// AUDIO_VIDEO
{ "AUDIO_VIDEO_CAMCORDER"_L1, QBluetoothDeviceInfo::Camcorder },
{ "AUDIO_VIDEO_CAR_AUDIO"_L1, QBluetoothDeviceInfo::CarAudio },
{ "AUDIO_VIDEO_HANDSFREE"_L1, QBluetoothDeviceInfo::HandsFreeDevice },
{ "AUDIO_VIDEO_HEADPHONES"_L1, QBluetoothDeviceInfo::Headphones },
{ "AUDIO_VIDEO_HIFI_AUDIO"_L1, QBluetoothDeviceInfo::HiFiAudioDevice },
{ "AUDIO_VIDEO_LOUDSPEAKER"_L1, QBluetoothDeviceInfo::Loudspeaker },
{ "AUDIO_VIDEO_MICROPHONE"_L1, QBluetoothDeviceInfo::Microphone },
{ "AUDIO_VIDEO_PORTABLE_AUDIO"_L1, QBluetoothDeviceInfo::PortableAudioDevice },
{ "AUDIO_VIDEO_SET_TOP_BOX"_L1, QBluetoothDeviceInfo::SetTopBox },
{ "AUDIO_VIDEO_UNCATEGORIZED"_L1, QBluetoothDeviceInfo::UncategorizedAudioVideoDevice },
{ "AUDIO_VIDEO_VCR"_L1, QBluetoothDeviceInfo::Vcr },
{ "AUDIO_VIDEO_VIDEO_CAMERA"_L1, QBluetoothDeviceInfo::VideoCamera },
{ "AUDIO_VIDEO_VIDEO_CONFERENCING"_L1, QBluetoothDeviceInfo::VideoConferencing },
{ "AUDIO_VIDEO_VIDEO_DISPLAY_AND_LOUDSPEAKER"_L1, QBluetoothDeviceInfo::VideoDisplayAndLoudspeaker },
{ "AUDIO_VIDEO_VIDEO_GAMING_TOY"_L1, QBluetoothDeviceInfo::GamingDevice },
{ "AUDIO_VIDEO_VIDEO_MONITOR"_L1, QBluetoothDeviceInfo::VideoMonitor },
{ "AUDIO_VIDEO_WEARABLE_HEADSET"_L1, QBluetoothDeviceInfo::WearableHeadsetDevice },
// COMPUTER
{ "COMPUTER_UNCATEGORIZED"_L1, QBluetoothDeviceInfo::UncategorizedComputer },
{ "COMPUTER_DESKTOP"_L1, QBluetoothDeviceInfo::DesktopComputer },
{ "COMPUTER_HANDHELD_PC_PDA"_L1, QBluetoothDeviceInfo::HandheldComputer },
{ "COMPUTER_LAPTOP"_L1, QBluetoothDeviceInfo::LaptopComputer },
{ "COMPUTER_PALM_SIZE_PC_PDA"_L1, QBluetoothDeviceInfo::HandheldClamShellComputer },
{ "COMPUTER_SERVER"_L1, QBluetoothDeviceInfo::ServerComputer },
{ "COMPUTER_WEARABLE"_L1, QBluetoothDeviceInfo::WearableComputer },
// HEALTH
{ "HEALTH_BLOOD_PRESSURE"_L1, QBluetoothDeviceInfo::HealthBloodPressureMonitor },
{ "HEALTH_DATA_DISPLAY"_L1, QBluetoothDeviceInfo::HealthDataDisplay },
{ "HEALTH_GLUCOSE"_L1, QBluetoothDeviceInfo::HealthGlucoseMeter },
{ "HEALTH_PULSE_OXIMETER"_L1, QBluetoothDeviceInfo::HealthPulseOximeter },
{ "HEALTH_PULSE_RATE"_L1, QBluetoothDeviceInfo::HealthStepCounter },
{ "HEALTH_THERMOMETER"_L1, QBluetoothDeviceInfo::HealthThermometer },
{ "HEALTH_UNCATEGORIZED"_L1, QBluetoothDeviceInfo::UncategorizedHealthDevice },
{ "HEALTH_WEIGHING"_L1, QBluetoothDeviceInfo::HealthWeightScale },
// PHONE
{ "PHONE_CELLULAR"_L1, QBluetoothDeviceInfo::CellularPhone },
{ "PHONE_CORDLESS"_L1, QBluetoothDeviceInfo::CordlessPhone },
{ "PHONE_ISDN"_L1, QBluetoothDeviceInfo::CommonIsdnAccessPhone },
{ "PHONE_MODEM_OR_GATEWAY"_L1, QBluetoothDeviceInfo::WiredModemOrVoiceGatewayPhone },
{ "PHONE_SMART"_L1, QBluetoothDeviceInfo::SmartPhone },
{ "PHONE_UNCATEGORIZED"_L1, QBluetoothDeviceInfo::UncategorizedPhone },
// TOY
{ "TOY_CONTROLLER"_L1, QBluetoothDeviceInfo::ToyController },
{ "TOY_DOLL_ACTION_FIGURE"_L1, QBluetoothDeviceInfo::ToyDoll },
{ "TOY_GAME"_L1, QBluetoothDeviceInfo::ToyGame },
{ "TOY_ROBOT"_L1, QBluetoothDeviceInfo::ToyRobot },
{ "TOY_UNCATEGORIZED"_L1, QBluetoothDeviceInfo::UncategorizedToy },
{ "TOY_VEHICLE"_L1, QBluetoothDeviceInfo::ToyVehicle },
// WEARABLE
{ "WEARABLE_GLASSES"_L1, QBluetoothDeviceInfo::WearableGlasses },
{ "WEARABLE_HELMET"_L1, QBluetoothDeviceInfo::WearableHelmet },
{ "WEARABLE_JACKET"_L1, QBluetoothDeviceInfo::WearableJacket },
{ "WEARABLE_PAGER"_L1, QBluetoothDeviceInfo::WearablePager },
{ "WEARABLE_UNCATEGORIZED"_L1, QBluetoothDeviceInfo::UncategorizedWearableDevice },
{ "WEARABLE_WRIST_WATCH"_L1, QBluetoothDeviceInfo::WearableWristWatch },
// PERIPHERAL
{ "PERIPHERAL_NON_KEYBOARD_NON_POINTING"_L1, QBluetoothDeviceInfo::UncategorizedPeripheral },
{ "PERIPHERAL_KEYBOARD"_L1, QBluetoothDeviceInfo::KeyboardPeripheral },
{ "PERIPHERAL_POINTING"_L1, QBluetoothDeviceInfo::PointingDevicePeripheral },
{ "PERIPHERAL_KEYBOARD_POINTING"_L1, QBluetoothDeviceInfo::KeyboardWithPointingDevicePeripheral }
};
qsizetype hits = 0;
testEnumToString([&](const char *generatedName, int minor) {
QLatin1StringView generatedNameL1(generatedName);
auto printOnFailure = qScopeGuard([&] { qDebug("%s", generatedName); });
QVERIFY(expectedMapping.contains(generatedNameL1));
int expectedValue = expectedMapping.value(generatedNameL1);
QCOMPARE(minor, expectedValue);
printOnFailure.dismiss();
++hits;
});
QCOMPARE(hits, expectedMapping.size());
#endif
}
void tst_QBluetoothDeviceDiscoveryAgent::tst_androidScanRecordParsing_data()
{
#ifndef Q_OS_ANDROID
QSKIP("This test only runs on Android");
#endif
QTest::addColumn<QByteArray>("scanRecord");
QTest::addColumn<int>("expectedServiceUuidCount");
QTest::addColumn<bool>("expectName");
QTest::addColumn<bool>("expectManufacturerData");
// -----------------------------------------------------------------------
// Baseline: well-formed scan record containing a 16-bit service UUID,
// a complete local name, and manufacturer-specific data.
// All three fields must be parsed correctly.
//
// Layout (each field: [nBytes] [ADType] [data...]):
// 02 01 06 -- Flags (ADType 0x01); not parsed by Qt, skipped
// 03 03 34 12 -- 16-bit UUID complete (0x1234 in little-endian)
// 05 09 54 65 73 74 -- Complete local name: "Test"
// 05 FF E0 00 AB CD -- Manufacturer data: company=0x00E0, payload=0xAB 0xCD
// -----------------------------------------------------------------------
QByteArray validRecord = QByteArray::fromHex("020106" // Flags
"03033412" // 16-bit UUID 0x1234
"050954657374"// "Test"
"05FFE000ABCD"); // Mfr data
QTest::newRow("valid_record") << validRecord << 1 << true << true;
QTest::newRow("zero_length") << QByteArray(1, 0x00) << 0 << false << false;
QByteArray truncated;
truncated += char(0x0A); // nBytes = 10, claims 9 bytes of name data
truncated += char(0x09); // ADType: complete local name
truncated += QByteArray("Hi"); // only 2 bytes available — record is truncated
QTest::newRow("truncated_record") << truncated << 0 << false << false;
// -----------------------------------------------------------------------
// Issue 1 – length byte with the high bit set (e.g. 0xFF).
//
// When the length field is read as a signed char (the bug), 0xFF becomes
// -1, making 'i += nBytes + 1' advance by zero — causing an infinite loop.
//
// This test will hang indefinitely with the unfixed implementation.
// -----------------------------------------------------------------------
QByteArray highBitLength;
highBitLength += char(0xFF); // length byte — high bit set
highBitLength += char(0x09); // ADType: complete local name
highBitLength += QByteArray(30, 'A'); // 30 bytes of name data
QTest::newRow("length_high_bit_set") << highBitLength << 0 << false << false;
// -----------------------------------------------------------------------
// Issue 2a – 128-bit UUID AD type with only 1 data byte (nBytes = 2).
//
// ADType128BitUuidComplete requires 16 bytes of data, so we'll read past
// the end of the buffer without a proper length check.
//
// After the fix (per-case guard: if (nBytes >= 17)), no read occurs and
// no UUID is produced.
// -----------------------------------------------------------------------
QByteArray short128BitUuid;
short128BitUuid += char(0x02); // nBytes = 2
short128BitUuid += char(0x07); // ADType128BitUuidComplete
short128BitUuid += char(0xAB); // only 1 data byte instead of 16
QTest::newRow("128bit_uuid_too_short") << short128BitUuid << 0 << false << false;
// -----------------------------------------------------------------------
// Issue 2b – 32-bit UUID AD type with only 1 data byte (nBytes = 2).
//
// ADType32BitUuidComplete requires 4 bytes of data, so we'll read past
// the end of the buffer without a proper length check.
//
// After the fix (per-case guard: if (nBytes >= 5)), no UUID is produced.
// -----------------------------------------------------------------------
QByteArray short32BitUuid;
short32BitUuid += char(0x02); // nBytes = 2
short32BitUuid += char(0x05); // ADType32BitUuidComplete
short32BitUuid += char(0xAB); // only 1 data byte instead of 4
QTest::newRow("32bit_uuid_too_short") << short32BitUuid << 0 << false << false;
// -----------------------------------------------------------------------
// Issue 2c – 16-bit UUID AD type with no data bytes (nBytes = 1).
//
// ADType16BitUuidComplete requires 2 bytes of data, so we'll read past
// the end of the buffer without a proper length check.
//
// After the fix (per-case guard: if (nBytes >= 3)), no UUID is produced.
// -----------------------------------------------------------------------
QByteArray short16BitUuid;
short16BitUuid += char(0x01); // nBytes = 1
short16BitUuid += char(0x03); // ADType16BitUuidComplete
// no data bytes — buffer ends here
QTest::newRow("16bit_uuid_too_short") << short16BitUuid << 0 << false << false;
}
#ifdef Q_OS_ANDROID
// Allocates a JVM byte array from a QByteArray. The caller is responsible for
// releasing the returned local reference via env->DeleteLocalRef().
static jbyteArray toJByteArray(QJniEnvironment &env, const QByteArray &data)
{
jbyteArray arr = env->NewByteArray(jsize(data.size()));
if (arr && !data.isEmpty())
env->SetByteArrayRegion(arr, 0, jsize(data.size()),
reinterpret_cast<const jbyte *>(data.constData()));
return arr;
}
#endif
void tst_QBluetoothDeviceDiscoveryAgent::tst_androidScanRecordParsing()
{
#ifdef Q_OS_ANDROID
QFETCH(QByteArray, scanRecord);
QFETCH(int, expectedServiceUuidCount);
QFETCH(bool, expectName);
QFETCH(bool, expectManufacturerData);
QBluetoothDeviceInfo info{ QBluetoothAddress("00:11:22:33:44:55"_L1), QString(), 0 };
QJniEnvironment env;
jbyteArray jScanRecord = toJByteArray(env, scanRecord);
parseScanRecord(info, jScanRecord);
env->DeleteLocalRef(jScanRecord);
QCOMPARE(info.serviceUuids().size(), expectedServiceUuidCount);
if (expectedServiceUuidCount > 0) {
// The valid-record row carries UUID 0x1234 — verify it was parsed correctly.
QVERIFY(info.serviceUuids().contains(QBluetoothUuid(quint16(0x1234))));
}
QCOMPARE(!info.name().isEmpty(), expectName);
if (expectManufacturerData) {
// The valid-record row carries manufacturer data for company 0x00E0.
const auto mfrData = info.manufacturerData();
QVERIFY(mfrData.contains(0x00E0));
QCOMPARE(mfrData.value(0x00E0), QByteArray::fromHex("ABCD"));
}
#endif
}
namespace {
enum class CoInitType {
Auto,
ManualApartment,
ManualMultithread,
};
} // namespace
void tst_QBluetoothDeviceDiscoveryAgent::tst_windowsDiscoveryInThread_data()
{
#ifndef Q_OS_WIN
QSKIP("This is a Windows only test");
#endif
QTest::addColumn<CoInitType>("coInitType");
QTest::newRow("default_CoInit") << CoInitType::Auto;
QTest::newRow("manual_multithreaded_CoInit") << CoInitType::ManualMultithread;
QTest::newRow("manual_apartment_CoInit") << CoInitType::ManualApartment;
}
class HelperContextObject : public QObject
{
Q_OBJECT
public slots:
void onDiscoveryError(QBluetoothDeviceDiscoveryAgent::Error err)
{
m_error = err;
}
void onFinished()
{
m_finished = true;
}
void onCanceled()
{
m_canceled = true;
}
public:
QBluetoothDeviceDiscoveryAgent::Error m_error = QBluetoothDeviceDiscoveryAgent::NoError;
bool m_finished = false;
bool m_canceled = false;
};
void tst_QBluetoothDeviceDiscoveryAgent::tst_windowsDiscoveryInThread()
{
#ifdef Q_OS_WIN
// This test checks that a Bluetooth device can be created in a secondary
// thread. The manualCoInit flag is used to emulate the situation when
// the secondary thread already called CoInitializeEx() with a different
// threading model.
QBluetoothLocalDevice localDevice;
QBluetoothAddress address = localDevice.address();
if (address.isNull())
QSKIP("No local Bluetooth adapter found!");
QFETCH(const CoInitType, coInitType);
HelperContextObject context;
using namespace std::chrono_literals;
static constexpr auto DiscoveryTimeout = 10000ms;
auto threadFunc = [coInitType, address, &context] {
switch (coInitType) {
case CoInitType::Auto:
break; // nothing to do
case CoInitType::ManualApartment:
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
break;
case CoInitType::ManualMultithread:
CoInitializeEx(NULL, COINIT_MULTITHREADED);
break;
}
auto guard = qScopeGuard([coInitType]{
if (coInitType != CoInitType::Auto)
CoUninitialize();
});
QBluetoothDeviceDiscoveryAgent discoveryAgent(address);
QObject::connect(&discoveryAgent, &QBluetoothDeviceDiscoveryAgent::finished,
&context, &HelperContextObject::onFinished);
QObject::connect(&discoveryAgent, &QBluetoothDeviceDiscoveryAgent::canceled,
&context, &HelperContextObject::onCanceled);
QObject::connect(&discoveryAgent, &QBluetoothDeviceDiscoveryAgent::errorOccurred,
&context, &HelperContextObject::onDiscoveryError);
discoveryAgent.start();
QTest::qWait(DiscoveryTimeout);
discoveryAgent.stop();
};
auto thread = std::unique_ptr<QThread>(QThread::create(std::move(threadFunc)));
thread->start();
QTRY_VERIFY_WITH_TIMEOUT(context.m_canceled || context.m_finished, DiscoveryTimeout * 2);
QCOMPARE(context.m_error, QBluetoothDeviceDiscoveryAgent::NoError);
#endif // Q_OS_WIN
}
QTEST_MAIN(tst_QBluetoothDeviceDiscoveryAgent)
#include "tst_qbluetoothdevicediscoveryagent.moc"