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 <QDebug>

    44 #include "qmediaservice.h"

    45 #include "qmediaplaylist.h"

    46 #include "qmediaplaylistcontrol.h"

    47 #include "qmediaplaylistnavigator.h"

    48 #include "qmediapluginloader_p.h"

    49 

    50 #include "qm3uhandler.h"

    51 

    52 QT_USE_NAMESPACE

    53 class MockReadOnlyPlaylistProvider : public QMediaPlaylistProvider

    54 {

    55     Q_OBJECT

    56 public:

    57     MockReadOnlyPlaylistProvider(QObject *parent)

    58         :QMediaPlaylistProvider(parent)

    59     {

    60         m_items.append(QMediaContent(QUrl(QLatin1String("file:///1"))));

    61         m_items.append(QMediaContent(QUrl(QLatin1String("file:///2"))));

    62         m_items.append(QMediaContent(QUrl(QLatin1String("file:///3"))));

    63     }

    64 

    65     int mediaCount() const { return m_items.size(); }

    66     QMediaContent media(int index) const

    67     {

    68         return index >=0 && index < mediaCount() ? m_items.at(index) : QMediaContent();

    69     }

    70 

    71 private:

    72     QList<QMediaContent> m_items;

    73 };

    74 

    75 class MockPlaylistControl : public QMediaPlaylistControl

    76 {

    77     Q_OBJECT

    78 public:

    79     MockPlaylistControl(QObject *parent) : QMediaPlaylistControl(parent)

    80     {        

    81         m_navigator = new QMediaPlaylistNavigator(new MockReadOnlyPlaylistProvider(this), this);

    82     }

    83 

    84     ~MockPlaylistControl()

    85     {

    86     }

    87 

    88     QMediaPlaylistProvider* playlistProvider() const { return m_navigator->playlist(); }

    89     bool setPlaylistProvider(QMediaPlaylistProvider *playlist) { m_navigator->setPlaylist(playlist); return true; }

    90 

    91     int currentIndex() const { return m_navigator->currentIndex(); }

    92     void setCurrentIndex(int position) { m_navigator->jump(position); }

    93     int nextIndex(int steps) const { return m_navigator->nextIndex(steps); }

    94     int previousIndex(int steps) const { return m_navigator->previousIndex(steps); }

    95 

    96     void next() { m_navigator->next(); }

    97     void previous() { m_navigator->previous(); }

    98 

    99     QMediaPlaylist::PlaybackMode playbackMode() const { return m_navigator->playbackMode(); }

   100     void setPlaybackMode(QMediaPlaylist::PlaybackMode mode) { m_navigator->setPlaybackMode(mode); }

   101 

   102 private:    

   103     QMediaPlaylistNavigator *m_navigator;

   104 };

   105 

   106 class MockPlaylistService : public QMediaService

   107 {

   108     Q_OBJECT

   109 

   110 public:

   111     MockPlaylistService():QMediaService(0)

   112     {

   113         mockControl = new MockPlaylistControl(this);

   114     }

   115 

   116     ~MockPlaylistService()

   117     {        

   118     }

   119 

   120     QMediaControl* requestControl(const char *iid)

   121     {

   122         if (qstrcmp(iid, QMediaPlaylistControl_iid) == 0)

   123             return mockControl;

   124         return 0;

   125     }

   126 

   127     void releaseControl(QMediaControl *)

   128     {

   129     }

   130 

   131     MockPlaylistControl *mockControl;

   132 };

   133 

   134 class MockReadOnlyPlaylistObject : public QMediaObject

   135 {

   136     Q_OBJECT

   137 public:

   138     MockReadOnlyPlaylistObject(QObject *parent = 0)

   139         :QMediaObject(parent, new MockPlaylistService)

   140     {

   141     }

   142 };

   143 

   144 

   145 class tst_QMediaPlaylist : public QObject

   146 {

   147     Q_OBJECT

   148 public slots:

   149     void init();

   150     void cleanup();

   151     void initTestCase();

   152 

   153 private slots:

   154     void construction();

   155     void append();

   156     void insert();

   157     void clear();

   158     void removeMedia();

   159     void currentItem();

   160     void saveAndLoad();

   161     void playbackMode();

   162     void playbackMode_data();

   163     void shuffle();

   164     void readOnlyPlaylist();

   165     void setMediaObject();

   166 

   167 private:

   168     QMediaContent content1;

   169     QMediaContent content2;

   170     QMediaContent content3;

   171 };

   172 

   173 void tst_QMediaPlaylist::init()

   174 {

   175 }

   176 

   177 void tst_QMediaPlaylist::initTestCase()

   178 {

   179     content1 = QMediaContent(QUrl(QLatin1String("file:///1")));

   180     content2 = QMediaContent(QUrl(QLatin1String("file:///2")));

   181     content3 = QMediaContent(QUrl(QLatin1String("file:///3")));

   182 

   183     QMediaPluginLoader::setStaticPlugins(QLatin1String("/playlistformats"), QObjectList() << new QM3uPlaylistPlugin(this));

   184 }

   185 

   186 void tst_QMediaPlaylist::cleanup()

   187 {

   188 }

   189 

   190 void tst_QMediaPlaylist::construction()

   191 {

   192     QMediaPlaylist playlist;

   193     QCOMPARE(playlist.mediaCount(), 0);

   194     QVERIFY(playlist.isEmpty());

   195 }

   196 

   197 void tst_QMediaPlaylist::append()

   198 {

   199     QMediaPlaylist playlist;

   200     QVERIFY(!playlist.isReadOnly());

   201 

   202     playlist.addMedia(content1);

   203     QCOMPARE(playlist.mediaCount(), 1);

   204     QCOMPARE(playlist.media(0), content1);

   205 

   206     QSignalSpy aboutToBeInsertedSignalSpy(&playlist, SIGNAL(mediaAboutToBeInserted(int,int)));

   207     QSignalSpy insertedSignalSpy(&playlist, SIGNAL(mediaInserted(int,int)));

   208     playlist.addMedia(content2);

   209     QCOMPARE(playlist.mediaCount(), 2);

   210     QCOMPARE(playlist.media(1), content2);

   211 

   212     QCOMPARE(aboutToBeInsertedSignalSpy.count(), 1);

   213     QCOMPARE(aboutToBeInsertedSignalSpy.first()[0].toInt(), 1);

   214     QCOMPARE(aboutToBeInsertedSignalSpy.first()[1].toInt(), 1);

   215 

   216     QCOMPARE(insertedSignalSpy.count(), 1);

   217     QCOMPARE(insertedSignalSpy.first()[0].toInt(), 1);

   218     QCOMPARE(insertedSignalSpy.first()[1].toInt(), 1);

   219 

   220     aboutToBeInsertedSignalSpy.clear();

   221     insertedSignalSpy.clear();

   222 

   223     QMediaContent content4(QUrl(QLatin1String("file:///4")));

   224     QMediaContent content5(QUrl(QLatin1String("file:///5")));

   225     playlist.addMedia(QList<QMediaContent>() << content3 << content4 << content5);

   226     QCOMPARE(playlist.mediaCount(), 5);

   227     QCOMPARE(playlist.media(2), content3);

   228     QCOMPARE(playlist.media(3), content4);

   229     QCOMPARE(playlist.media(4), content5);

   230 

   231     QCOMPARE(aboutToBeInsertedSignalSpy.count(), 1);

   232     QCOMPARE(aboutToBeInsertedSignalSpy[0][0].toInt(), 2);

   233     QCOMPARE(aboutToBeInsertedSignalSpy[0][1].toInt(), 4);

   234 

   235     QCOMPARE(insertedSignalSpy.count(), 1);

   236     QCOMPARE(insertedSignalSpy[0][0].toInt(), 2);

   237     QCOMPARE(insertedSignalSpy[0][1].toInt(), 4);

   238 

   239     aboutToBeInsertedSignalSpy.clear();

   240     insertedSignalSpy.clear();

   241 

   242     playlist.addMedia(QList<QMediaContent>());

   243     QCOMPARE(aboutToBeInsertedSignalSpy.count(), 0);

   244     QCOMPARE(insertedSignalSpy.count(), 0);

   245 }

   246 

   247 void tst_QMediaPlaylist::insert()

   248 {

   249     QMediaPlaylist playlist;

   250     QVERIFY(!playlist.isReadOnly());

   251 

   252     playlist.addMedia(content1);

   253     QCOMPARE(playlist.mediaCount(), 1);

   254     QCOMPARE(playlist.media(0), content1);

   255 

   256     playlist.addMedia(content2);

   257     QCOMPARE(playlist.mediaCount(), 2);

   258     QCOMPARE(playlist.media(1), content2);

   259 

   260     QSignalSpy aboutToBeInsertedSignalSpy(&playlist, SIGNAL(mediaAboutToBeInserted(int,int)));

   261     QSignalSpy insertedSignalSpy(&playlist, SIGNAL(mediaInserted(int,int)));

   262 

   263     playlist.insertMedia(1, content3);

   264     QCOMPARE(playlist.mediaCount(), 3);

   265     QCOMPARE(playlist.media(0), content1);

   266     QCOMPARE(playlist.media(1), content3);

   267     QCOMPARE(playlist.media(2), content2);

   268 

   269     QCOMPARE(aboutToBeInsertedSignalSpy.count(), 1);

   270     QCOMPARE(aboutToBeInsertedSignalSpy.first()[0].toInt(), 1);

   271     QCOMPARE(aboutToBeInsertedSignalSpy.first()[1].toInt(), 1);

   272 

   273     QCOMPARE(insertedSignalSpy.count(), 1);

   274     QCOMPARE(insertedSignalSpy.first()[0].toInt(), 1);

   275     QCOMPARE(insertedSignalSpy.first()[1].toInt(), 1);

   276 

   277     aboutToBeInsertedSignalSpy.clear();

   278     insertedSignalSpy.clear();

   279 

   280     QMediaContent content4(QUrl(QLatin1String("file:///4")));

   281     QMediaContent content5(QUrl(QLatin1String("file:///5")));

   282     playlist.insertMedia(1, QList<QMediaContent>() << content4 << content5);

   283 

   284     QCOMPARE(playlist.media(0), content1);

   285     QCOMPARE(playlist.media(1), content4);

   286     QCOMPARE(playlist.media(2), content5);

   287     QCOMPARE(playlist.media(3), content3);

   288     QCOMPARE(playlist.media(4), content2);

   289     QCOMPARE(aboutToBeInsertedSignalSpy.count(), 1);

   290     QCOMPARE(aboutToBeInsertedSignalSpy[0][0].toInt(), 1);

   291     QCOMPARE(aboutToBeInsertedSignalSpy[0][1].toInt(), 2);

   292 

   293     QCOMPARE(insertedSignalSpy.count(), 1);

   294     QCOMPARE(insertedSignalSpy[0][0].toInt(), 1);

   295     QCOMPARE(insertedSignalSpy[0][1].toInt(), 2);

   296 

   297     aboutToBeInsertedSignalSpy.clear();

   298     insertedSignalSpy.clear();

   299 

   300     playlist.insertMedia(1, QList<QMediaContent>());

   301     QCOMPARE(aboutToBeInsertedSignalSpy.count(), 0);

   302     QCOMPARE(insertedSignalSpy.count(), 0);

   303 }

   304 

   305 

   306 void tst_QMediaPlaylist::currentItem()

   307 {

   308     QMediaPlaylist playlist;

   309     playlist.addMedia(content1);

   310     playlist.addMedia(content2);

   311 

   312     QCOMPARE(playlist.currentIndex(), -1);

   313     QCOMPARE(playlist.currentMedia(), QMediaContent());

   314 

   315     QCOMPARE(playlist.nextIndex(), 0);

   316     QCOMPARE(playlist.nextIndex(2), 1);

   317     QCOMPARE(playlist.previousIndex(), 1);

   318     QCOMPARE(playlist.previousIndex(2), 0);

   319 

   320     playlist.setCurrentIndex(0);

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

   322     QCOMPARE(playlist.currentMedia(), content1);

   323 

   324     QCOMPARE(playlist.nextIndex(), 1);

   325     QCOMPARE(playlist.nextIndex(2), -1);

   326     QCOMPARE(playlist.previousIndex(), -1);

   327     QCOMPARE(playlist.previousIndex(2), -1);

   328 

   329     playlist.setCurrentIndex(1);

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

   331     QCOMPARE(playlist.currentMedia(), content2);

   332 

   333     QCOMPARE(playlist.nextIndex(), -1);

   334     QCOMPARE(playlist.nextIndex(2), -1);

   335     QCOMPARE(playlist.previousIndex(), 0);

   336     QCOMPARE(playlist.previousIndex(2), -1);

   337 

   338     QTest::ignoreMessage(QtWarningMsg, "QMediaPlaylistNavigator: Jump outside playlist range ");

   339     playlist.setCurrentIndex(2);

   340 

   341     QCOMPARE(playlist.currentIndex(), -1);

   342     QCOMPARE(playlist.currentMedia(), QMediaContent());

   343 }

   344 

   345 void tst_QMediaPlaylist::clear()

   346 {

   347     QMediaPlaylist playlist;

   348     playlist.addMedia(content1);

   349     playlist.addMedia(content2);

   350 

   351     playlist.clear();

   352     QVERIFY(playlist.isEmpty());

   353     QCOMPARE(playlist.mediaCount(), 0);

   354 }

   355 

   356 void tst_QMediaPlaylist::removeMedia()

   357 {

   358     QMediaPlaylist playlist;

   359     playlist.addMedia(content1);

   360     playlist.addMedia(content2);

   361     playlist.addMedia(content3);

   362 

   363     QSignalSpy aboutToBeRemovedSignalSpy(&playlist, SIGNAL(mediaAboutToBeRemoved(int,int)));

   364     QSignalSpy removedSignalSpy(&playlist, SIGNAL(mediaRemoved(int,int)));

   365     playlist.removeMedia(1);

   366     QCOMPARE(playlist.mediaCount(), 2);

   367     QCOMPARE(playlist.media(1), content3);

   368 

   369     QCOMPARE(aboutToBeRemovedSignalSpy.count(), 1);

   370     QCOMPARE(aboutToBeRemovedSignalSpy.first()[0].toInt(), 1);

   371     QCOMPARE(aboutToBeRemovedSignalSpy.first()[1].toInt(), 1);

   372 

   373     QCOMPARE(removedSignalSpy.count(), 1);

   374     QCOMPARE(removedSignalSpy.first()[0].toInt(), 1);

   375     QCOMPARE(removedSignalSpy.first()[1].toInt(), 1);

   376 

   377     aboutToBeRemovedSignalSpy.clear();

   378     removedSignalSpy.clear();

   379 

   380     playlist.removeMedia(0,1);

   381     QVERIFY(playlist.isEmpty());

   382 

   383     QCOMPARE(aboutToBeRemovedSignalSpy.count(), 1);

   384     QCOMPARE(aboutToBeRemovedSignalSpy.first()[0].toInt(), 0);

   385     QCOMPARE(aboutToBeRemovedSignalSpy.first()[1].toInt(), 1);

   386 

   387     QCOMPARE(removedSignalSpy.count(), 1);

   388     QCOMPARE(removedSignalSpy.first()[0].toInt(), 0);

   389     QCOMPARE(removedSignalSpy.first()[1].toInt(), 1);

   390 

   391 

   392     playlist.addMedia(content1);

   393     playlist.addMedia(content2);

   394     playlist.addMedia(content3);

   395 

   396     playlist.removeMedia(0,1);

   397     QCOMPARE(playlist.mediaCount(), 1);

   398     QCOMPARE(playlist.media(0), content3);

   399 }

   400 

   401 void tst_QMediaPlaylist::saveAndLoad()

   402 {

   403     QMediaPlaylist playlist;

   404     playlist.addMedia(content1);

   405     playlist.addMedia(content2);

   406     playlist.addMedia(content3);

   407 

   408     QCOMPARE(playlist.error(), QMediaPlaylist::NoError);

   409     QVERIFY(playlist.errorString().isEmpty());

   410 

   411     QBuffer buffer;

   412     buffer.open(QBuffer::ReadWrite);

   413 

   414     bool res = playlist.save(&buffer, "unsupported_format");

   415     QVERIFY(!res);

   416     QVERIFY(playlist.error() != QMediaPlaylist::NoError);

   417     QVERIFY(!playlist.errorString().isEmpty());

   418 

   419     QSignalSpy errorSignal(&playlist, SIGNAL(loadFailed()));

   420     playlist.load(&buffer, "unsupported_format");

   421     QCOMPARE(errorSignal.size(), 1);

   422     QVERIFY(playlist.error() != QMediaPlaylist::NoError);

   423     QVERIFY(!playlist.errorString().isEmpty());

   424 

   425     res = playlist.save(QUrl(QLatin1String("tmp.unsupported_format")), "unsupported_format");

   426     QVERIFY(!res);

   427     QVERIFY(playlist.error() != QMediaPlaylist::NoError);

   428     QVERIFY(!playlist.errorString().isEmpty());

   429 

   430     errorSignal.clear();

   431     playlist.load(QUrl(QLatin1String("tmp.unsupported_format")), "unsupported_format");

   432     QCOMPARE(errorSignal.size(), 1);

   433     QVERIFY(playlist.error() != QMediaPlaylist::NoError);

   434     QVERIFY(!playlist.errorString().isEmpty());

   435 

   436     res = playlist.save(&buffer, "m3u");

   437 

   438     QVERIFY(res);

   439     QVERIFY(buffer.pos() > 0);

   440     buffer.seek(0);

   441 

   442     QMediaPlaylist playlist2;

   443     playlist2.load(&buffer, "m3u");

   444     QCOMPARE(playlist.error(), QMediaPlaylist::NoError);

   445 

   446     QCOMPARE(playlist.mediaCount(), playlist2.mediaCount());

   447     QCOMPARE(playlist.media(0), playlist2.media(0));

   448     QCOMPARE(playlist.media(1), playlist2.media(1));

   449     QCOMPARE(playlist.media(3), playlist2.media(3));

   450 #ifdef Q_OS_SYMBIAN

   451     res = playlist.save(QUrl(QLatin1String("file:///c:/data/test_m3u.m3u")), "m3u");

   452 #else

   453     res = playlist.save(QUrl(QLatin1String("tmp.m3u")), "m3u");

   454 #endif

   455     QVERIFY(res);

   456 

   457     playlist2.clear();

   458     QVERIFY(playlist2.isEmpty());

   459 #ifdef Q_OS_SYMBIAN

   460     playlist2.load(QUrl(QLatin1String("file:///c:/data/test_m3u.m3u")), "m3u");

   461 #else

   462     playlist2.load(QUrl(QLatin1String("tmp.m3u")), "m3u");

   463 #endif

   464     QCOMPARE(playlist.error(), QMediaPlaylist::NoError);

   465 

   466     QCOMPARE(playlist.mediaCount(), playlist2.mediaCount());

   467     QCOMPARE(playlist.media(0), playlist2.media(0));

   468     QCOMPARE(playlist.media(1), playlist2.media(1));

   469     QCOMPARE(playlist.media(3), playlist2.media(3));

   470 }

   471 

   472 void tst_QMediaPlaylist::playbackMode_data()

   473 {

   474     QTest::addColumn<QMediaPlaylist::PlaybackMode>("playbackMode");

   475     QTest::addColumn<int>("expectedPrevious");

   476     QTest::addColumn<int>("pos");

   477     QTest::addColumn<int>("expectedNext");

   478 

   479     QTest::newRow("Sequential, 0") << QMediaPlaylist::Sequential << -1 << 0 << 1;

   480     QTest::newRow("Sequential, 1") << QMediaPlaylist::Sequential << 0 << 1 << 2;

   481     QTest::newRow("Sequential, 2") << QMediaPlaylist::Sequential << 1 << 2 << -1;

   482 

   483     QTest::newRow("Loop, 0") << QMediaPlaylist::Loop << 2 << 0 << 1;

   484     QTest::newRow("Loop, 1") << QMediaPlaylist::Loop << 0 << 1 << 2;

   485     QTest::newRow("Lopp, 2") << QMediaPlaylist::Loop << 1 << 2 << 0;

   486 

   487     QTest::newRow("ItemOnce, 1") << QMediaPlaylist::CurrentItemOnce << -1 << 1 << -1;

   488     QTest::newRow("ItemInLoop, 1") << QMediaPlaylist::CurrentItemInLoop << 1 << 1 << 1;

   489 

   490 }

   491 

   492 void tst_QMediaPlaylist::playbackMode()

   493 {

   494     QFETCH(QMediaPlaylist::PlaybackMode, playbackMode);

   495     QFETCH(int, expectedPrevious);

   496     QFETCH(int, pos);

   497     QFETCH(int, expectedNext);

   498 

   499     QMediaPlaylist playlist;

   500     playlist.addMedia(content1);

   501     playlist.addMedia(content2);

   502     playlist.addMedia(content3);

   503 

   504     QCOMPARE(playlist.playbackMode(), QMediaPlaylist::Sequential);

   505     QCOMPARE(playlist.currentIndex(), -1);

   506 

   507     playlist.setPlaybackMode(playbackMode);

   508     QCOMPARE(playlist.playbackMode(), playbackMode);

   509 

   510     playlist.setCurrentIndex(pos);

   511     QCOMPARE(playlist.currentIndex(), pos);

   512     QCOMPARE(playlist.nextIndex(), expectedNext);

   513     QCOMPARE(playlist.previousIndex(), expectedPrevious);

   514 

   515     playlist.next();

   516     QCOMPARE(playlist.currentIndex(), expectedNext);

   517 

   518     playlist.setCurrentIndex(pos);

   519     playlist.previous();

   520     QCOMPARE(playlist.currentIndex(), expectedPrevious);

   521 }

   522 

   523 void tst_QMediaPlaylist::shuffle()

   524 {

   525     QMediaPlaylist playlist;

   526     QList<QMediaContent> contentList;

   527 

   528     for (int i=0; i<100; i++) {

   529         QMediaContent content(QUrl(QString::number(i)));

   530         contentList.append(content);

   531         playlist.addMedia(content);

   532     }

   533 

   534     playlist.shuffle();

   535 

   536     QList<QMediaContent> shuffledContentList;

   537     for (int i=0; i<playlist.mediaCount(); i++)

   538         shuffledContentList.append(playlist.media(i));

   539 

   540     QVERIFY(contentList != shuffledContentList);

   541 

   542 }

   543 

   544 void tst_QMediaPlaylist::readOnlyPlaylist()

   545 {

   546     MockReadOnlyPlaylistObject mediaObject;

   547     QMediaPlaylist playlist;

   548     mediaObject.bind(&playlist);

   549 

   550     QVERIFY(playlist.isReadOnly());

   551     QVERIFY(!playlist.isEmpty());

   552     QCOMPARE(playlist.mediaCount(), 3);

   553 

   554     QCOMPARE(playlist.media(0), content1);

   555     QCOMPARE(playlist.media(1), content2);

   556     QCOMPARE(playlist.media(2), content3);

   557     QCOMPARE(playlist.media(3), QMediaContent());

   558 

   559     //it's a read only playlist, so all the modification should fail

   560     QVERIFY(!playlist.addMedia(content1));

   561     QCOMPARE(playlist.mediaCount(), 3);

   562     QVERIFY(!playlist.addMedia(QList<QMediaContent>() << content1 << content2));

   563     QCOMPARE(playlist.mediaCount(), 3);

   564     QVERIFY(!playlist.insertMedia(1, content1));

   565     QCOMPARE(playlist.mediaCount(), 3);

   566     QVERIFY(!playlist.insertMedia(1, QList<QMediaContent>() << content1 << content2));

   567     QCOMPARE(playlist.mediaCount(), 3);

   568     QVERIFY(!playlist.removeMedia(1));

   569     QCOMPARE(playlist.mediaCount(), 3);

   570     QVERIFY(!playlist.removeMedia(0,2));

   571     QCOMPARE(playlist.mediaCount(), 3);

   572     QVERIFY(!playlist.clear());

   573     QCOMPARE(playlist.mediaCount(), 3);

   574 

   575     //but it is still allowed to append/insert an empty list

   576     QVERIFY(playlist.addMedia(QList<QMediaContent>()));

   577     QVERIFY(playlist.insertMedia(1, QList<QMediaContent>()));

   578 

   579     playlist.shuffle();

   580     //it's still the same

   581     QCOMPARE(playlist.media(0), content1);

   582     QCOMPARE(playlist.media(1), content2);

   583     QCOMPARE(playlist.media(2), content3);

   584     QCOMPARE(playlist.media(3), QMediaContent());

   585 

   586 

   587     //load to read only playlist should fail,

   588     //unless underlaying provider supports it

   589     QBuffer buffer;

   590     buffer.open(QBuffer::ReadWrite);

   591     buffer.write(QByteArray("file:///1\nfile:///2"));

   592     buffer.seek(0);

   593 

   594     QSignalSpy errorSignal(&playlist, SIGNAL(loadFailed()));

   595     playlist.load(&buffer, "m3u");    

   596     QCOMPARE(errorSignal.size(), 1);

   597     QCOMPARE(playlist.error(), QMediaPlaylist::AccessDeniedError);

   598     QVERIFY(!playlist.errorString().isEmpty());

   599     QCOMPARE(playlist.mediaCount(), 3);

   600 

   601     errorSignal.clear();

   602     playlist.load(QUrl(QLatin1String("tmp.m3u")), "m3u");

   603 

   604     QCOMPARE(errorSignal.size(), 1);

   605     QCOMPARE(playlist.error(), QMediaPlaylist::AccessDeniedError);

   606     QVERIFY(!playlist.errorString().isEmpty());

   607     QCOMPARE(playlist.mediaCount(), 3);

   608 }

   609 

   610 void tst_QMediaPlaylist::setMediaObject()

   611 {

   612     MockReadOnlyPlaylistObject mediaObject;

   613 

   614     QMediaPlaylist playlist;

   615     QVERIFY(playlist.mediaObject() == 0);

   616     QVERIFY(!playlist.isReadOnly());

   617 

   618     mediaObject.bind(&playlist);

   619     QCOMPARE(playlist.mediaObject(), qobject_cast<QMediaObject*>(&mediaObject));

   620     QCOMPARE(playlist.mediaCount(), 3);

   621     QVERIFY(playlist.isReadOnly());

   622 

   623     mediaObject.unbind(&playlist);

   624     QVERIFY(playlist.mediaObject() == 0);

   625     QCOMPARE(playlist.mediaCount(), 0);

   626     QVERIFY(!playlist.isReadOnly());

   627 

   628     mediaObject.bind(&playlist);

   629     QCOMPARE(playlist.mediaObject(), qobject_cast<QMediaObject*>(&mediaObject));

   630     QCOMPARE(playlist.mediaCount(), 3);

   631     QVERIFY(playlist.isReadOnly());

   632 }

   633 

   634 QTEST_MAIN(tst_QMediaPlaylist)

   635 #include "tst_qmediaplaylist.moc"

   636