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 QTM_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* control(const char *iid) const

   121     {

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

   123             return mockControl;

   124         return 0;

   125     }

   126 

   127     MockPlaylistControl *mockControl;

   128 };

   129 

   130 class MockReadOnlyPlaylistObject : public QMediaObject

   131 {

   132     Q_OBJECT

   133 public:

   134     MockReadOnlyPlaylistObject(QObject *parent = 0)

   135         :QMediaObject(parent, new MockPlaylistService)

   136     {

   137     }

   138 };

   139 

   140 

   141 class tst_QMediaPlaylist : public QObject

   142 {

   143     Q_OBJECT

   144 public slots:

   145     void init();

   146     void cleanup();

   147     void initTestCase();

   148 

   149 private slots:

   150     void construction();

   151     void append();

   152     void insert();

   153     void clear();

   154     void removeMedia();

   155     void currentItem();

   156     void saveAndLoad();

   157     void playbackMode();

   158     void playbackMode_data();

   159     void shuffle();

   160     void readOnlyPlaylist();

   161     void setMediaObject();

   162 

   163 private:

   164     QMediaContent content1;

   165     QMediaContent content2;

   166     QMediaContent content3;

   167 };

   168 

   169 void tst_QMediaPlaylist::init()

   170 {

   171 }

   172 

   173 void tst_QMediaPlaylist::initTestCase()

   174 {

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

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

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

   178 

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

   180 }

   181 

   182 void tst_QMediaPlaylist::cleanup()

   183 {

   184 }

   185 

   186 void tst_QMediaPlaylist::construction()

   187 {

   188     QMediaPlaylist playlist;

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

   190     QVERIFY(playlist.isEmpty());

   191 }

   192 

   193 void tst_QMediaPlaylist::append()

   194 {

   195     QMediaPlaylist playlist;

   196     QVERIFY(!playlist.isReadOnly());

   197 

   198     playlist.addMedia(content1);

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

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

   201 

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

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

   204     playlist.addMedia(content2);

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

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

   207 

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

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

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

   211 

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

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

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

   215 

   216     aboutToBeInsertedSignalSpy.clear();

   217     insertedSignalSpy.clear();

   218 

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

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

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

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

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

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

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

   226 

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

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

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

   230 

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

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

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

   234 

   235     aboutToBeInsertedSignalSpy.clear();

   236     insertedSignalSpy.clear();

   237 

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

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

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

   241 }

   242 

   243 void tst_QMediaPlaylist::insert()

   244 {

   245     QMediaPlaylist playlist;

   246     QVERIFY(!playlist.isReadOnly());

   247 

   248     playlist.addMedia(content1);

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

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

   251 

   252     playlist.addMedia(content2);

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

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

   255 

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

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

   258 

   259     playlist.insertMedia(1, content3);

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

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

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

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

   264 

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

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

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

   268 

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

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

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

   272 

   273     aboutToBeInsertedSignalSpy.clear();

   274     insertedSignalSpy.clear();

   275 

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

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

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

   279 

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

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

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

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

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

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

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

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

   288 

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

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

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

   292 

   293     aboutToBeInsertedSignalSpy.clear();

   294     insertedSignalSpy.clear();

   295 

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

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

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

   299 }

   300 

   301 

   302 void tst_QMediaPlaylist::currentItem()

   303 {

   304     QMediaPlaylist playlist;

   305     playlist.addMedia(content1);

   306     playlist.addMedia(content2);

   307 

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

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

   310 

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

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

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

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

   315 

   316     playlist.setCurrentIndex(0);

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

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

   319 

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

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

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

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

   324 

   325     playlist.setCurrentIndex(1);

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

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

   328 

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

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

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

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

   333 

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

   335     playlist.setCurrentIndex(2);

   336 

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

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

   339 }

   340 

   341 void tst_QMediaPlaylist::clear()

   342 {

   343     QMediaPlaylist playlist;

   344     playlist.addMedia(content1);

   345     playlist.addMedia(content2);

   346 

   347     playlist.clear();

   348     QVERIFY(playlist.isEmpty());

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

   350 }

   351 

   352 void tst_QMediaPlaylist::removeMedia()

   353 {

   354     QMediaPlaylist playlist;

   355     playlist.addMedia(content1);

   356     playlist.addMedia(content2);

   357     playlist.addMedia(content3);

   358 

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

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

   361     playlist.removeMedia(1);

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

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

   364 

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

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

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

   368 

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

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

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

   372 

   373     aboutToBeRemovedSignalSpy.clear();

   374     removedSignalSpy.clear();

   375 

   376     playlist.removeMedia(0,1);

   377     QVERIFY(playlist.isEmpty());

   378 

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

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

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

   382 

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

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

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

   386 

   387 

   388     playlist.addMedia(content1);

   389     playlist.addMedia(content2);

   390     playlist.addMedia(content3);

   391 

   392     playlist.removeMedia(0,1);

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

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

   395 }

   396 

   397 void tst_QMediaPlaylist::saveAndLoad()

   398 {

   399     QMediaPlaylist playlist;

   400     playlist.addMedia(content1);

   401     playlist.addMedia(content2);

   402     playlist.addMedia(content3);

   403 

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

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

   406 

   407     QBuffer buffer;

   408     buffer.open(QBuffer::ReadWrite);

   409 

   410     QTest::ignoreMessage(QtWarningMsg, "Load static plugins for \"/playlistformats/\" ");

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

   412     QVERIFY(!res);

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

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

   415 

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

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

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

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

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

   421 

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

   423     QVERIFY(!res);

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

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

   426 

   427     errorSignal.clear();

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

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

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

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

   432 

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

   434 

   435     QVERIFY(res);

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

   437     buffer.seek(0);

   438 

   439     QMediaPlaylist playlist2;

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

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

   442 

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

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

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

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

   447 

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

   449     QVERIFY(res);

   450 

   451     playlist2.clear();

   452     QVERIFY(playlist2.isEmpty());

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

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

   455 

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

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

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

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

   460 }

   461 

   462 void tst_QMediaPlaylist::playbackMode_data()

   463 {

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

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

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

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

   468 

   469     QTest::newRow("Linear, 0") << QMediaPlaylist::Linear << -1 << 0 << 1;

   470     QTest::newRow("Linear, 1") << QMediaPlaylist::Linear << 0 << 1 << 2;

   471     QTest::newRow("Linear, 2") << QMediaPlaylist::Linear << 1 << 2 << -1;

   472 

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

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

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

   476 

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

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

   479 

   480 }

   481 

   482 void tst_QMediaPlaylist::playbackMode()

   483 {

   484     QFETCH(QMediaPlaylist::PlaybackMode, playbackMode);

   485     QFETCH(int, expectedPrevious);

   486     QFETCH(int, pos);

   487     QFETCH(int, expectedNext);

   488 

   489     QMediaPlaylist playlist;

   490     playlist.addMedia(content1);

   491     playlist.addMedia(content2);

   492     playlist.addMedia(content3);

   493 

   494     QCOMPARE(playlist.playbackMode(), QMediaPlaylist::Linear);

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

   496 

   497     playlist.setPlaybackMode(playbackMode);

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

   499 

   500     playlist.setCurrentIndex(pos);

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

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

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

   504 

   505     playlist.next();

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

   507 

   508     playlist.setCurrentIndex(pos);

   509     playlist.previous();

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

   511 }

   512 

   513 void tst_QMediaPlaylist::shuffle()

   514 {

   515     QMediaPlaylist playlist;

   516     QList<QMediaContent> contentList;

   517 

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

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

   520         contentList.append(content);

   521         playlist.addMedia(content);

   522     }

   523 

   524     playlist.shuffle();

   525 

   526     QList<QMediaContent> shuffledContentList;

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

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

   529 

   530     QVERIFY(contentList != shuffledContentList);

   531 

   532 }

   533 

   534 void tst_QMediaPlaylist::readOnlyPlaylist()

   535 {

   536     MockReadOnlyPlaylistObject mediaObject;

   537     QMediaPlaylist playlist;

   538     playlist.setMediaObject(&mediaObject);

   539 

   540     QVERIFY(playlist.isReadOnly());

   541     QVERIFY(!playlist.isEmpty());

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

   543 

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

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

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

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

   548 

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

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

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

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

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

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

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

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

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

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

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

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

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

   562     QVERIFY(!playlist.clear());

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

   564 

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

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

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

   568 

   569     playlist.shuffle();

   570     //it's still the same

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

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

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

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

   575 

   576 

   577     //load to read only playlist should fail,

   578     //unless underlaying provider supports it

   579     QBuffer buffer;

   580     buffer.open(QBuffer::ReadWrite);

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

   582     buffer.seek(0);

   583 

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

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

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

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

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

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

   590 

   591     errorSignal.clear();

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

   593 

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

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

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

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

   598 }

   599 

   600 void tst_QMediaPlaylist::setMediaObject()

   601 {

   602     MockReadOnlyPlaylistObject mediaObject;

   603 

   604     QMediaPlaylist playlist;

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

   606     QVERIFY(!playlist.isReadOnly());

   607 

   608     playlist.setMediaObject(&mediaObject);

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

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

   611     QVERIFY(playlist.isReadOnly());

   612 

   613     playlist.setMediaObject(0);

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

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

   616     QVERIFY(!playlist.isReadOnly());

   617 

   618     playlist.setMediaObject(&mediaObject);

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

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

   621     QVERIFY(playlist.isReadOnly());

   622 }

   623 

   624 QTEST_MAIN(tst_QMediaPlaylist)

   625 #include "tst_qmediaplaylist.moc"

   626