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>

    44 #include <QtGui>

    45  #include <QFile>

    46 

    47 #include <QMediaPlayer>

    48 #include <QMediaPlayerControl>

    49 #include <QMediaPlaylist>

    50 #include <QMediaService>

    51 #include <QMediaStreamsControl>

    52 #include <QVideoWidget>

    53 

    54 QTM_USE_NAMESPACE

    55 

    56 #define WAIT_FOR_CONDITION(a,e)            \

    57     for (int _i = 0; _i < 500; _i += 1) {  \

    58         if ((a) == (e)) break;             \

    59         QTest::qWait(10);}

    60 

    61 

    62 #define WAIT_LONG_FOR_CONDITION(a,e)        \

    63     for (int _i = 0; _i < 1800; _i += 1) {  \

    64         if ((a) == (e)) break;              \

    65         QTest::qWait(100);}

    66 

    67 class mediaStatusList : public QObject, public QList<QMediaPlayer::MediaStatus>

    68 {

    69     Q_OBJECT

    70 public slots:

    71     void mediaStatus(QMediaPlayer::MediaStatus status) {

    72         append(status);

    73     }    

    74     

    75 public:

    76     mediaStatusList(QObject *obj, const char *aSignal) 

    77     : QObject()

    78     {

    79         connect(obj, aSignal, this, SLOT(mediaStatus(QMediaPlayer::MediaStatus)));

    80     }

    81 };

    82 

    83 class MockProvider : public QMediaServiceProvider

    84 {

    85 public:

    86     MockProvider(QMediaService *service):mockService(service) {}

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

    88     {

    89         return mockService;

    90     }

    91 

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

    93 

    94     QMediaService *mockService;

    95 };

    96 

    97 class tst_QMediaPlayer: public QObject

    98 {

    99     Q_OBJECT

   100 

   101 public slots:

   102     void initTestCase_data();

   103     void initTestCase_data_default_winscw();

   104     void initTestCase_data_default_armv5();

   105     void initTestCase_data_50_winscw();

   106     void initTestCase_data_50_armv5();

   107     void initTestCase_data_32_winscw();

   108     void initTestCase_data_32_armv5();

   109     void initTestCase_data_31_winscw();

   110     void initTestCase_data_31_armv5();

   111     void initTestCase();

   112     void cleanupTestCase();

   113     void init();

   114     void cleanup();

   115 

   116 private slots:

   117 void testPositionWhilePlaying();    

   118     void testNullService();

   119     void testMedia();

   120     void testDuration();    

   121     void testPosition();

   122     

   123     void testVolume();

   124     void testVolumeWhilePlaying();

   125     void testMuted();

   126     void testMutedWhilePlaying();

   127     void testVideoAndAudioAvailability();

   128     void testError();

   129     void testPlay();

   130     void testPause();

   131     void testStop();

   132     void testMediaStatus();

   133     void testPlaylist();

   134     void testPlaybackRate();

   135     void testPlaybackRateWhilePlaying();

   136 

   137 

   138 private:

   139     QMediaPlayer *m_player;

   140     QVideoWidget *m_widget;

   141     bool runonce;

   142 };

   143 

   144 void tst_QMediaPlayer::initTestCase_data()

   145 {

   146 #ifdef __WINSCW__   

   147     if(QSysInfo::s60Version() == QSysInfo::SV_S60_3_1)

   148         initTestCase_data_31_winscw();

   149     else if(QSysInfo::s60Version() == QSysInfo::SV_S60_3_2)

   150         initTestCase_data_32_winscw();   

   151     else if(QSysInfo::s60Version() == QSysInfo::SV_S60_5_0)

   152         initTestCase_data_50_winscw();

   153     else

   154         initTestCase_data_default_winscw();

   155 #else

   156     if(QSysInfo::s60Version() == QSysInfo::SV_S60_3_1)

   157         initTestCase_data_31_armv5();

   158     else if(QSysInfo::s60Version() == QSysInfo::SV_S60_3_2)

   159         initTestCase_data_32_armv5();   

   160     else if(QSysInfo::s60Version() == QSysInfo::SV_S60_5_0)

   161         initTestCase_data_50_armv5();

   162     else

   163         initTestCase_data_default_armv5();

   164 #endif    

   165 }

   166 

   167 void tst_QMediaPlayer::initTestCase_data_default_winscw()

   168 {

   169     //TODO: add data

   170 }

   171 

   172 void tst_QMediaPlayer::initTestCase_data_default_armv5()

   173 {

   174     //TODO: add data

   175 }

   176 

   177 void tst_QMediaPlayer::initTestCase_data_50_winscw()

   178 {

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

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

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

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

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

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

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

   186     QTest::addColumn<bool>("seekableWhilePlaying");

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

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

   189     QTest::addColumn<bool>("audioAvailable");

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

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

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

   193 

   194     QTest::newRow("TestDataNull")

   195     << false //valid

   196     << QMediaPlayer::StoppedState // state

   197     << QMediaPlayer::NoMedia // status

   198     << QMediaContent() // mediaContent

   199     << qint64(-1) // duration

   200     << qint64(0) // position

   201     << false // seekable

   202     << false // seekableWhilePlaying

   203     << 50 // volume

   204     << false // videoAvailable

   205     << false //audioAvailable

   206     << qreal(0) // playbackRate

   207     << QMediaPlayer::NoError // error

   208     << QString(); // errorString

   209 

   210     QTest::newRow("test_3GPP.dat")

   211     << true //valid

   212     << QMediaPlayer::StoppedState // state

   213     << QMediaPlayer::LoadedMedia // status

   214     << QMediaContent(QUrl("file:///C:/data/testfiles/test_3GPP.dat")) // mediaContent

   215     << qint64(7200) // duration

   216     << qint64(3600) // position (duration/2)

   217     << true // seekable

   218     << false // seekableWhilePlaying 

   219     << 50 // volume

   220     << true // videoAvailable

   221     << true //audioAvailable

   222     << qreal(0) // playbackRate

   223     << QMediaPlayer::NoError // error

   224     << QString(); // errorString

   225     

   226     QTest::newRow("test_3gp.3gp")

   227     << true //valid

   228     << QMediaPlayer::StoppedState // state

   229     << QMediaPlayer::LoadedMedia // status

   230     << QMediaContent(QUrl("file:///C:/data/testfiles/test_3gp.3gp")) // mediaContent

   231     << qint64(46860) // duration

   232     << qint64(23430) // position (duration/2)

   233     << true // seekable

   234     << true // seekableWhilePlaying 

   235     << 50 // volume

   236     << true // videoAvailable

   237     << true //audioAvailable

   238     << qreal(0) // playbackRate

   239     << QMediaPlayer::NoError // error

   240     << QString(); // errorString

   241 

   242     QTest::newRow("test_mp4.mp4")

   243     << true //valid

   244     << QMediaPlayer::StoppedState // state

   245     << QMediaPlayer::LoadedMedia // status

   246     << QMediaContent(QUrl("file:///C:/data/testfiles/test_mp4.mp4")) // mediaContent

   247     << qint64(2701) // duration 

   248     << qint64(1351) // position (duration/2)

   249     << true // seekable

   250     << true // seekableWhilePlaying    

   251     << 50 // volume

   252     << true // videoAvailable

   253     << false //audioAvailable

   254     << qreal(0) // playbackRate

   255     << QMediaPlayer::FormatError // error

   256     << QString(); // errorString

   257 

   258     QTest::newRow("test_MP4.dat")

   259     << false //valid

   260     << QMediaPlayer::StoppedState // state

   261     << QMediaPlayer::InvalidMedia // status

   262     << QMediaContent(QUrl("file:///C:/data/testfiles/test_MP4.dat")) // mediaContent

   263     << qint64(-1) // duration 

   264     << qint64(0) // position (duration/2)

   265     << true // seekable

   266     << false // seekableWhilePlaying    

   267     << 50 // volume

   268     << true // videoAvailable

   269     << false //audioAvailable

   270     << qreal(0) // playbackRate

   271     << QMediaPlayer::AccessDeniedError// error

   272     << QString(); // errorString

   273     

   274     QTest::newRow("test_wmv9.wmv")

   275     << true //valid

   276     << QMediaPlayer::StoppedState // state

   277     << QMediaPlayer::LoadedMedia // status

   278     << QMediaContent(QUrl("file:///C:/data/testfiles/test_wmv9.wmv")) // mediaContent

   279     << qint64(169389) // duration

   280     << qint64(84695) // position (duration/2)

   281     << true // seekable

   282     << false // seekableWhilePlaying    

   283     << 50 // volume

   284     << true // videoAvailable

   285     << false //audioAvailable

   286     << qreal(0) // playbackRate

   287     << QMediaPlayer::FormatError // error

   288     << QString(); // errorString    

   289 

   290     QTest::newRow("test_h264_qcif.264")

   291     << false //valid

   292     << QMediaPlayer::StoppedState // state

   293     << QMediaPlayer::InvalidMedia // status

   294     << QMediaContent(QUrl("file:///C:/data/testfiles/test_h264_qcif.264")) // mediaContent

   295     << qint64(-1) // duration

   296     << qint64(0) // position (duration/2)

   297     << false // seekable

   298     << false // seekableWhilePlaying    

   299     << 50 // volume

   300     << false // videoAvailable

   301     << false //audioAvailable

   302     << qreal(0) // playbackRate

   303     << QMediaPlayer::ResourceError // error

   304     << QString(); // errorString  

   305 

   306     QTest::newRow("test_RM.dat")

   307     << true //valid

   308     << QMediaPlayer::StoppedState // state

   309     << QMediaPlayer::LoadedMedia // status

   310     << QMediaContent(QUrl("file:///C:/data/testfiles/test_RM.dat")) // mediaContent

   311     << qint64(20245) // duration

   312     << qint64(10123) // position (duration/2)

   313     << true // seekable

   314     << false // seekableWhilePlaying 

   315     << 50 // volume

   316     << true // videoAvailable

   317     << true //audioAvailable

   318     << qreal(0) // playbackRate

   319     << QMediaPlayer::NoError // error

   320     << QString(); // errorString

   321 

   322     QTest::newRow("test_SWF.dat")

   323     << false //valid

   324     << QMediaPlayer::StoppedState // state

   325     << QMediaPlayer::InvalidMedia // status

   326     << QMediaContent(QUrl("file:///C:/data/testfiles/test_SWF.dat")) // mediaContent

   327     << qint64(-1) // duration

   328     << qint64(0) // position (duration/2)

   329     << false // seekable

   330     << false // seekableWhilePlaying 

   331     << 50 // volume

   332     << false // videoAvailable

   333     << false //audioAvailable

   334     << qreal(0) // playbackRate

   335     << QMediaPlayer::ResourceError // error

   336     << QString(); // errorString

   337 

   338     QTest::newRow("test_WMV.dat")

   339     << true //valid

   340     << QMediaPlayer::StoppedState // state

   341     << QMediaPlayer::LoadedMedia // status

   342     << QMediaContent(QUrl("file:///C:/data/testfiles/test_WMV.dat")) // mediaContent

   343     << qint64(3098) // duration

   344     << qint64(1549) // position (duration/2)

   345     << true // seekable

   346     << false // seekableWhilePlaying, on emulator codec leaks memory and causes alloc panic on dtor 

   347     << 50 // volume

   348     << true // videoAvailable

   349     << false //audioAvailable

   350     << qreal(0) // playbackRate

   351     << QMediaPlayer::FormatError // error

   352     << QString(); // errorString

   353 

   354     QTest::newRow("test_WMA.dat")

   355     << false //valid

   356     << QMediaPlayer::StoppedState // state

   357     << QMediaPlayer::InvalidMedia // status

   358     << QMediaContent(QUrl("file:///C:/data/testfiles/test_WMA.dat")) // mediaContent

   359     << qint64(-1) // duration

   360     << qint64(0) // position (duration/2)

   361     << true // seekable

   362     << false // seekableWhilePlaying 

   363     << 50 // volume

   364     << true // videoAvailable

   365     << false //audioAvailable

   366     << qreal(0) // playbackRate

   367     << QMediaPlayer::AccessDeniedError // error

   368     << QString(); // errorString

   369 

   370     QTest::newRow("test_flash_video.flv")

   371     << false // valid

   372     << QMediaPlayer::StoppedState // state

   373     << QMediaPlayer::InvalidMedia // status

   374     << QMediaContent(QUrl("file:///C:/data/testfiles/test_flash_video.flv")) // mediaContent

   375     << qint64(-1) // duration

   376     << qint64(0) // position

   377     << false // seekable

   378     << false // seekableWhilePlaying    

   379     << 50 // volume

   380     << false // videoAvailable

   381     << false //audioAvailable

   382     << qreal(0) // playbackRate

   383     << QMediaPlayer::ResourceError // error

   384     << QString(); // errorString    

   385     

   386     QTest::newRow("test_MXMF.dat")

   387     << true //valid

   388     << QMediaPlayer::StoppedState // state

   389     << QMediaPlayer::LoadedMedia // status

   390     << QMediaContent(QUrl("file:///C:/data/testfiles/test_MXMF.dat")) // mediaContent

   391     << qint64(31980) // duration

   392     << qint64(15990) // position (duration/2)

   393     << true // seekable

   394     << true // seekableWhilePlaying    

   395     << 50 // volume

   396     << false // videoAvailable

   397     << true //audioAvailable

   398     << qreal(0) // playbackRate

   399     << QMediaPlayer::NoError // error

   400     << QString(); // errorString    

   401     

   402     QTest::newRow("test_amr.amr")

   403     << true // valid

   404     << QMediaPlayer::StoppedState // state

   405     << QMediaPlayer::LoadedMedia // status

   406     << QMediaContent(QUrl("file:///C:/data/testfiles/test_amr.amr")) // mediaContent

   407     << qint64(14402) // duration

   408     << qint64(7200) // position

   409     << true // seekable

   410     << false // seekableWhilePlaying    

   411     << 50 // volume

   412     << false // videoAvailable

   413     << true // audioAvailable

   414     << qreal(0) // playbackRate

   415     << QMediaPlayer::NoError // error

   416     << QString(); // errorString    

   417 

   418     QTest::newRow("test_AMR.dat")

   419     << true // valid

   420     << QMediaPlayer::StoppedState // state

   421     << QMediaPlayer::LoadedMedia // status

   422     << QMediaContent(QUrl("file:///C:/data/testfiles/test_AMR.dat")) // mediaContent

   423     << qint64(38509) // duration

   424     << qint64(19255) // position

   425     << true // seekable

   426     << false // seekableWhilePlaying    

   427     << 50 // volume

   428     << false // videoAvailable

   429     << true // audioAvailable

   430     << qreal(0) // playbackRate

   431     << QMediaPlayer::NoError // error

   432     << QString(); // errorString    

   433     

   434     QTest::newRow("test_mp3.mp3")

   435     << false // valid

   436     << QMediaPlayer::StoppedState // state

   437     << QMediaPlayer::InvalidMedia // status

   438     << QMediaContent(QUrl("file:///C:/data/testfiles/test_mp3.mp3")) // mediaContent

   439     << qint64(-1) //qint64(102044)  duration

   440     << qint64(0) // position

   441     << false // seekable

   442     << false // seekableWhilePlaying    

   443     << 50 // volume

   444     << false // videoAvailable

   445     << false // audioAvailable

   446     << qreal(0) // playbackRate

   447     << QMediaPlayer::ResourceError // error

   448     << QString(); // errorString

   449     

   450     QTest::newRow("test_MP3.dat")

   451     << false // valid

   452     << QMediaPlayer::StoppedState // state

   453     << QMediaPlayer::InvalidMedia // status

   454     << QMediaContent(QUrl("file:///C:/data/testfiles/test_MP3.dat")) // mediaContent

   455     << qint64(-1) //qint64(102044)  duration

   456     << qint64(0) // position

   457     << false // seekable

   458     << false // seekableWhilePlaying    

   459     << 50 // volume

   460     << false // videoAvailable

   461     << false // audioAvailable

   462     << qreal(0) // playbackRate

   463     << QMediaPlayer::ResourceError // error

   464     << QString(); // errorString

   465     

   466     QTest::newRow("test_MIDI.dat")

   467     << true // valid

   468     << QMediaPlayer::StoppedState // state

   469     << QMediaPlayer::LoadedMedia // status

   470     << QMediaContent(QUrl("file:///C:/data/testfiles/test_MIDI.dat")) // mediaContent

   471     << qint64(32782) // duration

   472     << qint64(16391) // position

   473     << true // seekable

   474     << true // seekableWhilePlaying    

   475     << 50 // volume

   476     << false // videoAvailable

   477     << true // audioAvailable

   478     << qreal(0) // playbackRate

   479     << QMediaPlayer::NoError // error

   480     << QString(); // errorString

   481 

   482     QTest::newRow("test_ACC.dat")

   483     << false // valid

   484     << QMediaPlayer::StoppedState // state

   485     << QMediaPlayer::InvalidMedia // status

   486     << QMediaContent(QUrl("file:///C:/data/testfiles/test_ACC.dat")) // mediaContent

   487     << qint64(-1) // duration

   488     << qint64(0) // position

   489     << false // seekable

   490     << false // seekableWhilePlaying    

   491     << 50 // volume

   492     << false // videoAvailable

   493     << false // audioAvailable

   494     << qreal(0) // playbackRate

   495     << QMediaPlayer::ResourceError // error

   496     << QString(); // errorString    

   497 

   498     QTest::newRow("test_WAV.dat")

   499     << true // valid

   500     << QMediaPlayer::StoppedState // state

   501     << QMediaPlayer::LoadedMedia // status

   502     << QMediaContent(QUrl("file:///C:/data/testfiles/test_WAV.dat")) // mediaContent

   503     << qint64(2864) // duration

   504     << qint64(1432) // position

   505     << true // seekable

   506     << true // seekableWhilePlaying    

   507     << 50 // volume

   508     << false // videoAvailable

   509     << true // audioAvailable

   510     << qreal(0) // playbackRate

   511     << QMediaPlayer::NoError // error

   512     << QString(); // errorString  

   513 

   514     QTest::newRow("test_stream")

   515     << false // valid

   516     << QMediaPlayer::StoppedState // state

   517     << QMediaPlayer::InvalidMedia // status

   518     << QMediaContent(QUrl("rtsp://v3.cache4.c.youtube.com/CkgLENy73wIaPwlU2rm7yu8PFhMYESARFEIJbXYtZ29vZ2xlSARSB3JlbGF0ZWRaDkNsaWNrVGh1bWJuYWlsYPi6_IXT2rvpSgw=/0/0/0/video.3gp")) // mediaContent

   519     << qint64(-1) // duration

   520     << qint64(0) // position

   521     << false // seekable

   522     << false // seekableWhilePlaying

   523     << 50 // volume

   524     << true // videoAvailable

   525     << false // audioAvailable

   526     << qreal(0) // playbackRate

   527     << QMediaPlayer::AccessDeniedError // error

   528     << QString(); // errorString    

   529 }

   530 

   531 void tst_QMediaPlayer::initTestCase_data_50_armv5()

   532 {

   533     //TODO: add data    

   534 }

   535 

   536 void tst_QMediaPlayer::initTestCase_data_32_winscw()

   537 {

   538     //TODO: add data

   539 }

   540 

   541 void tst_QMediaPlayer::initTestCase_data_32_armv5()

   542 {

   543     //TODO: add data

   544 }

   545 

   546 void tst_QMediaPlayer::initTestCase_data_31_winscw()

   547 {

   548     //backend does not compile on winscw due missing libs.

   549 }

   550 

   551 void tst_QMediaPlayer::initTestCase_data_31_armv5()

   552 {

   553     //TODO: add data

   554 }

   555 

   556 void tst_QMediaPlayer::initTestCase()

   557 {

   558     m_player = new QMediaPlayer();

   559     

   560     // Symbian back end needs coecontrol for creation.

   561     m_widget = new QVideoWidget();

   562     m_widget->setMediaObject(m_player);    

   563     m_widget->show();

   564     runonce = false;

   565 }

   566 

   567 void tst_QMediaPlayer::cleanupTestCase()

   568 {

   569     delete m_player;

   570     delete m_widget;

   571 }

   572 

   573 void tst_QMediaPlayer::init()

   574 {

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

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

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

   578 	qRegisterMetaType<QMediaContent>("QMediaContent");

   579 }

   580 

   581 void tst_QMediaPlayer::cleanup()

   582 {

   583 }

   584 

   585 void tst_QMediaPlayer::testNullService()

   586 {

   587     if(runonce)

   588         return;

   589     MockProvider provider(0);

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

   591 

   592     const QIODevice *nullDevice = 0;

   593 

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

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

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

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

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

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

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

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

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

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

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

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

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

   607 

   608     {

   609         QFETCH_GLOBAL(QMediaContent, mediaContent);

   610 

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

   612         QFile file;

   613 

   614         player.setMedia(mediaContent, &file);

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

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

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

   618     } {

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

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

   621 

   622         player.play();

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

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

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

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

   627 

   628         player.pause();

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

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

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

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

   633 

   634         player.stop();

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

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

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

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

   639     } {

   640         QFETCH_GLOBAL(int, volume);

   641 

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

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

   644 

   645         player.setVolume(volume);

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

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

   648 

   649         player.setMuted(false);

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

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

   652     } {

   653         QFETCH_GLOBAL(qint64, position);

   654 

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

   656 

   657         player.setPosition(position);

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

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

   660     } {

   661         QFETCH_GLOBAL(qreal, playbackRate);

   662 

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

   664 

   665         player.setPlaybackRate(playbackRate);

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

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

   668     } {

   669         QMediaPlaylist playlist;

   670         playlist.setMediaObject(&player);

   671 

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

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

   674 

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

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

   677 

   678         playlist.setCurrentIndex(0);

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

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

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

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

   683 

   684         playlist.next();

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

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

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

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

   689     }

   690     runonce = true;

   691 }

   692 

   693 void tst_QMediaPlayer::testMedia()

   694 {

   695     QFETCH_GLOBAL(QMediaContent, mediaContent);

   696     m_player->setMedia(mediaContent);

   697     QTest::qWait(500); 

   698     QCOMPARE(m_player->media(), mediaContent);

   699 }

   700 

   701 

   702 void tst_QMediaPlayer::testDuration()

   703 {

   704     QFETCH_GLOBAL(QMediaContent, mediaContent);

   705     QFETCH_GLOBAL(qint64, duration);

   706     QFETCH_GLOBAL(bool, valid);

   707     

   708     QSignalSpy spy(m_player, SIGNAL(durationChanged(qint64)));

   709     m_player->setMedia(mediaContent);

   710     

   711     if(valid) {

   712         WAIT_FOR_CONDITION(spy.count(), 1);

   713     } else {

   714         WAIT_FOR_CONDITION(m_player->mediaStatus(), (QMediaPlayer::NoMedia || QMediaPlayer::InvalidMedia));

   715     }

   716     

   717     QVERIFY(m_player->duration() == duration);

   718     //qDebug()<<m_player->duration()<<m_player->error();;

   719 }

   720 

   721 void tst_QMediaPlayer::testPosition()

   722 {

   723     QFETCH_GLOBAL(QMediaContent, mediaContent);

   724     QFETCH_GLOBAL(qint64, duration);

   725     QFETCH_GLOBAL(bool, valid);

   726     QFETCH_GLOBAL(bool, seekable);

   727     QFETCH_GLOBAL(qint64, position);

   728     QFETCH_GLOBAL(QMediaPlayer::MediaStatus, status);

   729     

   730     m_player->setMedia(mediaContent);

   731     

   732     if (valid) {

   733         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);

   734         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);

   735         

   736         QCOMPARE(m_player->isSeekable(), seekable);

   737         QCOMPARE(m_player->mediaStatus(), status);

   738         

   739         // preset position

   740         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   741         m_player->setPosition(position);

   742         QCOMPARE(m_player->position(), position);

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

   744         QCOMPARE(spy.at(0).at(0).toLongLong(), position);}

   745 

   746         // same pos second time

   747         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   748         m_player->setPosition(position);

   749         QCOMPARE(m_player->position(), position);

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

   751         

   752         //zero pos

   753         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   754         m_player->setPosition(0);

   755         QCOMPARE(m_player->position(), qint64(0));

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

   757         QCOMPARE(spy.at(0).at(0).toLongLong(),  qint64(0));}

   758         

   759         //end pos

   760         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   761         m_player->setPosition(duration);

   762         QCOMPARE(m_player->position(), duration);

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

   764         QCOMPARE(spy.at(0).at(0).toLongLong(),  duration);}

   765 

   766         //negative pos

   767         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   768         m_player->setPosition(qint64(-1));

   769         QCOMPARE(m_player->position(), qint64(0));

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

   771         QCOMPARE(spy.at(0).at(0).toLongLong(),  qint64(0));}

   772         

   773         //over duration

   774         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   775         m_player->setPosition(duration+1);

   776         QCOMPARE(m_player->position(), duration);

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

   778         QCOMPARE(spy.at(0).at(0).toLongLong(),  duration);}

   779         

   780     } else {

   781         WAIT_FOR_CONDITION(m_player->mediaStatus(), (QMediaPlayer::NoMedia || QMediaPlayer::InvalidMedia));

   782         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);

   783         QCOMPARE(m_player->isSeekable(), seekable);

   784         QCOMPARE(m_player->mediaStatus(), status);

   785     }

   786 }

   787 

   788 void tst_QMediaPlayer::testPositionWhilePlaying()

   789 {

   790     QFETCH_GLOBAL(QMediaContent, mediaContent);

   791     QFETCH_GLOBAL(qint64, duration);

   792     QFETCH_GLOBAL(bool, seekableWhilePlaying);

   793     QFETCH_GLOBAL(bool, seekable);

   794     QFETCH_GLOBAL(qint64, position);

   795     QFETCH_GLOBAL(bool, valid);

   796     QFETCH_GLOBAL(QMediaPlayer::MediaStatus, status);

   797     

   798     m_player->setMedia(mediaContent);

   799     WAIT_FOR_CONDITION(m_player->mediaStatus(), (QMediaPlayer::NoMedia || QMediaPlayer::InvalidMedia || QMediaPlayer::LoadedMedia));

   800     

   801     //qDebug()<<"";

   802     QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);

   803     QCOMPARE(m_player->isSeekable(), seekable);

   804     QCOMPARE(m_player->mediaStatus(), status);

   805     

   806     if (seekableWhilePlaying) {

   807         QCOMPARE(m_player->isSeekable(), seekableWhilePlaying);

   808         

   809         // preset position

   810         //qDebug()<<"preset";

   811         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   812         m_player->play();

   813         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);

   814         QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);

   815         m_player->setPosition(position);

   816         WAIT_FOR_CONDITION(spy.count(), 2);

   817         QVERIFY(m_player->mediaStatus() == QMediaPlayer::BufferingMedia || 

   818                 m_player->mediaStatus() == QMediaPlayer::BufferedMedia);

   819         

   820         QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);        

   821         QVERIFY(m_player->position()>=position);

   822         QVERIFY(spy.count()!=0);}

   823   

   824         //reset position 

   825         m_player->stop();

   826         m_player->setPosition(position);

   827         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);

   828         

   829         //zero pos

   830         //qDebug()<<"zero";

   831         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   832         m_player->play();

   833         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);

   834         QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);

   835         m_player->setPosition(0);

   836         WAIT_FOR_CONDITION(spy.count(), 2);

   837         QVERIFY(m_player->mediaStatus() == QMediaPlayer::BufferingMedia || 

   838                 m_player->mediaStatus() == QMediaPlayer::BufferedMedia);

   839         QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);

   840         QVERIFY(m_player->position() >= qint64(0));

   841         QVERIFY(spy.count()!=0);}

   842 

   843         //reset position 

   844         m_player->stop();

   845         m_player->setPosition(position);

   846         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);

   847         

   848         //end pos

   849         //qDebug()<<"dur";

   850         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   851         m_player->play();

   852         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);

   853         QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);

   854         m_player->setPosition(duration);

   855         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::EndOfMedia);

   856         QCOMPARE(m_player->mediaStatus(), QMediaPlayer::EndOfMedia);

   857         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);        

   858         QCOMPARE(m_player->position(), qint64(0));

   859         QVERIFY(spy.count()!=0);}

   860 

   861         //reset position

   862         m_player->stop();

   863         m_player->setPosition(position);

   864         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);

   865         

   866         //negative pos

   867         //qDebug()<<"negavite";

   868         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   869         m_player->play();

   870         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);

   871         QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);

   872         m_player->setPosition(qint64(-1));

   873         WAIT_FOR_CONDITION(spy.count(), 2);

   874         QVERIFY(m_player->mediaStatus() == QMediaPlayer::BufferingMedia || 

   875                 m_player->mediaStatus() == QMediaPlayer::BufferedMedia);

   876         QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);        

   877         QVERIFY(m_player->position() >= qint64(0));

   878         QVERIFY(spy.count()!=0);}

   879 

   880         //reset position 

   881         m_player->stop();

   882         m_player->setPosition(position);

   883         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);        

   884         

   885         //over duration

   886         //qDebug()<<"over";

   887         { QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));

   888         m_player->play();

   889         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);

   890         QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);

   891         m_player->setPosition(duration+1);

   892         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::EndOfMedia);

   893         QCOMPARE(m_player->mediaStatus(), QMediaPlayer::EndOfMedia);

   894         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);        

   895         QCOMPARE(m_player->position(), qint64(0));

   896         QVERIFY(spy.count()!=0);}

   897         

   898     } else

   899         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);

   900 

   901     m_player->stop();

   902     QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);

   903     //qDebug()<<"end";

   904 }

   905 

   906 

   907 void tst_QMediaPlayer::testVolume()

   908 {

   909     QFETCH_GLOBAL(int, volume);

   910 

   911     // preset volume

   912     { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

   913     m_player->setVolume(volume);

   914     QCOMPARE(m_player->volume(), volume);

   915     QCOMPARE(m_player->isMuted(), false);

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

   917 

   918     // same volume

   919     { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

   920     int currentVolume = m_player->volume();

   921     m_player->setVolume(currentVolume);

   922     QCOMPARE(m_player->volume(), currentVolume);

   923     QCOMPARE(m_player->isMuted(), false);

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

   925 

   926     // zero volume

   927     { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

   928     m_player->setVolume(0);

   929     QCOMPARE(m_player->volume(), 0);

   930     QCOMPARE(m_player->isMuted(), false);

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

   932 

   933     // max volume

   934     { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

   935     m_player->setVolume(100);

   936     QCOMPARE(m_player->volume(), 100);

   937     QCOMPARE(m_player->isMuted(), false);

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

   939 

   940     // negative volume

   941     { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

   942     m_player->setVolume(int(-1));

   943     QCOMPARE(m_player->volume(), 0);

   944     QCOMPARE(m_player->isMuted(), false);

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

   946 

   947     // over max volume

   948     { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

   949     m_player->setVolume(1000);

   950     QCOMPARE(m_player->volume(), 100);

   951     QCOMPARE(m_player->isMuted(), false);

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

   953 }

   954 

   955 void tst_QMediaPlayer::testVolumeWhilePlaying()

   956 {

   957     QFETCH_GLOBAL(QMediaContent, mediaContent);

   958     QFETCH_GLOBAL(int, volume);

   959     QFETCH_GLOBAL(bool, valid);

   960     

   961     if (valid) {

   962         m_player->setMedia(mediaContent);

   963         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);

   964         

   965         m_player->play();

   966         QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);

   967         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);

   968         

   969         // preset volume

   970         { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

   971         m_player->setVolume(volume);

   972         QCOMPARE(m_player->volume(), volume);

   973         QCOMPARE(m_player->isMuted(), false);

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

   975     

   976         // same volume

   977         { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

   978         int currentVolume = m_player->volume();

   979         m_player->setVolume(currentVolume);

   980         QCOMPARE(m_player->volume(), currentVolume);

   981         QCOMPARE(m_player->isMuted(), false);

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

   983     

   984         // zero volume

   985         { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

   986         m_player->setVolume(0);

   987         QCOMPARE(m_player->volume(), 0);

   988         QCOMPARE(m_player->isMuted(), false);

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

   990     

   991         // max volume

   992         { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

   993         m_player->setVolume(100);

   994         QCOMPARE(m_player->volume(), 100);

   995         QCOMPARE(m_player->isMuted(), false);

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

   997     

   998         // negative volume

   999         { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

  1000         m_player->setVolume(int(-1));

  1001         QCOMPARE(m_player->volume(), 0);

  1002         QCOMPARE(m_player->isMuted(), false);

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

  1004     

  1005         // over max volume

  1006         { QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));

  1007         m_player->setVolume(1000);

  1008         QCOMPARE(m_player->volume(), 100);

  1009         QCOMPARE(m_player->isMuted(), false);

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

  1011         

  1012         m_player->stop();

  1013         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);    

  1014     }

  1015 }

  1016 

  1017 

  1018 void tst_QMediaPlayer::testMuted()

  1019 {

  1020     QFETCH_GLOBAL(int, volume);

  1021 

  1022     //reset mute & volume

  1023     m_player->setMuted(false);

  1024     m_player->setVolume(0);

  1025     QVERIFY(m_player->isMuted() == false);

  1026     QCOMPARE(m_player->volume(), 0);

  1027     

  1028     // set muted

  1029     {QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));

  1030     m_player->setMuted(true);

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

  1032     QVERIFY(m_player->isMuted() == true);}

  1033 

  1034     // set muted again

  1035     {QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));

  1036     m_player->setMuted(true);

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

  1038     QVERIFY(m_player->isMuted() == true);}

  1039     

  1040     // unmute

  1041     {QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));

  1042     m_player->setMuted(false);

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

  1044     QVERIFY(m_player->isMuted() == false);}

  1045 

  1046     // set volume while muted

  1047     {QSignalSpy muteSpy(m_player, SIGNAL(mutedChanged(bool)));

  1048     QSignalSpy volumeSpy(m_player, SIGNAL(volumeChanged(int)));

  1049     m_player->setMuted(true);

  1050     m_player->setVolume(volume);

  1051     QCOMPARE(m_player->volume(), volume);

  1052     QCOMPARE(muteSpy.count(), 1);

  1053     QCOMPARE(volumeSpy.count(), 1);

  1054     QVERIFY(m_player->isMuted() == true);}

  1055 }

  1056 

  1057 void tst_QMediaPlayer::testMutedWhilePlaying()

  1058 {

  1059     QFETCH_GLOBAL(QMediaContent, mediaContent);

  1060     QFETCH_GLOBAL(int, volume);

  1061     QFETCH_GLOBAL(bool, valid);

  1062     

  1063     if (valid) {

  1064         m_player->setMedia(mediaContent);

  1065         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);

  1066         

  1067         //reset mute & volume

  1068         m_player->setMuted(false);

  1069         m_player->setVolume(65);

  1070         QVERIFY(m_player->isMuted() == false);

  1071         QCOMPARE(m_player->volume(), 65);

  1072         

  1073         m_player->play();

  1074         QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);

  1075         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);

  1076         

  1077         // set muted

  1078         {QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));

  1079         m_player->setMuted(true);

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

  1081         QVERIFY(m_player->isMuted() == true);}

  1082     

  1083         // set muted again

  1084         {QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));

  1085         m_player->setMuted(true);

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

  1087         QVERIFY(m_player->isMuted() == true);}

  1088         

  1089         // unmute

  1090         {QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));

  1091         m_player->setMuted(false);

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

  1093         QVERIFY(m_player->isMuted() == false);}

  1094     

  1095         // set volume while muted

  1096         {QSignalSpy muteSpy(m_player, SIGNAL(mutedChanged(bool)));

  1097         QSignalSpy volumeSpy(m_player, SIGNAL(volumeChanged(int)));

  1098         m_player->setMuted(true);

  1099         m_player->setVolume(volume);

  1100         QCOMPARE(m_player->volume(), volume);

  1101         QCOMPARE(muteSpy.count(), 1);

  1102         QCOMPARE(volumeSpy.count(), 1);

  1103         QVERIFY(m_player->isMuted() == true);}

  1104         

  1105         m_player->stop();

  1106         QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);        

  1107     }

  1108 }

  1109 

  1110 

  1111 void tst_QMediaPlayer::testVideoAndAudioAvailability()

  1112 {

  1113     QFETCH_GLOBAL(bool, videoAvailable);

  1114     QFETCH_GLOBAL(bool, audioAvailable);

  1115     QFETCH_GLOBAL(bool, valid);

  1116     QFETCH_GLOBAL(QMediaContent, mediaContent);

  1117     

  1118     if(valid) {        

  1119         QSignalSpy audioAvailableSpy(m_player, SIGNAL(audioAvailableChanged(bool)));

  1120         QSignalSpy videoAvailableSpy(m_player, SIGNAL(videoAvailableChanged(bool)));

  1121         

  1122         m_player->setMedia(mediaContent);

  1123         WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);

  1124         

  1125         QVERIFY(m_player->isVideoAvailable() == videoAvailable);

  1126         QVERIFY(m_player->isAudioAvailable() == audioAvailable);

  1127         

  1128         QCOMPARE(audioAvailableSpy.count(), 1);

  1129         QCOMPARE(videoAvailableSpy.count(), 1);

  1130     }

  1131 }

  1132 

  1133 void tst_QMediaPlayer::testError()

  1134 {