1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtTest/QtTest>

    43 #include <QtCore/qdebug.h>

    44 #include <QtCore/qbuffer.h>

    45 

    46 #include <qmediaplayer.h>

    47 #include <qmediaplayercontrol.h>

    48 #include <qmediaplaylist.h>

    49 #include <qmediaservice.h>

    50 #include <qmediastreamscontrol.h>

    51 

    52 

    53 QTM_USE_NAMESPACE

    54 class AutoConnection

    55 {

    56 public:

    57     AutoConnection(QObject *sender, const char *signal, QObject *receiver, const char *method)

    58             : sender(sender), signal(signal), receiver(receiver), method(method)

    59     {

    60         QObject::connect(sender, signal, receiver, method);

    61     }

    62 

    63     ~AutoConnection()

    64     {

    65         QObject::disconnect(sender, signal, receiver, method);

    66     }

    67 

    68 private:

    69     QObject *sender;

    70     const char *signal;

    71     QObject *receiver;

    72     const char *method;

    73 };

    74 

    75 

    76 class MockPlayerControl : public QMediaPlayerControl

    77 {

    78     friend class MockPlayerService;

    79 

    80 public:

    81     MockPlayerControl():QMediaPlayerControl(0) {}

    82 

    83     QMediaPlayer::State state() const { return _state; }

    84     QMediaPlayer::MediaStatus mediaStatus() const { return _mediaStatus; }

    85 

    86     qint64 duration() const { return _duration; }

    87 

    88     qint64 position() const { return _position; }

    89 

    90     void setPosition(qint64 position) { if (position != _position) emit positionChanged(_position = position); }

    91 

    92     int volume() const { return _volume; }

    93     void setVolume(int volume) { emit volumeChanged(_volume = volume); }

    94 

    95     bool isMuted() const { return _muted; }

    96     void setMuted(bool muted) { if (muted != _muted) emit mutedChanged(_muted = muted); }

    97 

    98     int bufferStatus() const { return _bufferStatus; }

    99 

   100     bool isAudioAvailable() const { return _audioAvailable; }

   101     bool isVideoAvailable() const { return _videoAvailable; }

   102 

   103     bool isSeekable() const { return _isSeekable; }

   104     QMediaTimeRange availablePlaybackRanges() const { return QMediaTimeRange(_seekRange.first, _seekRange.second); }

   105     void setSeekRange(qint64 minimum, qint64 maximum) { _seekRange = qMakePair(minimum, maximum); }

   106 

   107     qreal playbackRate() const { return _playbackRate; }

   108     void setPlaybackRate(qreal rate) { if (rate != _playbackRate) emit playbackRateChanged(_playbackRate = rate); }

   109 

   110     QMediaContent media() const { return _media; }

   111     void setMedia(const QMediaContent &content, QIODevice *stream)

   112     {

   113         _stream = stream;

   114         _media = content;

   115         if (_state != QMediaPlayer::StoppedState) {

   116             _mediaStatus = _media.isNull() ? QMediaPlayer::NoMedia : QMediaPlayer::LoadingMedia;

   117             emit stateChanged(_state = QMediaPlayer::StoppedState);

   118             emit mediaStatusChanged(_mediaStatus);

   119         }

   120         emit mediaChanged(_media = content);

   121     }

   122     QIODevice *mediaStream() const { return _stream; }

   123 

   124     void play() { if (_isValid && !_media.isNull() && _state != QMediaPlayer::PlayingState) emit stateChanged(_state = QMediaPlayer::PlayingState); }

   125     void pause() { if (_isValid && !_media.isNull() && _state != QMediaPlayer::PausedState) emit stateChanged(_state = QMediaPlayer::PausedState); }

   126     void stop() { if (_state != QMediaPlayer::StoppedState) emit stateChanged(_state = QMediaPlayer::StoppedState); }

   127 

   128     QMediaPlayer::State _state;

   129     QMediaPlayer::MediaStatus _mediaStatus;

   130     QMediaPlayer::Error _error;

   131     qint64 _duration;

   132     qint64 _position;

   133     int _volume;

   134     bool _muted;

   135     int _bufferStatus;

   136     bool _audioAvailable;

   137     bool _videoAvailable;

   138     bool _isSeekable;

   139     QPair<qint64, qint64> _seekRange;

   140     qreal _playbackRate;

   141     QMediaContent _media;

   142     QIODevice *_stream;

   143     bool _isValid;

   144     QString _errorString;

   145 };

   146 

   147 class MockStreamsControl : public QMediaStreamsControl

   148 {

   149 public:

   150     MockStreamsControl(QObject *parent = 0) : QMediaStreamsControl(parent) {}

   151 

   152     int streamCount() { return _streams.count(); }

   153     void setStreamCount(int count) { _streams.resize(count); }

   154 

   155     StreamType streamType(int index) { return _streams.at(index).type; }

   156     void setStreamType(int index, StreamType type) { _streams[index].type = type; }

   157 

   158     QVariant metaData(int index, QtMedia::MetaData key) {

   159         return _streams.at(index).metaData.value(key); }

   160     void setMetaData(int index, QtMedia::MetaData key, const QVariant &value) {

   161         _streams[index].metaData.insert(key, value); }

   162 

   163     bool isActive(int index) { return _streams.at(index).active; }

   164     void setActive(int index, bool state) { _streams[index].active = state; }

   165 

   166 private:

   167     struct Stream

   168     {

   169         Stream() : type(UnknownStream), active(false) {}

   170         StreamType type;

   171         QMap<QtMedia::MetaData, QVariant> metaData;

   172         bool active;

   173     };

   174 

   175     QVector<Stream> _streams;

   176 };

   177 

   178 class MockPlayerService : public QMediaService

   179 {

   180     Q_OBJECT

   181 

   182 public:

   183     MockPlayerService():QMediaService(0)

   184     {

   185         mockControl = new MockPlayerControl;

   186         mockStreamsControl = new MockStreamsControl;

   187     }

   188 

   189     ~MockPlayerService()

   190     {

   191         delete mockControl;

   192         delete mockStreamsControl;

   193     }

   194 

   195     QMediaControl* control(const char *iid) const

   196     {

   197         if (qstrcmp(iid, QMediaPlayerControl_iid) == 0)

   198             return mockControl;

   199 

   200         return 0;

   201     }

   202 

   203     void setState(QMediaPlayer::State state) { emit mockControl->stateChanged(mockControl->_state = state); }

   204     void setState(QMediaPlayer::State state, QMediaPlayer::MediaStatus status) {

   205         mockControl->_state = state;

   206         mockControl->_mediaStatus = status;

   207         emit mockControl->mediaStatusChanged(status);

   208         emit mockControl->stateChanged(state);

   209     }

   210     void setMediaStatus(QMediaPlayer::MediaStatus status) { emit mockControl->mediaStatusChanged(mockControl->_mediaStatus = status); }

   211     void setIsValid(bool isValid) { mockControl->_isValid = isValid; }

   212     void setMedia(QMediaContent media) { mockControl->_media = media; }

   213     void setDuration(qint64 duration) { mockControl->_duration = duration; }

   214     void setPosition(qint64 position) { mockControl->_position = position; }

   215     void setSeekable(bool seekable) { mockControl->_isSeekable = seekable; }

   216     void setVolume(int volume) { mockControl->_volume = volume; }

   217     void setMuted(bool muted) { mockControl->_muted = muted; }

   218     void setVideoAvailable(bool videoAvailable) { mockControl->_videoAvailable = videoAvailable; }

   219     void setBufferStatus(int bufferStatus) { mockControl->_bufferStatus = bufferStatus; }

   220     void setPlaybackRate(qreal playbackRate) { mockControl->_playbackRate = playbackRate; }

   221     void setError(QMediaPlayer::Error error) { mockControl->_error = error; emit mockControl->error(mockControl->_error, mockControl->_errorString); }

   222     void setErrorString(QString errorString) { mockControl->_errorString = errorString; emit mockControl->error(mockControl->_error, mockControl->_errorString); }

   223 

   224     void reset()

   225     {

   226         mockControl->_state = QMediaPlayer::StoppedState;

   227         mockControl->_mediaStatus = QMediaPlayer::UnknownMediaStatus;

   228         mockControl->_error = QMediaPlayer::NoError;

   229         mockControl->_duration = 0;

   230         mockControl->_position = 0;

   231         mockControl->_volume = 0;

   232         mockControl->_muted = false;

   233         mockControl->_bufferStatus = 0;

   234         mockControl->_videoAvailable = false;

   235         mockControl->_isSeekable = false;

   236         mockControl->_playbackRate = 0.0;

   237         mockControl->_media = QMediaContent();

   238         mockControl->_stream = 0;

   239         mockControl->_isValid = false;

   240         mockControl->_errorString = QString();

   241     }

   242 

   243     MockPlayerControl *mockControl;

   244     MockStreamsControl *mockStreamsControl;

   245 };

   246 

   247 class MockProvider : public QMediaServiceProvider

   248 {

   249 public:

   250     MockProvider(MockPlayerService *service):mockService(service) {}

   251     QMediaService *requestService(const QByteArray &, const QMediaServiceProviderHint &)

   252     {

   253         return mockService;

   254     }

   255 

   256     void releaseService(QMediaService *service) { delete service; }

   257 

   258     MockPlayerService *mockService;

   259 };

   260 

   261 class tst_QMediaPlayer: public QObject

   262 {

   263     Q_OBJECT

   264 

   265 public slots:

   266     void initTestCase_data();

   267     void initTestCase();

   268     void cleanupTestCase();

   269     void init();

   270     void cleanup();

   271 

   272 private slots:

   273     void testNullService();

   274     void testValid();

   275     void testMedia();

   276     void testDuration();

   277     void testPosition();

   278     void testVolume();

   279     void testMuted();

   280     void testVideoAvailable();

   281     void testBufferStatus();

   282     void testSeekable();

   283     void testPlaybackRate();

   284     void testError();

   285     void testErrorString();

   286     void testService();

   287     void testPlay();

   288     void testPause();

   289     void testStop();

   290     void testMediaStatus();

   291     void testPlaylist();

   292 

   293 private:

   294     MockProvider *mockProvider;

   295     MockPlayerService  *mockService;

   296     QMediaPlayer *player;

   297 };

   298 

   299 void tst_QMediaPlayer::initTestCase_data()

   300 {

   301     QTest::addColumn<bool>("valid");

   302     QTest::addColumn<QMediaPlayer::State>("state");

   303     QTest::addColumn<QMediaPlayer::MediaStatus>("status");

   304     QTest::addColumn<QMediaContent>("mediaContent");

   305     QTest::addColumn<qint64>("duration");

   306     QTest::addColumn<qint64>("position");

   307     QTest::addColumn<bool>("seekable");

   308     QTest::addColumn<int>("volume");

   309     QTest::addColumn<bool>("muted");

   310     QTest::addColumn<bool>("videoAvailable");

   311     QTest::addColumn<int>("bufferStatus");

   312     QTest::addColumn<qreal>("playbackRate");

   313     QTest::addColumn<QMediaPlayer::Error>("error");

   314     QTest::addColumn<QString>("errorString");

   315 

   316     QTest::newRow("invalid") << false << QMediaPlayer::StoppedState << QMediaPlayer::UnknownMediaStatus <<

   317                                 QMediaContent() << qint64(0) << qint64(0) << false << 0 << false << false << 0 <<

   318                                 qreal(0) << QMediaPlayer::NoError << QString();

   319     QTest::newRow("valid+null") << true << QMediaPlayer::StoppedState << QMediaPlayer::UnknownMediaStatus <<

   320                                 QMediaContent() << qint64(0) << qint64(0) << false << 0 << false << false << 50 <<

   321                                 qreal(0) << QMediaPlayer::NoError << QString();

   322     QTest::newRow("valid+content+stopped") << true << QMediaPlayer::StoppedState << QMediaPlayer::UnknownMediaStatus <<

   323                                 QMediaContent(QUrl("file:///some.mp3")) << qint64(0) << qint64(0) << false << 50 << false << false << 0 <<

   324                                 qreal(1) << QMediaPlayer::NoError << QString();

   325     QTest::newRow("valid+content+playing") << true << QMediaPlayer::PlayingState << QMediaPlayer::LoadedMedia <<

   326                                 QMediaContent(QUrl("file:///some.mp3")) << qint64(10000) << qint64(10) << true << 50 << true << false << 0 <<

   327                                 qreal(1) << QMediaPlayer::NoError << QString();

   328     QTest::newRow("valid+content+paused") << true << QMediaPlayer::PausedState << QMediaPlayer::LoadedMedia <<

   329                                 QMediaContent(QUrl("file:///some.mp3")) << qint64(10000) << qint64(10) << true << 50 << true << false << 0 <<

   330                                 qreal(1)  << QMediaPlayer::NoError << QString();

   331     QTest::newRow("valud+streaming") << true << QMediaPlayer::PlayingState << QMediaPlayer::LoadedMedia <<

   332                                 QMediaContent(QUrl("http://example.com/stream")) << qint64(10000) << qint64(10000) << false << 50 << false << true << 0 <<

   333                                 qreal(1)  << QMediaPlayer::NoError << QString();

   334     QTest::newRow("valid+error") << true << QMediaPlayer::StoppedState << QMediaPlayer::UnknownMediaStatus <<

   335                                 QMediaContent(QUrl("http://example.com/stream")) << qint64(0) << qint64(0) << false << 50 << false << false << 0 <<

   336                                 qreal(0) << QMediaPlayer::ResourceError << QString("Resource unavailable");

   337 }

   338 

   339 void tst_QMediaPlayer::initTestCase()

   340 {

   341     qRegisterMetaType<QMediaPlayer::State>("QMediaPlayer::State");

   342     qRegisterMetaType<QMediaPlayer::Error>("QMediaPlayer::Error");

   343     qRegisterMetaType<QMediaPlayer::MediaStatus>("QMediaPlayer::MediaStatus");

   344     qRegisterMetaType<QMediaContent>("QMediaContent");

   345 

   346     mockService = new MockPlayerService;

   347     mockProvider = new MockProvider(mockService);

   348     player = new QMediaPlayer(0, 0, mockProvider);

   349 }

   350 

   351 void tst_QMediaPlayer::cleanupTestCase()

   352 {

   353     delete player;

   354 }

   355 

   356 void tst_QMediaPlayer::init()

   357 {

   358     mockService->reset();

   359 }

   360 

   361 void tst_QMediaPlayer::cleanup()

   362 {

   363 }

   364 

   365 void tst_QMediaPlayer::testNullService()

   366 {

   367     MockProvider provider(0);

   368     QMediaPlayer player(0, 0, &provider);

   369 

   370     const QIODevice *nullDevice = 0;

   371 

   372     QCOMPARE(player.media(), QMediaContent());

   373     QCOMPARE(player.mediaStream(), nullDevice);

   374     QCOMPARE(player.state(), QMediaPlayer::StoppedState);

   375     QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);

   376     QCOMPARE(player.duration(), qint64(-1));

   377     QCOMPARE(player.position(), qint64(0));

   378     QCOMPARE(player.volume(), 0);

   379     QCOMPARE(player.isMuted(), false);

   380     QCOMPARE(player.isVideoAvailable(), false);

   381     QCOMPARE(player.bufferStatus(), 0);

   382     QCOMPARE(player.isSeekable(), false);

   383     QCOMPARE(player.playbackRate(), qreal(0));

   384     QCOMPARE(player.error(), QMediaPlayer::ServiceMissingError);

   385 

   386     {

   387         QFETCH_GLOBAL(QMediaContent, mediaContent);

   388 

   389         QSignalSpy spy(&player, SIGNAL(mediaChanged(QMediaContent)));

   390         QFile file;

   391 

   392         player.setMedia(mediaContent, &file);

   393         QCOMPARE(player.media(), QMediaContent());

   394         QCOMPARE(player.mediaStream(), nullDevice);

   395         QCOMPARE(spy.count(), 0);

   396     } {

   397         QSignalSpy stateSpy(&player, SIGNAL(stateChanged(QMediaPlayer::State)));

   398         QSignalSpy statusSpy(&player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));

   399 

   400         player.play();

   401         QCOMPARE(player.state(), QMediaPlayer::StoppedState);

   402         QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);

   403         QCOMPARE(stateSpy.count(), 0);

   404         QCOMPARE(statusSpy.count(), 0);

   405 

   406         player.pause();

   407         QCOMPARE(player.state(), QMediaPlayer::StoppedState);

   408         QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);

   409         QCOMPARE(stateSpy.count(), 0);

   410         QCOMPARE(statusSpy.count(), 0);

   411 

   412         player.stop();

   413         QCOMPARE(player.state(), QMediaPlayer::StoppedState);

   414         QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);

   415         QCOMPARE(stateSpy.count(), 0);

   416         QCOMPARE(statusSpy.count(), 0);

   417     } {

   418         QFETCH_GLOBAL(int, volume);

   419         QFETCH_GLOBAL(bool, muted);

   420 

   421         QSignalSpy volumeSpy(&player, SIGNAL(volumeChanged(int)));

   422         QSignalSpy mutingSpy(&player, SIGNAL(mutedChanged(bool)));

   423 

   424         player.setVolume(volume);

   425         QCOMPARE(player.volume(), 0);

   426         QCOMPARE(volumeSpy.count(), 0);

   427 

   428         player.setMuted(muted);

   429         QCOMPARE(player.isMuted(), false);

   430         QCOMPARE(mutingSpy.count(), 0);

   431     } {

   432         QFETCH_GLOBAL(qint64, position);

   433 

   434         QSignalSpy spy(&player, SIGNAL(positionChanged(qint64)));

   435 

   436         player.setPosition(position);

   437         QCOMPARE(player.position(), qint64(0));

   438         QCOMPARE(spy.count(), 0);

   439     } {

   440         QFETCH_GLOBAL(qreal, playbackRate);

   441 

   442         QSignalSpy spy(&player, SIGNAL(playbackRateChanged(qreal)));

   443 

   444         player.setPlaybackRate(playbackRate);

   445         QCOMPARE(player.playbackRate(), qreal(0));

   446         QCOMPARE(spy.count(), 0);

   447     } {

   448         QMediaPlaylist playlist;

   449         playlist.setMediaObject(&player);

   450 

   451         QSignalSpy mediaSpy(&player, SIGNAL(mediaChanged(QMediaContent)));

   452         QSignalSpy statusSpy(&player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));

   453 

   454         playlist.addMedia(QUrl("http://example.com/stream"));

   455         playlist.addMedia(QUrl("file:///some.mp3"));

   456 

   457         playlist.setCurrentIndex(0);

   458         QCOMPARE(playlist.currentIndex(), 0);

   459         QCOMPARE(player.media(), QMediaContent());

   460         QCOMPARE(mediaSpy.count(), 0);

   461         QCOMPARE(statusSpy.count(), 0);

   462 

   463         playlist.next();

   464         QCOMPARE(playlist.currentIndex(), 1);

   465         QCOMPARE(player.media(), QMediaContent());

   466         QCOMPARE(mediaSpy.count(), 0);

   467         QCOMPARE(statusSpy.count(), 0);

   468     }

   469 }

   470 

   471 void tst_QMediaPlayer::testValid()

   472 {

   473     /*

   474     QFETCH_GLOBAL(bool, valid);

   475 

   476     mockService->setIsValid(valid);

   477     QCOMPARE(player->isValid(), valid);

   478     */

   479 }

   480 

   481 void tst_QMediaPlayer::testMedia()

   482 {

   483     QFETCH_GLOBAL(QMediaContent, mediaContent);

   484 

   485     mockService->setMedia(mediaContent);

   486     QCOMPARE(player->media(), mediaContent);

   487 

   488     QBuffer stream;

   489     player->setMedia(mediaContent, &stream);

   490     QCOMPARE(player->media(), mediaContent);

   491     QCOMPARE((QBuffer*)player->mediaStream(), &stream);

   492 }

   493 

   494 void tst_QMediaPlayer::testDuration()

   495 {

   496     QFETCH_GLOBAL(qint64, duration);

   497 

   498     mockService->setDuration(duration);

   499     QVERIFY(player->duration() == duration);

   500 }

   501 

   502 void tst_QMediaPlayer::testPosition()

   503 {

   504     QFETCH_GLOBAL(bool, valid);

   505     QFETCH_GLOBAL(bool, seekable);

   506     QFETCH_GLOBAL(qint64, position);

   507     QFETCH_GLOBAL(qint64, duration);

   508 

   509     mockService->setIsValid(valid);

   510     mockService->setSeekable(seekable);

   511     mockService->setPosition(position);

   512     mockService->setDuration(duration);

   513     QVERIFY(player->isSeekable() == seekable);

   514     QVERIFY(player->position() == position);

   515     QVERIFY(player->duration() == duration);

   516 

   517     if (seekable) {

   518         { QSignalSpy spy(player, SIGNAL(positionChanged(qint64)));

   519         player->setPosition(position);

   520         QCOMPARE(player->position(), position);

   521         QCOMPARE(spy.count(), 0); }

   522 

   523         mockService->setPosition(position);

   524         { QSignalSpy spy(player, SIGNAL(positionChanged(qint64)));

   525         player->setPosition(0);

   526         QCOMPARE(player->position(), qint64(0));

   527         QCOMPARE(spy.count(), position == 0 ? 0 : 1); }

   528 

   529         mockService->setPosition(position);

   530         { QSignalSpy spy(player, SIGNAL(positionChanged(qint64)));

   531         player->setPosition(duration);

   532         QCOMPARE(player->position(), duration);

   533         QCOMPARE(spy.count(), position == duration ? 0 : 1); }

   534 

   535         mockService->setPosition(position);

   536         { QSignalSpy spy(player, SIGNAL(positionChanged(qint64)));

   537         player->setPosition(-1);

   538         QCOMPARE(player->position(), qint64(0));

   539         QCOMPARE(spy.count(), position == 0 ? 0 : 1); }

   540 

   541         mockService->setPosition(position);

   542         { QSignalSpy spy(player, SIGNAL(positionChanged(qint64)));

   543         player->setPosition(duration + 1);

   544         QCOMPARE(player->position(), duration);

   545         QCOMPARE(spy.count(), position == duration ? 0 : 1); }

   546     }

   547     else {

   548         QSignalSpy spy(player, SIGNAL(positionChanged(qint64)));

   549         player->setPosition(position);

   550 

   551         QCOMPARE(player->position(), position);

   552         QCOMPARE(spy.count(), 0);

   553     }

   554 }

   555 

   556 void tst_QMediaPlayer::testVolume()

   557 {

   558     QFETCH_GLOBAL(bool, valid);

   559     QFETCH_GLOBAL(int, volume);

   560 

   561     mockService->setVolume(volume);

   562     QVERIFY(player->volume() == volume);

   563 

   564     if (valid) {

   565         { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));

   566         player->setVolume(10);

   567         QCOMPARE(player->volume(), 10);

   568         QCOMPARE(spy.count(), 1); }

   569 

   570         { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));

   571         player->setVolume(-1000);

   572         QCOMPARE(player->volume(), 0);

   573         QCOMPARE(spy.count(), 1); }

   574 

   575         { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));

   576         player->setVolume(100);

   577         QCOMPARE(player->volume(), 100);

   578         QCOMPARE(spy.count(), 1); }

   579 

   580         { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));

   581         player->setVolume(1000);

   582         QCOMPARE(player->volume(), 100);

   583         QCOMPARE(spy.count(), 0); }

   584     }

   585 }

   586 

   587 void tst_QMediaPlayer::testMuted()

   588 {

   589     QFETCH_GLOBAL(bool, valid);

   590     QFETCH_GLOBAL(bool, muted);

   591     QFETCH_GLOBAL(int, volume);

   592 

   593     if (valid) {

   594         mockService->setMuted(muted);

   595         mockService->setVolume(volume);

   596         QVERIFY(player->isMuted() == muted);

   597 

   598         QSignalSpy spy(player, SIGNAL(mutedChanged(bool)));

   599         player->setMuted(!muted);

   600         QCOMPARE(player->isMuted(), !muted);

   601         QCOMPARE(player->volume(), volume);

   602         QCOMPARE(spy.count(), 1);

   603     }

   604 }

   605 

   606 void tst_QMediaPlayer::testVideoAvailable()

   607 {

   608     QFETCH_GLOBAL(bool, videoAvailable);

   609 

   610     mockService->setVideoAvailable(videoAvailable);

   611     QVERIFY(player->isVideoAvailable() == videoAvailable);

   612 }

   613 

   614 void tst_QMediaPlayer::testBufferStatus()

   615 {

   616     QFETCH_GLOBAL(int, bufferStatus);

   617 

   618     mockService->setBufferStatus(bufferStatus);

   619     QVERIFY(player->bufferStatus() == bufferStatus);

   620 }

   621 

   622 void tst_QMediaPlayer::testSeekable()

   623 {

   624     QFETCH_GLOBAL(bool, seekable);

   625 

   626     mockService->setSeekable(seekable);

   627     QVERIFY(player->isSeekable() == seekable);

   628 }

   629 

   630 void tst_QMediaPlayer::testPlaybackRate()

   631 {

   632     QFETCH_GLOBAL(bool, valid);

   633     QFETCH_GLOBAL(qreal, playbackRate);

   634 

   635     if (valid) {

   636         mockService->setPlaybackRate(playbackRate);

   637         QVERIFY(player->playbackRate() == playbackRate);

   638 

   639         QSignalSpy spy(player, SIGNAL(playbackRateChanged(qreal)));

   640         player->setPlaybackRate(playbackRate + 0.5f);

   641         QCOMPARE(player->playbackRate(), playbackRate + 0.5f);

   642         QCOMPARE(spy.count(), 1);

   643     }

   644 }

   645 

   646 void tst_QMediaPlayer::testError()

   647 {

   648     QFETCH_GLOBAL(QMediaPlayer::Error, error);

   649 

   650     mockService->setError(error);

   651     QVERIFY(player->error() == error);

   652 }

   653 

   654 void tst_QMediaPlayer::testErrorString()

   655 {

   656     QFETCH_GLOBAL(QString, errorString);

   657 

   658     mockService->setErrorString(errorString);

   659     QVERIFY(player->errorString() == errorString);

   660 }

   661 

   662 void tst_QMediaPlayer::testService()

   663 {

   664     /*

   665     QFETCH_GLOBAL(bool, valid);

   666 

   667     mockService->setIsValid(valid);

   668 

   669     if (valid)

   670         QVERIFY(player->service() != 0);

   671     else

   672         QVERIFY(player->service() == 0);

   673         */

   674 }

   675 

   676 void tst_QMediaPlayer::testPlay()

   677 {

   678     QFETCH_GLOBAL(bool, valid);

   679     QFETCH_GLOBAL(QMediaContent, mediaContent);

   680     QFETCH_GLOBAL(QMediaPlayer::State, state);

   681 

   682     mockService->setIsValid(valid);

   683     mockService->setState(state);

   684     mockService->setMedia(mediaContent);

   685     QVERIFY(player->state() == state);

   686     QVERIFY(player->media() == mediaContent);

   687 

   688     QSignalSpy spy(player, SIGNAL(stateChanged(QMediaPlayer::State)));

   689 

   690     player->play();

   691 

   692     if (!valid || mediaContent.isNull())  {

   693         QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   694         QCOMPARE(spy.count(), 0);

   695     }

   696     else {

   697         QCOMPARE(player->state(), QMediaPlayer::PlayingState);

   698         QCOMPARE(spy.count(), state == QMediaPlayer::PlayingState ? 0 : 1);

   699     }

   700 }

   701 

   702 void tst_QMediaPlayer::testPause()

   703 {

   704     QFETCH_GLOBAL(bool, valid);

   705     QFETCH_GLOBAL(QMediaContent, mediaContent);

   706     QFETCH_GLOBAL(QMediaPlayer::State, state);

   707 

   708     mockService->setIsValid(valid);

   709     mockService->setState(state);

   710     mockService->setMedia(mediaContent);

   711     QVERIFY(player->state() == state);

   712     QVERIFY(player->media() == mediaContent);

   713 

   714     QSignalSpy spy(player, SIGNAL(stateChanged(QMediaPlayer::State)));

   715 

   716     player->pause();

   717 

   718     if (!valid || mediaContent.isNull()) {

   719         QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   720         QCOMPARE(spy.count(), 0);

   721     }

   722     else {

   723         QCOMPARE(player->state(), QMediaPlayer::PausedState);

   724         QCOMPARE(spy.count(), state == QMediaPlayer::PausedState ? 0 : 1);

   725     }

   726 }

   727 

   728 void tst_QMediaPlayer::testStop()

   729 {

   730     QFETCH_GLOBAL(QMediaContent, mediaContent);

   731     QFETCH_GLOBAL(QMediaPlayer::State, state);

   732 

   733     mockService->setState(state);

   734     mockService->setMedia(mediaContent);

   735     QVERIFY(player->state() == state);

   736     QVERIFY(player->media() == mediaContent);

   737 

   738     QSignalSpy spy(player, SIGNAL(stateChanged(QMediaPlayer::State)));

   739 

   740     player->stop();

   741 

   742     if (mediaContent.isNull() || state == QMediaPlayer::StoppedState) {

   743         QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   744         QCOMPARE(spy.count(), 0);

   745     }

   746     else {

   747         QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   748         QCOMPARE(spy.count(), 1);

   749     }

   750 }

   751 

   752 void tst_QMediaPlayer::testMediaStatus()

   753 {

   754     QFETCH_GLOBAL(int, bufferStatus);

   755     int bufferSignals = 0;

   756 

   757     player->setNotifyInterval(10);

   758 

   759     mockService->setMediaStatus(QMediaPlayer::NoMedia);

   760     mockService->setBufferStatus(bufferStatus);

   761 

   762     AutoConnection connection(

   763             player, SIGNAL(bufferStatusChanged(int)),

   764             &QTestEventLoop::instance(), SLOT(exitLoop()));

   765 

   766     QSignalSpy statusSpy(player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));

   767     QSignalSpy bufferSpy(player, SIGNAL(bufferStatusChanged(int)));

   768 

   769     QCOMPARE(player->mediaStatus(), QMediaPlayer::NoMedia);

   770 

   771     mockService->setMediaStatus(QMediaPlayer::LoadingMedia);

   772     QCOMPARE(player->mediaStatus(), QMediaPlayer::LoadingMedia);

   773     QCOMPARE(statusSpy.count(), 1);

   774 

   775 #ifdef QTM_NAMESPACE

   776     //looks like the correct value is emited, but QSignalSpy doesn't work correctly with QtMobility namespace

   777     QEXPECT_FAIL("", "QSignalSpy doesn't grab the correct value from signal because of QtMobility namespace", Continue);

   778 #endif

   779     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)),

   780              QMediaPlayer::LoadingMedia);

   781 

   782     mockService->setMediaStatus(QMediaPlayer::LoadedMedia);

   783     QCOMPARE(player->mediaStatus(), QMediaPlayer::LoadedMedia);

   784     QCOMPARE(statusSpy.count(), 2);

   785 

   786 #ifdef QTM_NAMESPACE

   787     //looks like the correct value is emited, but QSignalSpy doesn't work correctly with QtMobility namespace

   788     QEXPECT_FAIL("", "QSignalSpy doesn't grab the correct value from signal because of QtMobility namespace", Continue);

   789 #endif

   790     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)),

   791              QMediaPlayer::LoadedMedia);

   792 

   793     // Verify the bufferStatusChanged() signal isn't being emitted.

   794     QTestEventLoop::instance().enterLoop(1);

   795     QCOMPARE(bufferSpy.count(), 0);

   796 

   797     mockService->setMediaStatus(QMediaPlayer::StalledMedia);

   798     QCOMPARE(player->mediaStatus(), QMediaPlayer::StalledMedia);

   799     QCOMPARE(statusSpy.count(), 3);

   800 

   801 #ifdef QTM_NAMESPACE

   802     //looks like the correct value is emited, but QSignalSpy doesn't work correctly with QtMobility namespace

   803     QEXPECT_FAIL("", "QSignalSpy doesn't grab the correct value from signal because of QtMobility namespace", Continue);

   804 #endif

   805     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)),

   806              QMediaPlayer::StalledMedia);

   807 

   808     // Verify the bufferStatusChanged() signal is being emitted.

   809     QTestEventLoop::instance().enterLoop(1);

   810     QVERIFY(bufferSpy.count() > bufferSignals);

   811     QCOMPARE(bufferSpy.last().value(0).toInt(), bufferStatus);

   812     bufferSignals = bufferSpy.count();

   813 

   814     mockService->setMediaStatus(QMediaPlayer::BufferingMedia);

   815     QCOMPARE(player->mediaStatus(), QMediaPlayer::BufferingMedia);

   816     QCOMPARE(statusSpy.count(), 4);

   817 

   818 #ifdef QTM_NAMESPACE

   819     //looks like the correct value is emited, but QSignalSpy doesn't work correctly with QtMobility namespace

   820     QEXPECT_FAIL("", "QSignalSpy doesn't grab the correct value from signal because of QtMobility namespace", Continue);

   821 #endif

   822     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)),

   823              QMediaPlayer::BufferingMedia);

   824 

   825     // Verify the bufferStatusChanged() signal is being emitted.

   826     QTestEventLoop::instance().enterLoop(1);

   827     QVERIFY(bufferSpy.count() > bufferSignals);

   828     QCOMPARE(bufferSpy.last().value(0).toInt(), bufferStatus);

   829     bufferSignals = bufferSpy.count();

   830 

   831     mockService->setMediaStatus(QMediaPlayer::BufferedMedia);

   832     QCOMPARE(player->mediaStatus(), QMediaPlayer::BufferedMedia);

   833     QCOMPARE(statusSpy.count(), 5);

   834 

   835 #ifdef QTM_NAMESPACE

   836     //looks like the correct value is emited, but QSignalSpy doesn't work correctly with QtMobility namespace

   837     QEXPECT_FAIL("", "QSignalSpy doesn't grab the correct value from signal because of QtMobility namespace", Continue);

   838 #endif

   839     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)),

   840              QMediaPlayer::BufferedMedia);

   841 

   842     // Verify the bufferStatusChanged() signal isn't being emitted.

   843     QTestEventLoop::instance().enterLoop(1);

   844     QCOMPARE(bufferSpy.count(), bufferSignals);

   845 

   846     mockService->setMediaStatus(QMediaPlayer::EndOfMedia);

   847     QCOMPARE(player->mediaStatus(), QMediaPlayer::EndOfMedia);

   848     QCOMPARE(statusSpy.count(), 6);

   849 

   850 #ifdef QTM_NAMESPACE

   851     //looks like the correct value is emited, but QSignalSpy doesn't work correctly with QtMobility namespace

   852     QEXPECT_FAIL("", "QSignalSpy doesn't grab the correct value from signal because of QtMobility namespace", Continue);

   853 #endif

   854     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)),

   855              QMediaPlayer::EndOfMedia);

   856 }

   857 

   858 void tst_QMediaPlayer::testPlaylist()

   859 {

   860     QMediaContent content0(QUrl(QLatin1String("test://audio/song1.mp3")));

   861     QMediaContent content1(QUrl(QLatin1String("test://audio/song2.mp3")));

   862     QMediaContent content2(QUrl(QLatin1String("test://video/movie1.mp4")));

   863     QMediaContent content3(QUrl(QLatin1String("test://video/movie2.mp4")));

   864     QMediaContent content4(QUrl(QLatin1String("test://image/photo.jpg")));

   865 

   866     mockService->setIsValid(true);

   867     mockService->setState(QMediaPlayer::StoppedState, QMediaPlayer::NoMedia);

   868 

   869     QMediaPlaylist *playlist = new QMediaPlaylist;

   870     playlist->setMediaObject(player);

   871 

   872     QSignalSpy stateSpy(player, SIGNAL(stateChanged(QMediaPlayer::State)));

   873     QSignalSpy mediaSpy(player, SIGNAL(mediaChanged(QMediaContent)));

   874 

   875     // Test the player does nothing with an empty playlist attached.

   876     player->play();

   877     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   878     QCOMPARE(player->media(), QMediaContent());

   879     QCOMPARE(stateSpy.count(), 0);

   880     QCOMPARE(mediaSpy.count(), 0);

   881 

   882     playlist->addMedia(content0);

   883     playlist->addMedia(content1);

   884     playlist->addMedia(content2);

   885     playlist->addMedia(content3);

   886 

   887     // Test changing the playlist position, changes the current media, but not the playing state.

   888     playlist->setCurrentIndex(1);

   889     QCOMPARE(player->media(), content1);

   890     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   891     QCOMPARE(stateSpy.count(), 0);

   892     QCOMPARE(mediaSpy.count(), 1);

   893 

   894     // Test playing starts with the current media.

   895     player->play();

   896     QCOMPARE(player->media(), content1);

   897     QCOMPARE(player->state(), QMediaPlayer::PlayingState);

   898     QCOMPARE(stateSpy.count(), 1);

   899     QCOMPARE(mediaSpy.count(), 1);

   900 

   901     // Test pausing doesn't change the current media.

   902     player->pause();

   903     QCOMPARE(player->media(), content1);

   904     QCOMPARE(player->state(), QMediaPlayer::PausedState);

   905     QCOMPARE(stateSpy.count(), 2);

   906     QCOMPARE(mediaSpy.count(), 1);

   907 

   908     // Test stopping doesn't change the current media.

   909     player->stop();

   910     QCOMPARE(player->media(), content1);

   911     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   912     QCOMPARE(stateSpy.count(), 3);

   913     QCOMPARE(mediaSpy.count(), 1);

   914 

   915     // Test when the player service reaches the end of the current media, the player moves onto

   916     // the next item without stopping.

   917     player->play();

   918     QCOMPARE(player->media(), content1);

   919     QCOMPARE(player->state(), QMediaPlayer::PlayingState);

   920     QCOMPARE(stateSpy.count(), 4);

   921     QCOMPARE(mediaSpy.count(), 1);

   922 

   923     mockService->setState(QMediaPlayer::StoppedState, QMediaPlayer::EndOfMedia);

   924     QCOMPARE(player->media(), content2);

   925     QCOMPARE(player->state(), QMediaPlayer::PlayingState);

   926     QCOMPARE(stateSpy.count(), 4);

   927     QCOMPARE(mediaSpy.count(), 2);

   928 

   929     // Test skipping the current media doesn't change the state.

   930     playlist->next();

   931     QCOMPARE(player->media(), content3);

   932     QCOMPARE(player->state(), QMediaPlayer::PlayingState);

   933     QCOMPARE(stateSpy.count(), 4);

   934     QCOMPARE(mediaSpy.count(), 3);

   935 

   936     // Test changing the current media while paused doesn't change the state.

   937     player->pause();

   938     mockService->setMediaStatus(QMediaPlayer::BufferedMedia);

   939     QCOMPARE(player->media(), content3);

   940     QCOMPARE(player->state(), QMediaPlayer::PausedState);

   941     QCOMPARE(stateSpy.count(), 5);

   942     QCOMPARE(mediaSpy.count(), 3);

   943 

   944     playlist->previous();

   945     QCOMPARE(player->media(), content2);

   946     QCOMPARE(player->state(), QMediaPlayer::PausedState);

   947     QCOMPARE(stateSpy.count(), 5);

   948     QCOMPARE(mediaSpy.count(), 4);

   949 

   950     // Test changing the current media while stopped doesn't change the state.

   951     player->stop();

   952     mockService->setMediaStatus(QMediaPlayer::LoadedMedia);

   953     QCOMPARE(player->media(), content2);

   954     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   955     QCOMPARE(stateSpy.count(), 6);

   956     QCOMPARE(mediaSpy.count(), 4);

   957 

   958     playlist->next();

   959     QCOMPARE(player->media(), content3);

   960     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   961     QCOMPARE(stateSpy.count(), 6);

   962     QCOMPARE(mediaSpy.count(), 5);

   963 

   964     // Test the player is stopped and the current media cleared when it reaches the end of the last

   965     // item in the playlist.

   966     player->play();

   967     QCOMPARE(player->media(), content3);

   968     QCOMPARE(player->state(), QMediaPlayer::PlayingState);

   969     QCOMPARE(stateSpy.count(), 7);

   970     QCOMPARE(mediaSpy.count(), 5);

   971 

   972     // Double up the signals to ensure some noise doesn't destabalize things.

   973     mockService->setState(QMediaPlayer::StoppedState, QMediaPlayer::EndOfMedia);

   974     mockService->setState(QMediaPlayer::StoppedState, QMediaPlayer::EndOfMedia);

   975     QCOMPARE(player->media(), QMediaContent());

   976     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   977     QCOMPARE(stateSpy.count(), 8);

   978     QCOMPARE(mediaSpy.count(), 6);

   979 

   980     // Test starts playing from the start of the playlist if there is no current media selected.

   981     player->play();

   982     QCOMPARE(player->media(), content0);

   983     QCOMPARE(player->state(), QMediaPlayer::PlayingState);

   984     QCOMPARE(stateSpy.count(), 9);

   985     QCOMPARE(mediaSpy.count(), 7);

   986 

   987     // Test deleting the playlist stops the player and clears the media it set.

   988     delete playlist;

   989     QCOMPARE(player->media(), QMediaContent());

   990     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   991     QCOMPARE(stateSpy.count(), 10);

   992     QCOMPARE(mediaSpy.count(), 8);

   993 

   994     // Test the player works as normal with the playlist removed.

   995     player->play();

   996     QCOMPARE(player->media(), QMediaContent());

   997     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

   998     QCOMPARE(stateSpy.count(), 10);

   999     QCOMPARE(mediaSpy.count(), 8);

  1000 

  1001     player->setMedia(content1);

  1002     player->play();

  1003 

  1004     QCOMPARE(player->media(), content1);

  1005     QCOMPARE(player->state(), QMediaPlayer::PlayingState);

  1006     QCOMPARE(stateSpy.count(), 11);

  1007     QCOMPARE(mediaSpy.count(), 9);

  1008 

  1009     // Test the player can bind to playlist again

  1010     playlist = new QMediaPlaylist;

  1011     playlist->setMediaObject(player);

  1012     QCOMPARE(playlist->mediaObject(), qobject_cast<QMediaObject*>(player));

  1013 

  1014     QCOMPARE(player->media(), QMediaContent());

  1015     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

  1016 

  1017     playlist->addMedia(content0);

  1018     playlist->addMedia(content1);

  1019     playlist->addMedia(content2);

  1020     playlist->addMedia(content3);

  1021 

  1022     playlist->setCurrentIndex(1);

  1023     QCOMPARE(player->media(), content1);

  1024     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

  1025 

  1026     // Test attaching the new playlist,

  1027     // player should detach the current one

  1028     QMediaPlaylist *playlist2 = new QMediaPlaylist;

  1029     playlist2->addMedia(content1);

  1030     playlist2->addMedia(content2);

  1031     playlist2->addMedia(content3);

  1032     playlist2->setCurrentIndex(2);

  1033 

  1034     player->play();

  1035     playlist2->setMediaObject(player);

  1036     QCOMPARE(playlist2->mediaObject(), qobject_cast<QMediaObject*>(player));

  1037     QVERIFY(playlist->mediaObject() == 0);

  1038     QCOMPARE(player->media(), playlist2->currentMedia());

  1039     QCOMPARE(player->state(), QMediaPlayer::StoppedState);

  1040 

  1041     playlist2->setCurrentIndex(1);

  1042     QCOMPARE(player->media(), playlist2->currentMedia());

  1043 }

  1044 

  1045 QTEST_MAIN(tst_QMediaPlayer)

  1046 

  1047 #include "tst_qmediaplayer.moc"