bluez-qt/autotests/mediaplayertest.cpp

0001 /*
0002  * SPDX-FileCopyrightText: 2014-2015 David Rosca <nowrep@gmail.com>
0003  *
0004  * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
0005  */
0006
0007 #include "mediaplayertest.h"
0008 #include "autotests.h"
0009 #include "initmanagerjob.h"
0010 #include "pendingcall.h"
0011 #include "services.h"
0012
0013 #include <QSignalSpy>
0014 #include <QTest>
0015
0016 namespace BluezQt
0017 {
0018 extern void bluezqt_initFakeBluezTestRun();
0019 }
0020
0021 using namespace BluezQt;
0022
0023 Q_DECLARE_METATYPE(MediaPlayer::Equalizer)
0024 Q_DECLARE_METATYPE(MediaPlayer::Repeat)
0025 Q_DECLARE_METATYPE(MediaPlayer::Shuffle)
0026 Q_DECLARE_METATYPE(MediaPlayer::Status)
0027
0028 MediaPlayerTest::MediaPlayerTest()
0029     : m_manager(nullptr)
0030 {
0031     Autotests::registerMetatypes();
0032
0033     qRegisterMetaType<MediaPlayer::Equalizer>("Equalizer");
0034     qRegisterMetaType<MediaPlayer::Repeat>("Repeat");
0035     qRegisterMetaType<MediaPlayer::Shuffle>("Shuffle");
0036     qRegisterMetaType<MediaPlayer::Status>("Status");
0037     qRegisterMetaType<MediaPlayerTrack>("MediaPlayerTrack");
0038 }
0039
0040 void MediaPlayerTest::initTestCase()
0041 {
0042     bluezqt_initFakeBluezTestRun();
0043
0044     FakeBluez::start();
0045     FakeBluez::runTest(QStringLiteral("bluez-standard"));
0046
0047     // Create adapter
0048     QString adapter = QStringLiteral("/org/bluez/hci0");
0049     QVariantMap adapterProps;
0050     adapterProps[QStringLiteral("Path")] = QVariant::fromValue(QDBusObjectPath(adapter));
0051     adapterProps[QStringLiteral("Address")] = QStringLiteral("1C:E5:C3:BC:94:7E");
0052     adapterProps[QStringLiteral("Name")] = QStringLiteral("TestAdapter");
0053     FakeBluez::runAction(QStringLiteral("devicemanager"), QStringLiteral("create-adapter"), adapterProps);
0054
0055     // Create devices
0056     QVariantMap deviceProps;
0057     QVariantMap mediaPlayerProps;
0058     QVariantMap trackProps;
0059
0060     QString device1 = adapter + QLatin1String("/dev_40_79_6A_0C_39_75");
0061     deviceProps[QStringLiteral("Path")] = QVariant::fromValue(QDBusObjectPath(device1));
0062     deviceProps[QStringLiteral("Adapter")] = QVariant::fromValue(QDBusObjectPath(adapter));
0063     deviceProps[QStringLiteral("Address")] = QStringLiteral("40:79:6A:0C:39:75");
0064     deviceProps[QStringLiteral("Name")] = QStringLiteral("TestDevice");
0065     deviceProps[QStringLiteral("UUIDs")] = QStringList(QStringLiteral("0000110E-0000-1000-8000-00805F9B34FB"));
0066     mediaPlayerProps[QStringLiteral("Path")] = QVariant::fromValue(QDBusObjectPath(device1 + QLatin1String("/player0")));
0067     mediaPlayerProps[QStringLiteral("Name")] = QStringLiteral("Player1");
0068     mediaPlayerProps[QStringLiteral("Equalizer")] = QStringLiteral("on");
0069     mediaPlayerProps[QStringLiteral("Repeat")] = QStringLiteral("singletrack");
0070     mediaPlayerProps[QStringLiteral("Shuffle")] = QStringLiteral("group");
0071     mediaPlayerProps[QStringLiteral("Status")] = QStringLiteral("stopped");
0072     mediaPlayerProps[QStringLiteral("Position")] = QVariant::fromValue(quint32(150));
0073     mediaPlayerProps[QStringLiteral("Device")] = QVariant::fromValue(QDBusObjectPath(device1));
0074     trackProps[QStringLiteral("Title")] = QStringLiteral("Song1");
0075     trackProps[QStringLiteral("Artist")] = QStringLiteral("Band1");
0076     trackProps[QStringLiteral("Album")] = QStringLiteral("First Album");
0077     trackProps[QStringLiteral("Genre")] = QStringLiteral("Rock");
0078     trackProps[QStringLiteral("NumberOfTracks")] = 24;
0079     trackProps[QStringLiteral("TrackNumber")] = 4;
0080     trackProps[QStringLiteral("Duration")] = 12403;
0081     mediaPlayerProps[QStringLiteral("Track")] = trackProps;
0082     deviceProps[QStringLiteral("MediaPlayer")] = mediaPlayerProps;
0083     FakeBluez::runAction(QStringLiteral("devicemanager"), QStringLiteral("create-device"), deviceProps);
0084
0085     QString device2 = adapter + QLatin1String("/dev_50_79_6A_0C_39_75");
0086     deviceProps[QStringLiteral("Path")] = QVariant::fromValue(QDBusObjectPath(device2));
0087     deviceProps[QStringLiteral("Adapter")] = QVariant::fromValue(QDBusObjectPath(adapter));
0088     deviceProps[QStringLiteral("Address")] = QStringLiteral("50:79:6A:0C:39:75");
0089     deviceProps[QStringLiteral("Name")] = QStringLiteral("TestDevice2");
0090     deviceProps[QStringLiteral("UUIDs")] = QStringList(QStringLiteral("0000110E-0000-1000-8000-00805F9B34FB"));
0091     mediaPlayerProps[QStringLiteral("Path")] = QVariant::fromValue(QDBusObjectPath(device2 + QLatin1String("/player0")));
0092     mediaPlayerProps[QStringLiteral("Name")] = QStringLiteral("Player2");
0093     mediaPlayerProps[QStringLiteral("Equalizer")] = QStringLiteral("off");
0094     mediaPlayerProps[QStringLiteral("Repeat")] = QStringLiteral("alltracks");
0095     mediaPlayerProps[QStringLiteral("Shuffle")] = QStringLiteral("off");
0096     mediaPlayerProps[QStringLiteral("Status")] = QStringLiteral("paused");
0097     mediaPlayerProps[QStringLiteral("Position")] = QVariant::fromValue(quint32(2500));
0098     mediaPlayerProps[QStringLiteral("Device")] = QVariant::fromValue(QDBusObjectPath(device2));
0099     trackProps[QStringLiteral("Title")] = QStringLiteral("Song2");
0100     trackProps[QStringLiteral("Artist")] = QStringLiteral("Band2");
0101     trackProps[QStringLiteral("Album")] = QStringLiteral("Second Album");
0102     trackProps[QStringLiteral("Genre")] = QStringLiteral("Heavy Metal");
0103     trackProps[QStringLiteral("NumberOfTracks")] = 666;
0104     trackProps[QStringLiteral("TrackNumber")] = 22;
0105     trackProps[QStringLiteral("Duration")] = 22403;
0106     mediaPlayerProps[QStringLiteral("Track")] = trackProps;
0107     deviceProps[QStringLiteral("MediaPlayer")] = mediaPlayerProps;
0108     FakeBluez::runAction(QStringLiteral("devicemanager"), QStringLiteral("create-device"), deviceProps);
0109
0110     m_manager = new Manager();
0111     InitManagerJob *initJob = m_manager->init();
0112     initJob->exec();
0113     QVERIFY(!initJob->error());
0114
0115     QCOMPARE(m_manager->adapters().count(), 1);
0116     QCOMPARE(m_manager->devices().count(), 2);
0117 }
0118
0119 void MediaPlayerTest::cleanupTestCase()
0120 {
0121     for (const MediaPlayerUnit &unit : m_units) {
0122         delete unit.dbusMediaPlayer;
0123         delete unit.dbusProperties;
0124     }
0125
0126     delete m_manager;
0127
0128     FakeBluez::stop();
0129 }
0130
0131 void MediaPlayerTest::connectTest()
0132 {
0133     for (DevicePtr device : m_manager->devices()) {
0134         QVERIFY(!device->ubi().isEmpty());
0135         QVERIFY(!device->mediaPlayer());
0136
0137         QSignalSpy deviceSpy(device.data(), SIGNAL(mediaPlayerChanged(MediaPlayerPtr)));
0138
0139         device->connectToDevice();
0140         QTRY_COMPARE(deviceSpy.count(), 1);
0141         QVERIFY(device->mediaPlayer());
0142     }
0143 }
0144
0145 void MediaPlayerTest::disconnectTest()
0146 {
0147     for (DevicePtr device : m_manager->devices()) {
0148         QVERIFY(device->mediaPlayer());
0149
0150         QSignalSpy deviceSpy(device.data(), SIGNAL(mediaPlayerChanged(MediaPlayerPtr)));
0151
0152         device->disconnectFromDevice();
0153         QTRY_COMPARE(deviceSpy.count(), 1);
0154         QVERIFY(!device->mediaPlayer());
0155     }
0156 }
0157
0158 void MediaPlayerTest::connectProfileTest()
0159 {
0160     QDBusConnection connection = QDBusConnection::sessionBus();
0161     QString service = QStringLiteral("org.kde.bluezqt.fakebluez");
0162
0163     for (DevicePtr device : m_manager->devices()) {
0164         QVERIFY(!device->ubi().isEmpty());
0165         QVERIFY(!device->mediaPlayer());
0166
0167         QSignalSpy deviceSpy(device.data(), SIGNAL(mediaPlayerChanged(MediaPlayerPtr)));
0168
0169         device->connectProfile(Services::AudioVideoRemoteControl);
0170         QTRY_COMPARE(deviceSpy.count(), 1);
0171         QVERIFY(device->mediaPlayer());
0172
0173         QString path = device->ubi() + QLatin1String("/player0");
0174
0175         MediaPlayerUnit u;
0176         u.device = device;
0177         u.dbusMediaPlayer = new org::bluez::MediaPlayer1(service, path, connection, this);
0178         u.dbusProperties = new org::freedesktop::DBus::Properties(service, path, connection, this);
0179         m_units.append(u);
0180     }
0181 }
0182
0183 void MediaPlayerTest::getPropertiesTest()
0184 {
0185     for (const MediaPlayerUnit &unit : m_units) {
0186         QCOMPARE(unit.device->mediaPlayer()->name(), unit.dbusMediaPlayer->name());
0187         QCOMPARE(equalizerString(unit.device->mediaPlayer()), unit.dbusMediaPlayer->equalizer());
0188         QCOMPARE(repeatString(unit.device->mediaPlayer()), unit.dbusMediaPlayer->repeat());
0189         QCOMPARE(shuffleString(unit.device->mediaPlayer()), unit.dbusMediaPlayer->shuffle());
0190         QCOMPARE(statusString(unit.device->mediaPlayer()), unit.dbusMediaPlayer->status());
0191         QCOMPARE(trackMap(unit.device->mediaPlayer()), unit.dbusMediaPlayer->track());
0192         QCOMPARE(unit.device->mediaPlayer()->position(), unit.dbusMediaPlayer->position());
0193     }
0194 }
0195
0196 void MediaPlayerTest::setEqualizerTest()
0197 {
0198     for (const MediaPlayerUnit &unit : m_units) {
0199         MediaPlayerPtr mediaPlayer = unit.device->mediaPlayer();
0200         MediaPlayer::Equalizer value = mediaPlayer->equalizer() == MediaPlayer::EqualizerOff ? MediaPlayer::EqualizerOn : MediaPlayer::EqualizerOff;
0201
0202         QSignalSpy equalizerSpy(mediaPlayer.data(), SIGNAL(equalizerChanged(Equalizer)));
0203
0204         mediaPlayer->setEqualizer(value);
0205         QTRY_COMPARE(equalizerSpy.count(), 1);
0206         QCOMPARE(equalizerSpy.at(0).at(0).value<MediaPlayer::Equalizer>(), value);
0207         QCOMPARE(mediaPlayer->equalizer(), value);
0208     }
0209 }
0210
0211 void MediaPlayerTest::setRepeatTest()
0212 {
0213     for (const MediaPlayerUnit &unit : m_units) {
0214         MediaPlayerPtr mediaPlayer = unit.device->mediaPlayer();
0215         MediaPlayer::Repeat value = mediaPlayer->repeat() == MediaPlayer::RepeatGroup ? MediaPlayer::RepeatSingleTrack : MediaPlayer::RepeatGroup;
0216
0217         QSignalSpy equalizerSpy(mediaPlayer.data(), SIGNAL(repeatChanged(Repeat)));
0218
0219         mediaPlayer->setRepeat(value);
0220         QTRY_COMPARE(equalizerSpy.count(), 1);
0221         QCOMPARE(equalizerSpy.at(0).at(0).value<MediaPlayer::Repeat>(), value);
0222         QCOMPARE(mediaPlayer->repeat(), value);
0223     }
0224 }
0225
0226 void MediaPlayerTest::setShuffleTest()
0227 {
0228     for (const MediaPlayerUnit &unit : m_units) {
0229         MediaPlayerPtr mediaPlayer = unit.device->mediaPlayer();
0230         MediaPlayer::Shuffle value = mediaPlayer->shuffle() == MediaPlayer::ShuffleAllTracks ? MediaPlayer::ShuffleOff : MediaPlayer::ShuffleAllTracks;
0231
0232         QSignalSpy equalizerSpy(mediaPlayer.data(), SIGNAL(shuffleChanged(Shuffle)));
0233
0234         mediaPlayer->setShuffle(value);
0235         QTRY_COMPARE(equalizerSpy.count(), 1);
0236         QCOMPARE(equalizerSpy.at(0).at(0).value<MediaPlayer::Shuffle>(), value);
0237         QCOMPARE(mediaPlayer->shuffle(), value);
0238     }
0239 }
0240
0241 void MediaPlayerTest::changeStatusTest()
0242 {
0243     for (const MediaPlayerUnit &unit : m_units) {
0244         MediaPlayerPtr mediaPlayer = unit.device->mediaPlayer();
0245
0246         QSignalSpy statusSpy(mediaPlayer.data(), SIGNAL(statusChanged(Status)));
0247
0248         if (mediaPlayer->status() != MediaPlayer::Stopped) {
0249             mediaPlayer->stop();
0250             QTRY_COMPARE(statusSpy.count(), 1);
0251             QCOMPARE(statusSpy.at(0).at(0).value<MediaPlayer::Status>(), MediaPlayer::Stopped);
0252             QCOMPARE(mediaPlayer->status(), MediaPlayer::Stopped);
0253         }
0254
0255         statusSpy.clear();
0256         mediaPlayer->play();
0257         QTRY_COMPARE(statusSpy.count(), 1);
0258         QCOMPARE(statusSpy.at(0).at(0).value<MediaPlayer::Status>(), MediaPlayer::Playing);
0259         QCOMPARE(mediaPlayer->status(), MediaPlayer::Playing);
0260
0261         statusSpy.clear();
0262         mediaPlayer->pause();
0263         QTRY_COMPARE(statusSpy.count(), 1);
0264         QCOMPARE(statusSpy.at(0).at(0).value<MediaPlayer::Status>(), MediaPlayer::Paused);
0265         QCOMPARE(mediaPlayer->status(), MediaPlayer::Paused);
0266
0267         statusSpy.clear();
0268         mediaPlayer->fastForward();
0269         QTRY_COMPARE(statusSpy.count(), 1);
0270         QCOMPARE(statusSpy.at(0).at(0).value<MediaPlayer::Status>(), MediaPlayer::ForwardSeek);
0271         QCOMPARE(mediaPlayer->status(), MediaPlayer::ForwardSeek);
0272
0273         statusSpy.clear();
0274         mediaPlayer->rewind();
0275         QTRY_COMPARE(statusSpy.count(), 1);
0276         QCOMPARE(statusSpy.at(0).at(0).value<MediaPlayer::Status>(), MediaPlayer::ReverseSeek);
0277         QCOMPARE(mediaPlayer->status(), MediaPlayer::ReverseSeek);
0278
0279         statusSpy.clear();
0280         mediaPlayer->stop();
0281         QTRY_COMPARE(statusSpy.count(), 1);
0282         QCOMPARE(statusSpy.at(0).at(0).value<MediaPlayer::Status>(), MediaPlayer::Stopped);
0283         QCOMPARE(mediaPlayer->status(), MediaPlayer::Stopped);
0284     }
0285 }
0286
0287 void MediaPlayerTest::changeTrackTest()
0288 {
0289     for (const MediaPlayerUnit &unit : m_units) {
0290         MediaPlayerPtr mediaPlayer = unit.device->mediaPlayer();
0291
0292         QSignalSpy trackSpy(mediaPlayer.data(), SIGNAL(trackChanged(MediaPlayerTrack)));
0293
0294         trackSpy.clear();
0295         mediaPlayer->next();
0296         QTRY_COMPARE(trackSpy.count(), 1);
0297         QCOMPARE(mediaPlayer->track().isValid(), true);
0298
0299         trackSpy.clear();
0300         mediaPlayer->previous();
0301         QTRY_COMPARE(trackSpy.count(), 1);
0302         QCOMPARE(mediaPlayer->track().isValid(), true);
0303     }
0304 }
0305
0306 void MediaPlayerTest::disconnectProfileTest()
0307 {
0308     for (const MediaPlayerUnit &unit : m_units) {
0309         QVERIFY(unit.device->mediaPlayer());
0310
0311         QSignalSpy deviceSpy(unit.device.data(), SIGNAL(mediaPlayerChanged(MediaPlayerPtr)));
0312
0313         unit.device->disconnectProfile(Services::AudioVideoRemoteControl);
0314         QTRY_COMPARE(deviceSpy.count(), 1);
0315         QVERIFY(!unit.device->mediaPlayer());
0316     }
0317 }
0318
0319 void MediaPlayerTest::bug403289()
0320 {
0321     // Bug 403289: MediaPlayer interface path is not checked in InterfacesRemoved signal
0322
0323     QDBusConnection connection = QDBusConnection::sessionBus();
0324     QString service = QStringLiteral("org.kde.bluezqt.fakebluez");
0325
0326     for (DevicePtr device : m_manager->devices()) {
0327         QVERIFY(!device->mediaPlayer());
0328
0329         QSignalSpy deviceSpy(device.data(), SIGNAL(mediaPlayerChanged(MediaPlayerPtr)));
0330
0331         const QVariantMap props = {{QStringLiteral("DevicePath"), QVariant::fromValue(QDBusObjectPath(device->ubi()))}};
0332         FakeBluez::runAction(QStringLiteral("devicemanager"), QStringLiteral("bug403289"), props);
0333
0334         QTRY_COMPARE(deviceSpy.count(), 1);
0335         QVERIFY(deviceSpy.at(0).at(0).value<MediaPlayerPtr>());
0336         QTest::qWait(100);
0337         QCOMPARE(deviceSpy.count(), 1);
0338         device->disconnectProfile(Services::AudioVideoRemoteControl);
0339         QTRY_COMPARE(deviceSpy.count(), 2);
0340         QVERIFY(!deviceSpy.at(1).at(0).value<MediaPlayerPtr>());
0341     }
0342 }
0343
0344 QString MediaPlayerTest::equalizerString(const MediaPlayerPtr &mediaPlayer) const
0345 {
0346     switch (mediaPlayer->equalizer()) {
0347     case MediaPlayer::EqualizerOn:
0348         return QStringLiteral("on");
0349     default:
0350         return QStringLiteral("off");
0351     }
0352 }
0353
0354 QString MediaPlayerTest::repeatString(const MediaPlayerPtr &mediaPlayer) const
0355 {
0356     switch (mediaPlayer->repeat()) {
0357     case MediaPlayer::RepeatSingleTrack:
0358         return QStringLiteral("singletrack");
0359     case MediaPlayer::RepeatAllTracks:
0360         return QStringLiteral("alltracks");
0361     case MediaPlayer::RepeatGroup:
0362         return QStringLiteral("group");
0363     default:
0364         return QStringLiteral("off");
0365     }
0366 }
0367
0368 QString MediaPlayerTest::shuffleString(const MediaPlayerPtr &mediaPlayer) const
0369 {
0370     switch (mediaPlayer->shuffle()) {
0371     case MediaPlayer::ShuffleAllTracks:
0372         return QStringLiteral("alltracks");
0373     case MediaPlayer::ShuffleGroup:
0374         return QStringLiteral("group");
0375     default:
0376         return QStringLiteral("off");
0377     }
0378 }
0379
0380 QString MediaPlayerTest::statusString(const MediaPlayerPtr &mediaPlayer) const
0381 {
0382     switch (mediaPlayer->status()) {
0383     case MediaPlayer::Playing:
0384         return QStringLiteral("playing");
0385     case MediaPlayer::Stopped:
0386         return QStringLiteral("stopped");
0387     case MediaPlayer::Paused:
0388         return QStringLiteral("paused");
0389     case MediaPlayer::ForwardSeek:
0390         return QStringLiteral("forward-seek");
0391     case MediaPlayer::ReverseSeek:
0392         return QStringLiteral("reverse-seek");
0393     default:
0394         return QStringLiteral("error");
0395     }
0396 }
0397
0398 QVariantMap MediaPlayerTest::trackMap(const MediaPlayerPtr &mediaPlayer) const
0399 {
0400     QVariantMap out;
0401
0402     if (!mediaPlayer->track().isValid()) {
0403         return out;
0404     }
0405
0406     out[QStringLiteral("Title")] = mediaPlayer->track().title();
0407     out[QStringLiteral("Artist")] = mediaPlayer->track().artist();
0408     out[QStringLiteral("Album")] = mediaPlayer->track().album();
0409     out[QStringLiteral("Genre")] = mediaPlayer->track().genre();
0410     out[QStringLiteral("NumberOfTracks")] = mediaPlayer->track().numberOfTracks();
0411     out[QStringLiteral("TrackNumber")] = mediaPlayer->track().trackNumber();
0412     out[QStringLiteral("Duration")] = mediaPlayer->track().duration();
0413
0414     return out;
0415 }
0416
0417 QTEST_MAIN(MediaPlayerTest)