Merge lp:~phablet-team/qtubuntu-media/fix-1449790 into lp:qtubuntu-media

[Jim Hodapp]

URI encode the URI that we call setMedia() on or add to the playlist

URI encode the URI that we call setMedia() on or add to the playlist

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:103
http://jenkins.qa.ubuntu.com/job/qtubuntu-media-ci/138/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-amd64-ci/63
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-armhf-ci/63
        deb: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-armhf-ci/63/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-i386-ci/63

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtubuntu-media-ci/138/rebuild

review: Approve (continuous-integration)

[lp:~phablet-team/qtubuntu-media/fix-1449790]

104. By Jim Hodapp on 2016-02-15

Make sure to URI encode the track paths that get added via playlists

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:104
http://jenkins.qa.ubuntu.com/job/qtubuntu-media-ci/139/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-amd64-ci/64
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-armhf-ci/64
        deb: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-armhf-ci/64/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-i386-ci/64

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtubuntu-media-ci/139/rebuild

review: Approve (continuous-integration)

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

My main concern with this change is whether we handle properly UTF-8 or not. The toLocal8Bit() suggests we might be breaking support for non-ascii file names (although I am not sure if we supported that before).

I think it is a good opportunity to add tests for UTF-8 (this MP adds infrastructure for that, like generate_test_files.sh, which is great) and make sure those files get played as expected.

Finally, I have an inline comment.

review: Needs Fixing

[lp:~phablet-team/qtubuntu-media/fix-1449790]

105. By Jim Hodapp on 2016-02-19

Simply pass the URL string through to media-hub, no longer need to do any special handling since media-hub takes care of it all

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:105
http://jenkins.qa.ubuntu.com/job/qtubuntu-media-ci/140/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-amd64-ci/65/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-armhf-ci/65/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-i386-ci/65/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtubuntu-media-ci/140/rebuild

review: Needs Fixing (continuous-integration)

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

Looks good, but you have forgotten to remove encode_uri() (it is not used anymore).

review: Needs Fixing

[lp:~phablet-team/qtubuntu-media/fix-1449790]

106. By Jim Hodapp on 2016-02-22

Added another integration test that checks special character handling for setMedia()

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:106
http://jenkins.qa.ubuntu.com/job/qtubuntu-media-ci/141/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-amd64-ci/66/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-armhf-ci/66/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtubuntu-media-vivid-i386-ci/66/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtubuntu-media-ci/141/rebuild

review: Needs Fixing (continuous-integration)

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

LGTM

review: Approve

[lp:~phablet-team/qtubuntu-media/fix-1449790]

107. By Jim Hodapp on 2016-02-22

Added README note for how to manually run the integrations tests

=== modified file 'README'
--- README	2015-09-09 15:13:10 +0000
+++ README	2016-02-22 16:57:32 +0000
@@ -1,3 +1,10 @@
+Integrations Tests:
+-------------------
+* Currently, the integration tests are disabled by default. To utilize them, you first need to
+  uncomment the last line in tests/tests.pro (starts with "system"). Then from the build/ dir,
+  run qmake -r .. followed by make. After it's done building, cd to each integration test's dir
+  within build/ and manually run each test's binary.
+
 Coding Convention:
 ------------------
 
 
=== modified file 'src/aal/aalmediaplayerservice.cpp'
--- src/aal/aalmediaplayerservice.cpp	2016-01-14 19:56:59 +0000
+++ src/aal/aalmediaplayerservice.cpp	2016-02-22 16:57:32 +0000
@@ -312,14 +312,19 @@
     if (m_mediaPlaylistProvider && url.isEmpty())
         m_mediaPlaylistProvider->clear();
 
-    const media::Track::UriType uri(url.url().toStdString());
     if (m_mediaPlaylistProvider == nullptr || m_mediaPlaylistProvider->mediaCount() == 0)
     {
         try {
-            m_hubPlayerSession->open_uri(uri);
+            m_hubPlayerSession->open_uri(url.toString().toStdString());
         }
         catch (const media::Player::Errors::InsufficientAppArmorPermissions &e) {
             qWarning() << e.what();
+            signalQMediaPlayerError(media::Player::Error::resource_error);
+            return;
+        }
+        catch (const media::Player::Errors::UriNotFound &e) {
+            qWarning() << e.what();
+            signalQMediaPlayerError(media::Player::Error::resource_error);
             return;
         }
         catch (const std::runtime_error &e) {
@@ -631,10 +636,12 @@
         case media::Player::Error::resource_error:
             outError = QMediaPlayer::ResourceError;
             outErrorStr = "A media resource couldn't be resolved.";
+            m_mediaPlayerControl->setMediaStatus(QMediaPlayer::InvalidMedia);
             break;
         case media::Player::Error::format_error:
             outError = QMediaPlayer::FormatError;
             outErrorStr = "The media format type is not playable due to a missing codec.";
+            m_mediaPlayerControl->setMediaStatus(QMediaPlayer::InvalidMedia);
             break;
         case media::Player::Error::network_error:
             outError = QMediaPlayer::NetworkError;
@@ -643,6 +650,7 @@
         case media::Player::Error::access_denied_error:
             outError = QMediaPlayer::AccessDeniedError;
             outErrorStr = "Insufficient privileges to play that media.";
+            m_mediaPlayerControl->setMediaStatus(QMediaPlayer::InvalidMedia);
             break;
         case media::Player::Error::service_missing_error:
             outError = QMediaPlayer::ServiceMissingError;
 
=== modified file 'src/aal/aalmediaplaylistprovider.cpp'
--- src/aal/aalmediaplaylistprovider.cpp	2016-01-05 16:58:37 +0000
+++ src/aal/aalmediaplaylistprovider.cpp	2016-02-22 16:57:32 +0000
@@ -108,8 +108,8 @@
     }
 
     const QUrl url = content.canonicalUrl();
-    std::string urlStr = AalUtility::unescape_str(content);
-    if (url.scheme().isEmpty() and url.scheme() != "file")
+    std::string urlStr = url.toString().toStdString();
+    if (url.scheme().isEmpty())
         urlStr = "file://" + urlStr;
 
     static const bool make_current = false;
@@ -123,11 +123,19 @@
     }
     catch (const media::TrackList::Errors::InsufficientPermissionsToAddTrack &e)
     {
-        qWarning() << "Failed to add track '" << content.canonicalUrl().toString() << "' to playlist: " << e.what();
+        qWarning() << "Failed to add track '" << content.canonicalUrl().toString()
+                   << "' to playlist:" << e.what();
+        return false;
+    }
+    catch (const media::Player::Errors::UriNotFound &e)
+    {
+        qWarning() << "Failed to add track '" << content.canonicalUrl().toString()
+                   << "' to playlist:" << e.what();
         return false;
     }
     catch (const std::runtime_error &e) {
-        qWarning() << "Failed to add track '" << content.canonicalUrl().toString() << "' to playlist: " << e.what();
+        qWarning() << "Failed to add track '" << content.canonicalUrl().toString()
+                   << "' to playlist: " << e.what();
         return false;
     }
 
@@ -149,9 +157,9 @@
     media::TrackList::ContainerURI uris;
     for (const auto mediaContent : contentList) {
 #ifdef VERBOSE_DEBUG
-        qDebug() << "Adding track " << AalUtility::unescape(mediaContent).toString();
+        qDebug() << "Adding track " << mediaContent.canonicalUrl().toString().toStdString();
 #endif
-        uris.push_back(AalUtility::unescape_str(mediaContent));
+        uris.push_back(mediaContent.canonicalUrl().toString().toStdString());
     }
 
     const media::Track::Id after_empty_track = media::TrackList::after_empty_track();
@@ -165,6 +173,11 @@
         qWarning() << "Failed to add" << contentList.size() << "tracks to playlist: " << e.what();
         return false;
     }
+    catch (const media::Player::Errors::UriNotFound &e)
+    {
+        qWarning() << "Failed to add certain tracks to playlist: " << e.what();
+        return false;
+    }
     catch (const std::runtime_error &e) {
         qWarning() << "Failed to add" << contentList.size() << "tracks to playlist: " << e.what();
         return false;
@@ -186,7 +199,7 @@
     }
 
     const QUrl url = content.canonicalUrl();
-    std::string urlStr = AalUtility::unescape_str(content);
+    std::string urlStr = url.toString().toStdString();
     if (url.scheme().isEmpty() and url.scheme() != "file")
         urlStr = "file://" + urlStr;
 
@@ -212,11 +225,13 @@
     }
     catch (const media::TrackList::Errors::InsufficientPermissionsToAddTrack &e)
     {
-        qWarning() << "Failed to add track '" << content.canonicalUrl().toString() << "' to playlist: " << e.what();
+        qWarning() << "Failed to add track '" << content.canonicalUrl().toString()
+                   << "' to playlist: " << e.what();
         return false;
     }
     catch (const std::runtime_error &e) {
-        qWarning() << "Failed to add track '" << content.canonicalUrl().toString() << "' to playlist: " << e.what();
+        qWarning() << "Failed to add track '" << content.canonicalUrl().toString()
+                   << "' to playlist: " << e.what();
         return false;
     }
 
 
=== modified file 'tests/integration/integration.pro'
--- tests/integration/integration.pro	2015-11-03 15:58:40 +0000
+++ tests/integration/integration.pro	2016-02-22 16:57:32 +0000
@@ -1,23 +1,6 @@
-include(../../coverage.pri)
-
-CONFIG += testcase
-QMAKE_CXXFLAGS += -std=c++11
-DEFINES += QT_NO_KEYWORDS
-TARGET = tst_integration
-
-QT += core multimedia testlib
-
-QT_TESTCASE_BUILDDIR = .
-
-INCLUDEPATH += ../../src/aal \
-    /usr/include/qt5/QtMultimedia \
-
-HEADERS += \
-    tst_mediaplaylist.h
-
-SOURCES += \
-    tst_mediaplaylist.cpp \
-    ../../src/aal/aalutility.cpp
-
-# media-hub is required to be running for these tests
-#system(/sbin/stop media-hub; /sbin/start media-hub)
+include(coverage.pri)
+
+TEMPLATE = subdirs
+
+SUBDIRS += uris
+SUBDIRS += playlists
 
=== added directory 'tests/integration/playlists'
=== added file 'tests/integration/playlists/playlists.pro'
--- tests/integration/playlists/playlists.pro	1970-01-01 00:00:00 +0000
+++ tests/integration/playlists/playlists.pro	2016-02-22 16:57:32 +0000
@@ -0,0 +1,25 @@
+include(../../coverage.pri)
+
+CONFIG += testcase
+QMAKE_CXXFLAGS += -std=c++11
+DEFINES += QT_NO_KEYWORDS
+TARGET = tst_playlists
+
+QT += core multimedia testlib
+
+QT_TESTCASE_BUILDDIR = .
+
+INCLUDEPATH += ../../src/aal \
+    /usr/include/qt5/QtMultimedia \
+
+HEADERS += \
+    tst_mediaplaylist.h
+
+SOURCES += \
+    tst_mediaplaylist.cpp \
+    ../../../src/aal/aalutility.cpp
+
+SUBDIRS += uris
+
+# media-hub is required to be running for these tests
+#system(/sbin/stop media-hub; /sbin/start media-hub)
 
=== added directory 'tests/integration/playlists/testdata'
=== added file 'tests/integration/playlists/testdata/Ubuntu.ogg'
 Binary files tests/integration/playlists/testdata/Ubuntu.ogg	1970-01-01 00:00:00 +0000 and tests/integration/playlists/testdata/Ubuntu.ogg	2016-02-22 16:57:32 +0000 differ
=== added file 'tests/integration/playlists/testdata/testfile.mp4'
 Binary files tests/integration/playlists/testdata/testfile.mp4	1970-01-01 00:00:00 +0000 and tests/integration/playlists/testdata/testfile.mp4	2016-02-22 16:57:32 +0000 differ
=== added file 'tests/integration/playlists/testdata/testfile.ogg'
 Binary files tests/integration/playlists/testdata/testfile.ogg	1970-01-01 00:00:00 +0000 and tests/integration/playlists/testdata/testfile.ogg	2016-02-22 16:57:32 +0000 differ
=== added file 'tests/integration/playlists/testdata/testfile1.ogg'
 Binary files tests/integration/playlists/testdata/testfile1.ogg	1970-01-01 00:00:00 +0000 and tests/integration/playlists/testdata/testfile1.ogg	2016-02-22 16:57:32 +0000 differ
=== added file 'tests/integration/playlists/testdata/testfile2.ogg'
 Binary files tests/integration/playlists/testdata/testfile2.ogg	1970-01-01 00:00:00 +0000 and tests/integration/playlists/testdata/testfile2.ogg	2016-02-22 16:57:32 +0000 differ
=== added file 'tests/integration/playlists/testdata/testfile3.ogg'
 Binary files tests/integration/playlists/testdata/testfile3.ogg	1970-01-01 00:00:00 +0000 and tests/integration/playlists/testdata/testfile3.ogg	2016-02-22 16:57:32 +0000 differ
=== added file 'tests/integration/playlists/testdata/testfile4.ogg'
 Binary files tests/integration/playlists/testdata/testfile4.ogg	1970-01-01 00:00:00 +0000 and tests/integration/playlists/testdata/testfile4.ogg	2016-02-22 16:57:32 +0000 differ
=== added file 'tests/integration/playlists/tst_mediaplaylist.cpp'
--- tests/integration/playlists/tst_mediaplaylist.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration/playlists/tst_mediaplaylist.cpp	2016-02-22 16:57:32 +0000
@@ -0,0 +1,896 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tst_mediaplaylist.h"
+#include "../../../src/aal/aalutility.h"
+
+#include <thread>
+#include <unistd.h>
+
+#include <QMediaPlayer>
+#include <QMediaPlaylist>
+
+#include <QtTest/QtTest>
+
+void tst_MediaPlaylist::initTestCase()
+{
+}
+
+void tst_MediaPlaylist::cleanupTestCase()
+{
+}
+
+void tst_MediaPlaylist::init()
+{
+    // NOTE: This sleep is currently needed in order to give media-hub a bit of time
+    // between our different tests to cleanup and come back in a state where it can
+    // respond to our requests.
+    sleep(1);
+}
+
+void tst_MediaPlaylist::constructDestroyRepeat()
+{
+    for (int i=0; i<25; i++)
+    {
+        QMediaPlayer *player = new QMediaPlayer;
+        QMediaPlaylist *playlist = new QMediaPlaylist;
+        player->setPlaylist(playlist);
+
+        delete playlist;
+        delete player;
+    }
+}
+
+void tst_MediaPlaylist::addTwoTracksAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
+    playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
+
+    QCOMPARE(playlist->mediaCount(), 2);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::insertTracksAtPositionAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QElapsedTimer timer;
+    timer.start();
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    waitTrackInserted(playlist);
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    waitTrackInserted(playlist);
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
+    waitTrackInserted(playlist);
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
+    waitTrackInserted(playlist);
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
+    waitTrackInserted(playlist);
+    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
+
+    QCOMPARE(playlist->mediaCount(), 5);
+
+    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile4.ogg")));
+    playlist->insertMedia(2, insertedTrack);
+    waitTrackInserted(playlist);
+
+    qDebug() << "playlist->media(2):" << playlist->media(2).canonicalUrl();
+    qDebug() << "insertedTrack:" << insertedTrack.canonicalUrl();
+    QCOMPARE(playlist->media(2), insertedTrack);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::moveTrackAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QElapsedTimer timer;
+    timer.start();
+    QList<QMediaContent> content;
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
+    const QMediaContent newLastTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
+    content.push_back(newLastTrack);
+    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    content.push_back(insertedTrack);
+    playlist->addMedia(content);
+    waitTrackInserted(playlist);
+    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
+
+    QCOMPARE(playlist->mediaCount(), 6);
+
+    connectSignal(playlist, Signals::MediaRemoved);
+    connectSignal(playlist, Signals::MediaInserted);
+    playlist->moveMedia(5, 2);
+
+    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaRemoved);
+    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
+    QCOMPARE(playlist->mediaCount(), 6);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::movePlayingTrackAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QElapsedTimer timer;
+    timer.start();
+    QList<QMediaContent> content;
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
+    const QMediaContent newLastTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
+    content.push_back(newLastTrack);
+    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/Ubuntu.ogg")));
+    content.push_back(insertedTrack);
+    playlist->addMedia(content);
+    waitTrackInserted(playlist);
+    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
+
+    playlist->setCurrentIndex(5);
+    waitCurrentIndexChange(playlist);
+    QCOMPARE(playlist->currentIndex(), 5);
+
+    player->play();
+
+    QCOMPARE(playlist->mediaCount(), 6);
+
+    sleep(2);
+
+    connectSignal(playlist, Signals::MediaRemoved);
+    connectSignal(playlist, Signals::MediaInserted);
+    playlist->moveMedia(5, 2);
+
+    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaRemoved);
+    qDebug() << "Verifying the presence of MediaInserted signal in deque";
+    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
+    QCOMPARE(playlist->mediaCount(), 6);
+
+    waitCurrentIndexChange(playlist);
+
+    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
+    QCOMPARE(playlist->currentIndex(), 2);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::addListOfTracksAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QList<QMediaContent> content;
+    content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
+
+    playlist->addMedia(content);
+
+    QCOMPARE(playlist->mediaCount(), 2);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::addLargeListOfTracksAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    // Total number of tracks added will be iterations * 5
+    const uint16_t iterations = 20;
+    QElapsedTimer timer;
+    timer.start();
+    for (uint16_t i=0; i<iterations; i++)
+    {
+        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
+        waitTrackInserted(playlist);
+        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
+        waitTrackInserted(playlist);
+        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
+        waitTrackInserted(playlist);
+        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
+        waitTrackInserted(playlist);
+        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
+        waitTrackInserted(playlist);
+    }
+    qDebug() << "** addMedia loop took" << timer.elapsed() << "milliseconds";
+
+    QCOMPARE(playlist->mediaCount(), iterations * 5);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::addLargeListOfTracksAtOnceAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QList<QMediaContent> content;
+    int i;
+    for (i=0; i<20; i++)
+    {
+        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
+        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
+        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
+        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
+        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
+        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
+        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
+        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
+        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
+        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
+    }
+
+    QElapsedTimer timer;
+    timer.start();
+    playlist->addMedia(content);
+    qDebug() << "** addMedia(QList) took" << timer.elapsed() << "milliseconds";
+
+    waitTrackInserted(playlist);
+    QCOMPARE(playlist->mediaCount(), i * 10);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::addTwoListsOfTracksAtOnceAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QList<QMediaContent> content1;
+    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
+    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
+    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
+    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
+    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
+    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
+    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
+    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
+    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
+    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
+
+    QList<QMediaContent> content2;
+    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
+    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
+    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
+    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
+    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
+    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
+    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
+    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
+    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
+    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
+
+    QElapsedTimer timer;
+    timer.start();
+    playlist->addMedia(content1);
+    qDebug() << "** First list addMedia(QList) took" << timer.elapsed() << "milliseconds";
+
+    waitTrackInserted(playlist);
+    QCOMPARE(playlist->mediaCount(), 10);
+
+    timer.invalidate();
+    timer.start();
+    playlist->addMedia(content2);
+    qDebug() << "** Second list addMedia(QList) took" << timer.elapsed() << "milliseconds";
+
+    waitTrackInserted(playlist);
+    QCOMPARE(playlist->mediaCount(), 20);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::goToNextTrack()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    const QUrl audio(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    qDebug() << "audio URL: " << audio.toString();
+    qDebug() << "video URL: " << video.toString();
+    playlist->addMedia(audio);
+    playlist->addMedia(video);
+
+    QCOMPARE(playlist->mediaCount(), 2);
+
+    player->play();
+
+    QCoreApplication::processEvents();
+
+    const QUrl audioToVerify(playlist->currentMedia().canonicalUrl());
+    QCOMPARE(audioToVerify, audio);
+
+    playlist->next();
+
+    QCoreApplication::processEvents();
+
+    const QUrl videoToVerify(playlist->currentMedia().canonicalUrl());
+    QCOMPARE(videoToVerify, video);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::goToPreviousTrack()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    const QUrl audio1(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    const QUrl audio2(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    playlist->addMedia(audio1);
+    playlist->addMedia(audio2);
+
+    QCOMPARE(playlist->mediaCount(), 2);
+    playlist->setCurrentIndex(1);
+
+    player->play();
+
+    QCoreApplication::processEvents();
+
+    const QUrl audio2ToVerify(playlist->currentMedia().canonicalUrl());
+    QCOMPARE(audio2ToVerify, audio2);
+
+    playlist->previous();
+
+    QCoreApplication::processEvents();
+
+    const QUrl audio1ToVerify(playlist->currentMedia().canonicalUrl());
+    QCOMPARE(audio2ToVerify, audio1);
+    QCOMPARE(playlist->currentIndex(), 0);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::verifyMedia()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    const QUrl audio(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    qDebug() << "audio URL: " << audio.toString();
+    qDebug() << "video URL: " << video.toString();
+    playlist->addMedia(audio);
+    playlist->addMedia(video);
+
+    QCOMPARE(playlist->mediaCount(), 2);
+
+    const QUrl audioToVerify(playlist->media(0).canonicalUrl());
+    QCOMPARE(audioToVerify, audio);
+
+    const QUrl videoToVerify(playlist->media(1).canonicalUrl());
+    QCOMPARE(videoToVerify, video);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::removeTrackAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    playlist->addMedia(video);
+
+    waitTrackInserted(playlist);
+    QCOMPARE(playlist->mediaCount(), 2);
+
+    playlist->removeMedia(0);
+
+    QCOMPARE(playlist->mediaCount(), 1);
+
+    const QUrl videoToVerify(playlist->media(0).canonicalUrl());
+    QCOMPARE(videoToVerify, video);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::removeCurrentNonPlayingTrackAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QList<QMediaContent> content1;
+    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
+    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
+    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
+    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile4.ogg")));
+    playlist->addMedia(content1);
+    const QUrl track(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    playlist->addMedia(track);
+
+    waitTrackInserted(playlist);
+    QCOMPARE(playlist->mediaCount(), 6);
+
+    playlist->setCurrentIndex(2);
+    // Wait for the currentMediaChanged signal to be emited
+    waitTrackChange(playlist);
+    // We should not be automatically playing
+    QCOMPARE(player->state(), QMediaPlayer::State::StoppedState);
+    QCOMPARE(playlist->currentIndex(), 2);
+
+    playlist->removeMedia(2);
+
+    // We should still not be playing
+    QCOMPARE(player->state(), QMediaPlayer::State::StoppedState);
+
+    QCOMPARE(playlist->mediaCount(), 5);
+
+    const QUrl trackToVerify(playlist->media(4).canonicalUrl());
+    QCOMPARE(trackToVerify, track);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::removeCurrentPlayingTrackAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QList<QMediaContent> content1;
+    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
+    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
+    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
+    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile4.ogg")));
+    playlist->addMedia(content1);
+    const QUrl track(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    playlist->addMedia(track);
+
+    waitTrackInserted(playlist);
+    QCOMPARE(playlist->mediaCount(), 6);
+
+    player->play();
+
+    playlist->setCurrentIndex(2);
+    // Wait for the currentMediaChanged signal to be emited
+    waitTrackChange(playlist);
+    // We be  playing
+    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
+    QCOMPARE(playlist->currentIndex(), 2);
+
+    playlist->removeMedia(2);
+
+    // We should still be playing
+    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
+
+    QCOMPARE(playlist->mediaCount(), 5);
+
+    const QUrl trackToVerify(playlist->media(4).canonicalUrl());
+    QCOMPARE(trackToVerify, track);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::removeLastCurrentPlayingTrackAndVerify()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    const QUrl track(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    playlist->addMedia(track);
+
+    waitTrackInserted(playlist);
+    QCOMPARE(playlist->mediaCount(), 1);
+
+    player->play();
+
+    playlist->setCurrentIndex(0);
+    qDebug() << "Waiting for playback status to change to playing";
+    // Wait for the currentMediaChanged signal to be emited
+    waitTrackChange(playlist);
+    // We be  playing
+    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
+
+    qDebug() << "Removing track index 0";
+    playlist->removeMedia(0);
+
+    waitTrackRemoved(playlist);
+    // We should no longer be playing
+    QCOMPARE(player->state(), QMediaPlayer::State::StoppedState);
+
+    QCOMPARE(playlist->mediaCount(), 0);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::verifyCurrentIndex()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QList<QMediaContent> content;
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    playlist->addMedia(content);
+
+    waitTrackInserted(playlist);
+    QCOMPARE(playlist->mediaCount(), 3);
+
+    qDebug() << "Setting current index to be 1";
+    playlist->setCurrentIndex(1);
+
+    // Wait for the currentMediaChanged signal to be emited
+    waitTrackChange(playlist);
+
+    qDebug() << "Checking if current index is 1";
+    QCOMPARE(playlist->currentIndex(), 1);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::verifyNextIndex()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QList<QMediaContent> content;
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    playlist->addMedia(content);
+
+    waitTrackInserted(playlist);
+    QCOMPARE(playlist->mediaCount(), 6);
+
+    QCOMPARE(playlist->nextIndex(1), 1);
+    QCOMPARE(playlist->nextIndex(4), 4);
+    QCOMPARE(playlist->nextIndex(6), 0);
+    QCOMPARE(playlist->nextIndex(7), 1);
+    QCOMPARE(playlist->nextIndex(11), 5);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::verifyPreviousIndex()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    QList<QMediaContent> content;
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+    playlist->addMedia(content);
+
+    waitTrackInserted(playlist);
+    QCOMPARE(playlist->mediaCount(), 6);
+
+    QCOMPARE(playlist->previousIndex(1), 5);
+    QCOMPARE(playlist->previousIndex(4), 2);
+    QCOMPARE(playlist->previousIndex(6), 0);
+    QCOMPARE(playlist->previousIndex(11), 1);
+    QCOMPARE(playlist->previousIndex(21), 3);
+    QCOMPARE(playlist->previousIndex(19), 5);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::verifyPlaybackModeCurrentItemInLoop()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    connectSignal(playlist, Signals::MediaInserted);
+
+    QList<QMediaContent> content;
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    playlist->addMedia(content);
+
+    // Wait until the first track is set as the current one
+    waitTrackChange(playlist);
+    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
+    QCOMPARE(playlist->mediaCount(), 2);
+
+    waitPlaybackModeChange(playlist, [playlist]()
+        {
+            playlist->setPlaybackMode(QMediaPlaylist::CurrentItemInLoop);
+        });
+
+    player->play();
+
+    // Wait for the currentMediaChanged signal to be emited
+    waitTrackChange(playlist);
+
+    QCOMPARE(playlist->currentIndex(), 0);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::verifyPlaybackModeSequential()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    connectSignal(playlist, Signals::MediaInserted);
+
+    QList<QMediaContent> content;
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    playlist->addMedia(content);
+
+    // Wait until the first track is set as the current one
+    waitTrackChange(playlist);
+    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
+    QCOMPARE(playlist->mediaCount(), 2);
+
+    waitPlaybackModeChange(playlist, [playlist]()
+        {
+            playlist->setPlaybackMode(QMediaPlaylist::Sequential);
+        });
+
+    player->play();
+
+    // Wait until the second track is selected
+    waitTrackChange(playlist);
+
+    QCOMPARE(playlist->currentIndex(), 1);
+
+    delete playlist;
+    delete player;
+}
+
+void tst_MediaPlaylist::playReusePlayTrackList()
+{
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    const QUrl audio(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
+    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
+
+    for (int i = 0; i < 5; ++i) {
+        playlist->addMedia(audio);
+        waitTrackInserted(playlist);
+        playlist->addMedia(video);
+        waitTrackInserted(playlist);
+        playlist->addMedia(audio);
+        waitTrackInserted(playlist);
+        QCOMPARE(playlist->mediaCount(), 3);
+
+        player->play();
+
+        const QUrl audioToVerify(playlist->currentMedia().canonicalUrl());
+        QCOMPARE(audioToVerify, audio);
+
+        player->stop();
+
+        connectSignal(playlist, Signals::MediaRemoved);
+        playlist->clear();
+
+        Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaRemoved);
+
+        QCOMPARE(playlist->mediaCount(), 0);
+    }
+
+    delete playlist;
+    delete player;
+}
+
+template<typename R>
+void tst_MediaPlaylist::wait_for_signal(std::future<R> const& f)
+{
+    while (!is_ready<R>(f))
+    {
+        // Make sure we don't block the main QEventLoop, which
+        // would hinder receiving the currentMediaChanged event above
+        QCoreApplication::processEvents();
+        std::this_thread::yield();
+    }
+}
+
+void tst_MediaPlaylist::waitTrackChange(QMediaPlaylist *playlist)
+{
+    QMediaContent current_media;
+    std::promise<QMediaContent> promise;
+    std::future<QMediaContent> future{promise.get_future()};
+
+    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::currentMediaChanged,
+        [&](const QMediaContent& content)
+        {
+            qDebug() << "currentMediaChanged to: " << content.canonicalUrl().toString();
+            current_media = content;
+            promise.set_value(current_media);
+            // Make sure the promise is not fulfilled twice
+            QObject::disconnect(c);
+        });
+
+    wait_for_signal(future);
+}
+
+void tst_MediaPlaylist::waitTrackInserted(QMediaPlaylist *playlist)
+{
+    int index = 0;
+    std::promise<int> promise;
+    std::future<int> future{promise.get_future()};
+
+    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::mediaInserted,
+        [&](int start, int end)
+        {
+            qDebug() << "mediaInserted start: " << start << ", end: " << end;
+            index = end;
+            promise.set_value(index);
+            // Make sure the promise is not fulfilled twice
+            QObject::disconnect(c);
+        });
+
+    wait_for_signal(future);
+}
+
+void tst_MediaPlaylist::waitTrackRemoved(QMediaPlaylist *playlist)
+{
+    int index = 0;
+    std::promise<int> promise;
+    std::future<int> future{promise.get_future()};
+
+    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::mediaRemoved,
+        [&](int start, int end)
+        {
+            qDebug() << "mediaRemoved start: " << start << ", end: " << end;
+            index = end;
+            promise.set_value(index);
+            // Make sure the promise is not fulfilled twice
+            QObject::disconnect(c);
+        });
+
+    wait_for_signal(future);
+}
+
+void tst_MediaPlaylist::waitPlaybackModeChange(QMediaPlaylist *playlist,
+                                               const std::function<void()>& action)
+{
+    QMediaPlaylist::PlaybackMode current_mode;
+    std::promise<QMediaPlaylist::PlaybackMode> promise;
+    std::future<QMediaPlaylist::PlaybackMode> future{promise.get_future()};
+
+    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::playbackModeChanged,
+        [&](QMediaPlaylist::PlaybackMode mode)
+        {
+            qDebug() << "playbackModeChanged to: " << mode;
+            current_mode = mode;
+            promise.set_value(current_mode);
+            // Make sure the promise is not fulfilled twice
+            QObject::disconnect(c);
+        });
+
+    action();
+
+    wait_for_signal(future);
+}
+
+void tst_MediaPlaylist::waitCurrentIndexChange(QMediaPlaylist *playlist)
+{
+    int index = 0;
+    std::promise<int> promise;
+    std::future<int> future{promise.get_future()};
+
+    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::currentIndexChanged,
+        [&](int i)
+        {
+            qDebug() << "currentIndexChanged index: " << i;
+            index = i;
+            promise.set_value(index);
+            // Make sure the promise is not fulfilled twice
+            QObject::disconnect(c);
+        });
+
+    wait_for_signal(future);
+}
+
+void tst_MediaPlaylist::connectSignal(QMediaPlaylist *playlist, Signals signal)
+{
+    switch (signal)
+    {
+        case Signals::Unknown:
+            break;
+        case Signals::CurrentMediaChanged:
+        {
+            connect(playlist, &QMediaPlaylist::currentMediaChanged, [&](const QMediaContent& content)
+            {
+                (void) content;
+                qDebug() << "Pushing CurrentMediaChanged onto m_signalsDeque";
+                m_signalsDeque.push_back(signal);
+            });
+            break;
+        }
+        case Signals::MediaInserted:
+        {
+            connect(playlist, &QMediaPlaylist::mediaInserted, [&](int start, int end)
+            {
+                (void) start;
+                (void) end;
+                qDebug() << "Pushing MediaInserted onto m_signalsDeque";
+                m_signalsDeque.push_back(signal);
+            });
+            break;
+        }
+        case Signals::MediaRemoved:
+        {
+            connect(playlist, &QMediaPlaylist::mediaRemoved, [&](int index)
+            {
+                (void) index;
+                qDebug() << "Pushing MediaRemoved onto m_signalsDeque";
+                m_signalsDeque.push_back(signal);
+            });
+            break;
+        }
+        default:
+            qWarning() << "Unknown signal type, can't add to queue:" << signal;
+    }
+}
+
+QTEST_GUILESS_MAIN(tst_MediaPlaylist)
 
=== added file 'tests/integration/playlists/tst_mediaplaylist.h'
--- tests/integration/playlists/tst_mediaplaylist.h	1970-01-01 00:00:00 +0000
+++ tests/integration/playlists/tst_mediaplaylist.h	2016-02-22 16:57:32 +0000
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TST_MEDIAPLAYLIST_H
+#define TST_MEDIAPLAYLIST_H
+
+#include <core/media/player.h>
+
+#include <deque>
+#include <future>
+#include <memory>
+
+#include <QMediaPlayer>
+#include <QMediaPlaylist>
+#include <QObject>
+
+class AalMediaPlaylistControl;
+class QMediaPlayer;
+
+class tst_MediaPlaylist : public QObject
+{
+    Q_OBJECT
+
+    AalMediaPlaylistControl *m_mediaPlaylistControl;
+
+public:
+    enum Signals {
+        Unknown,
+        CurrentMediaChanged,
+        MediaInserted,
+        MediaRemoved
+    };
+
+Q_SIGNALS:
+
+private Q_SLOTS:
+    // We want the setup to be run prior to every test case to
+    // ensure correct test isolation, see http://qt-project.org/doc/qt-5/qtest-overview.html.
+    void initTestCase();
+    void cleanupTestCase();
+
+    void init();
+
+    void constructDestroyRepeat();
+
+    void addTwoTracksAndVerify();
+    void insertTracksAtPositionAndVerify();
+    void moveTrackAndVerify();
+    void movePlayingTrackAndVerify();
+    void addListOfTracksAndVerify();
+    void addLargeListOfTracksAndVerify();
+    void addLargeListOfTracksAtOnceAndVerify();
+    void addTwoListsOfTracksAtOnceAndVerify();
+
+    void goToNextTrack();
+    void goToPreviousTrack();
+    void verifyMedia();
+
+    void removeTrackAndVerify();
+    void removeCurrentNonPlayingTrackAndVerify();
+    void removeCurrentPlayingTrackAndVerify();
+    void removeLastCurrentPlayingTrackAndVerify();
+
+    void verifyCurrentIndex();
+    void verifyNextIndex();
+    void verifyPreviousIndex();
+
+    void verifyPlaybackModeCurrentItemInLoop();
+    void verifyPlaybackModeSequential();
+
+    void playReusePlayTrackList();
+
+private:
+    std::deque<Signals> m_signalsDeque;
+
+    template<typename R>
+        bool is_ready(std::future<R> const& f)
+        { return f.wait_for(std::chrono::seconds(0)) == std::future_status::ready; }
+
+    template<typename R>
+        void wait_for_signal(std::future<R> const& f);
+
+    void waitTrackChange(QMediaPlaylist *playlist);
+    void waitTrackInserted(QMediaPlaylist *playlist);
+    void waitTrackRemoved(QMediaPlaylist *playlist);
+    void waitPlaybackModeChange(QMediaPlaylist *playlist,
+                                const std::function<void()>& action);
+    void waitCurrentIndexChange(QMediaPlaylist *playlist);
+
+    // A generic way of getting a signal registered into m_signalsDeque without blocking
+    // which can be used to later check the order of signals that were emitted. Simply call
+    // this method for each signal that you'd like to check and it'll be pushed onto the deque
+    // when it's fired.
+    void connectSignal(QMediaPlaylist *playlist, Signals signal);
+};
+
+#endif // TST_MEDIAPLAYLIST_H
 
=== removed directory 'tests/integration/testdata'
=== removed file 'tests/integration/testdata/Ubuntu.ogg'
 Binary files tests/integration/testdata/Ubuntu.ogg	2015-11-03 18:00:37 +0000 and tests/integration/testdata/Ubuntu.ogg	1970-01-01 00:00:00 +0000 differ
=== removed file 'tests/integration/testdata/testfile.mp4'
 Binary files tests/integration/testdata/testfile.mp4	2015-07-07 20:31:08 +0000 and tests/integration/testdata/testfile.mp4	1970-01-01 00:00:00 +0000 differ
=== removed file 'tests/integration/testdata/testfile.ogg'
 Binary files tests/integration/testdata/testfile.ogg	2015-07-07 20:31:08 +0000 and tests/integration/testdata/testfile.ogg	1970-01-01 00:00:00 +0000 differ
=== removed file 'tests/integration/testdata/testfile1.ogg'
 Binary files tests/integration/testdata/testfile1.ogg	2015-10-09 20:06:40 +0000 and tests/integration/testdata/testfile1.ogg	1970-01-01 00:00:00 +0000 differ
=== removed file 'tests/integration/testdata/testfile2.ogg'
 Binary files tests/integration/testdata/testfile2.ogg	2015-10-09 20:06:40 +0000 and tests/integration/testdata/testfile2.ogg	1970-01-01 00:00:00 +0000 differ
=== removed file 'tests/integration/testdata/testfile3.ogg'
 Binary files tests/integration/testdata/testfile3.ogg	2015-10-09 20:06:40 +0000 and tests/integration/testdata/testfile3.ogg	1970-01-01 00:00:00 +0000 differ
=== removed file 'tests/integration/testdata/testfile4.ogg'
 Binary files tests/integration/testdata/testfile4.ogg	2015-10-09 20:06:40 +0000 and tests/integration/testdata/testfile4.ogg	1970-01-01 00:00:00 +0000 differ
=== removed file 'tests/integration/tst_mediaplaylist.cpp'
--- tests/integration/tst_mediaplaylist.cpp	2015-11-17 22:25:36 +0000
+++ tests/integration/tst_mediaplaylist.cpp	1970-01-01 00:00:00 +0000
@@ -1,896 +0,0 @@
-/*
- * Copyright (C) 2015 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "tst_mediaplaylist.h"
-#include "aalutility.h"
-
-#include <thread>
-#include <unistd.h>
-
-#include <QMediaPlayer>
-#include <QMediaPlaylist>
-
-#include <QtTest/QtTest>
-
-void tst_MediaPlaylist::initTestCase()
-{
-}
-
-void tst_MediaPlaylist::cleanupTestCase()
-{
-}
-
-void tst_MediaPlaylist::init()
-{
-    // NOTE: This sleep is currently needed in order to give media-hub a bit of time
-    // between our different tests to cleanup and come back in a state where it can
-    // respond to our requests.
-    sleep(1);
-}
-
-void tst_MediaPlaylist::constructDestroyRepeat()
-{
-    for (int i=0; i<25; i++)
-    {
-        QMediaPlayer *player = new QMediaPlayer;
-        QMediaPlaylist *playlist = new QMediaPlaylist;
-        player->setPlaylist(playlist);
-
-        delete playlist;
-        delete player;
-    }
-}
-
-void tst_MediaPlaylist::addTwoTracksAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
-    playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
-
-    QCOMPARE(playlist->mediaCount(), 2);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::insertTracksAtPositionAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QElapsedTimer timer;
-    timer.start();
-    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    waitTrackInserted(playlist);
-    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    waitTrackInserted(playlist);
-    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
-    waitTrackInserted(playlist);
-    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
-    waitTrackInserted(playlist);
-    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
-    waitTrackInserted(playlist);
-    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
-
-    QCOMPARE(playlist->mediaCount(), 5);
-
-    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile4.ogg")));
-    playlist->insertMedia(2, insertedTrack);
-    waitTrackInserted(playlist);
-
-    qDebug() << "playlist->media(2):" << playlist->media(2).canonicalUrl();
-    qDebug() << "insertedTrack:" << insertedTrack.canonicalUrl();
-    QCOMPARE(playlist->media(2), insertedTrack);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::moveTrackAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QElapsedTimer timer;
-    timer.start();
-    QList<QMediaContent> content;
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
-    const QMediaContent newLastTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
-    content.push_back(newLastTrack);
-    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    content.push_back(insertedTrack);
-    playlist->addMedia(content);
-    waitTrackInserted(playlist);
-    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
-
-    QCOMPARE(playlist->mediaCount(), 6);
-
-    connectSignal(playlist, Signals::MediaRemoved);
-    connectSignal(playlist, Signals::MediaInserted);
-    playlist->moveMedia(5, 2);
-
-    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaRemoved);
-    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
-    QCOMPARE(playlist->mediaCount(), 6);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::movePlayingTrackAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QElapsedTimer timer;
-    timer.start();
-    QList<QMediaContent> content;
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
-    const QMediaContent newLastTrack(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
-    content.push_back(newLastTrack);
-    const QMediaContent insertedTrack(QUrl("file://" + QFINDTESTDATA("testdata/Ubuntu.ogg")));
-    content.push_back(insertedTrack);
-    playlist->addMedia(content);
-    waitTrackInserted(playlist);
-    qDebug() << "** addMedia took" << timer.elapsed() << "milliseconds";
-
-    playlist->setCurrentIndex(5);
-    waitCurrentIndexChange(playlist);
-    QCOMPARE(playlist->currentIndex(), 5);
-
-    player->play();
-
-    QCOMPARE(playlist->mediaCount(), 6);
-
-    sleep(2);
-
-    connectSignal(playlist, Signals::MediaRemoved);
-    connectSignal(playlist, Signals::MediaInserted);
-    playlist->moveMedia(5, 2);
-
-    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaRemoved);
-    qDebug() << "Verifying the presence of MediaInserted signal in deque";
-    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
-    QCOMPARE(playlist->mediaCount(), 6);
-
-    waitCurrentIndexChange(playlist);
-
-    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
-    QCOMPARE(playlist->currentIndex(), 2);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::addListOfTracksAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QList<QMediaContent> content;
-    content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
-
-    playlist->addMedia(content);
-
-    QCOMPARE(playlist->mediaCount(), 2);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::addLargeListOfTracksAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    // Total number of tracks added will be iterations * 5
-    const uint16_t iterations = 20;
-    QElapsedTimer timer;
-    timer.start();
-    for (uint16_t i=0; i<iterations; i++)
-    {
-        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
-        waitTrackInserted(playlist);
-        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
-        waitTrackInserted(playlist);
-        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
-        waitTrackInserted(playlist);
-        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
-        waitTrackInserted(playlist);
-        playlist->addMedia(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
-        waitTrackInserted(playlist);
-    }
-    qDebug() << "** addMedia loop took" << timer.elapsed() << "milliseconds";
-
-    QCOMPARE(playlist->mediaCount(), iterations * 5);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::addLargeListOfTracksAtOnceAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QList<QMediaContent> content;
-    int i;
-    for (i=0; i<20; i++)
-    {
-        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
-        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
-        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
-        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
-        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
-        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
-        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
-        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
-        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
-        content.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
-    }
-
-    QElapsedTimer timer;
-    timer.start();
-    playlist->addMedia(content);
-    qDebug() << "** addMedia(QList) took" << timer.elapsed() << "milliseconds";
-
-    waitTrackInserted(playlist);
-    QCOMPARE(playlist->mediaCount(), i * 10);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::addTwoListsOfTracksAtOnceAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QList<QMediaContent> content1;
-    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
-    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
-    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
-    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
-    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
-    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
-    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
-    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
-    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
-    content1.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
-
-    QList<QMediaContent> content2;
-    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
-    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
-    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
-    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
-    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile.mp4")));
-    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile.ogg")));
-    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile1.ogg")));
-    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile2.ogg")));
-    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile3.ogg")));
-    content2.push_back(QUrl(QFINDTESTDATA("testdata/testfile4.ogg")));
-
-    QElapsedTimer timer;
-    timer.start();
-    playlist->addMedia(content1);
-    qDebug() << "** First list addMedia(QList) took" << timer.elapsed() << "milliseconds";
-
-    waitTrackInserted(playlist);
-    QCOMPARE(playlist->mediaCount(), 10);
-
-    timer.invalidate();
-    timer.start();
-    playlist->addMedia(content2);
-    qDebug() << "** Second list addMedia(QList) took" << timer.elapsed() << "milliseconds";
-
-    waitTrackInserted(playlist);
-    QCOMPARE(playlist->mediaCount(), 20);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::goToNextTrack()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    const QUrl audio(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    qDebug() << "audio URL: " << audio.toString();
-    qDebug() << "video URL: " << video.toString();
-    playlist->addMedia(audio);
-    playlist->addMedia(video);
-
-    QCOMPARE(playlist->mediaCount(), 2);
-
-    player->play();
-
-    QCoreApplication::processEvents();
-
-    const QUrl audioToVerify(playlist->currentMedia().canonicalUrl());
-    QCOMPARE(audioToVerify, audio);
-
-    playlist->next();
-
-    QCoreApplication::processEvents();
-
-    const QUrl videoToVerify(playlist->currentMedia().canonicalUrl());
-    QCOMPARE(videoToVerify, video);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::goToPreviousTrack()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    const QUrl audio1(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    const QUrl audio2(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    playlist->addMedia(audio1);
-    playlist->addMedia(audio2);
-
-    QCOMPARE(playlist->mediaCount(), 2);
-    playlist->setCurrentIndex(1);
-
-    player->play();
-
-    QCoreApplication::processEvents();
-
-    const QUrl audio2ToVerify(playlist->currentMedia().canonicalUrl());
-    QCOMPARE(audio2ToVerify, audio2);
-
-    playlist->previous();
-
-    QCoreApplication::processEvents();
-
-    const QUrl audio1ToVerify(playlist->currentMedia().canonicalUrl());
-    QCOMPARE(audio2ToVerify, audio1);
-    QCOMPARE(playlist->currentIndex(), 0);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::verifyMedia()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    const QUrl audio(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    qDebug() << "audio URL: " << audio.toString();
-    qDebug() << "video URL: " << video.toString();
-    playlist->addMedia(audio);
-    playlist->addMedia(video);
-
-    QCOMPARE(playlist->mediaCount(), 2);
-
-    const QUrl audioToVerify(playlist->media(0).canonicalUrl());
-    QCOMPARE(audioToVerify, audio);
-
-    const QUrl videoToVerify(playlist->media(1).canonicalUrl());
-    QCOMPARE(videoToVerify, video);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::removeTrackAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    playlist->addMedia(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    playlist->addMedia(video);
-
-    waitTrackInserted(playlist);
-    QCOMPARE(playlist->mediaCount(), 2);
-
-    playlist->removeMedia(0);
-
-    QCOMPARE(playlist->mediaCount(), 1);
-
-    const QUrl videoToVerify(playlist->media(0).canonicalUrl());
-    QCOMPARE(videoToVerify, video);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::removeCurrentNonPlayingTrackAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QList<QMediaContent> content1;
-    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
-    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
-    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
-    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile4.ogg")));
-    playlist->addMedia(content1);
-    const QUrl track(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    playlist->addMedia(track);
-
-    waitTrackInserted(playlist);
-    QCOMPARE(playlist->mediaCount(), 6);
-
-    playlist->setCurrentIndex(2);
-    // Wait for the currentMediaChanged signal to be emited
-    waitTrackChange(playlist);
-    // We should not be automatically playing
-    QCOMPARE(player->state(), QMediaPlayer::State::StoppedState);
-    QCOMPARE(playlist->currentIndex(), 2);
-
-    playlist->removeMedia(2);
-
-    // We should still not be playing
-    QCOMPARE(player->state(), QMediaPlayer::State::StoppedState);
-
-    QCOMPARE(playlist->mediaCount(), 5);
-
-    const QUrl trackToVerify(playlist->media(4).canonicalUrl());
-    QCOMPARE(trackToVerify, track);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::removeCurrentPlayingTrackAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QList<QMediaContent> content1;
-    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile1.ogg")));
-    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile2.ogg")));
-    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile3.ogg")));
-    content1.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile4.ogg")));
-    playlist->addMedia(content1);
-    const QUrl track(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    playlist->addMedia(track);
-
-    waitTrackInserted(playlist);
-    QCOMPARE(playlist->mediaCount(), 6);
-
-    player->play();
-
-    playlist->setCurrentIndex(2);
-    // Wait for the currentMediaChanged signal to be emited
-    waitTrackChange(playlist);
-    // We be  playing
-    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
-    QCOMPARE(playlist->currentIndex(), 2);
-
-    playlist->removeMedia(2);
-
-    // We should still be playing
-    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
-
-    QCOMPARE(playlist->mediaCount(), 5);
-
-    const QUrl trackToVerify(playlist->media(4).canonicalUrl());
-    QCOMPARE(trackToVerify, track);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::removeLastCurrentPlayingTrackAndVerify()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    const QUrl track(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    playlist->addMedia(track);
-
-    waitTrackInserted(playlist);
-    QCOMPARE(playlist->mediaCount(), 1);
-
-    player->play();
-
-    playlist->setCurrentIndex(0);
-    qDebug() << "Waiting for playback status to change to playing";
-    // Wait for the currentMediaChanged signal to be emited
-    waitTrackChange(playlist);
-    // We be  playing
-    QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
-
-    qDebug() << "Removing track index 0";
-    playlist->removeMedia(0);
-
-    waitTrackRemoved(playlist);
-    // We should no longer be playing
-    QCOMPARE(player->state(), QMediaPlayer::State::StoppedState);
-
-    QCOMPARE(playlist->mediaCount(), 0);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::verifyCurrentIndex()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QList<QMediaContent> content;
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    playlist->addMedia(content);
-
-    waitTrackInserted(playlist);
-    QCOMPARE(playlist->mediaCount(), 3);
-
-    qDebug() << "Setting current index to be 1";
-    playlist->setCurrentIndex(1);
-
-    // Wait for the currentMediaChanged signal to be emited
-    waitTrackChange(playlist);
-
-    qDebug() << "Checking if current index is 1";
-    QCOMPARE(playlist->currentIndex(), 1);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::verifyNextIndex()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QList<QMediaContent> content;
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    playlist->addMedia(content);
-
-    waitTrackInserted(playlist);
-    QCOMPARE(playlist->mediaCount(), 6);
-
-    QCOMPARE(playlist->nextIndex(1), 1);
-    QCOMPARE(playlist->nextIndex(4), 4);
-    QCOMPARE(playlist->nextIndex(6), 0);
-    QCOMPARE(playlist->nextIndex(7), 1);
-    QCOMPARE(playlist->nextIndex(11), 5);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::verifyPreviousIndex()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    QList<QMediaContent> content;
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-    playlist->addMedia(content);
-
-    waitTrackInserted(playlist);
-    QCOMPARE(playlist->mediaCount(), 6);
-
-    QCOMPARE(playlist->previousIndex(1), 5);
-    QCOMPARE(playlist->previousIndex(4), 2);
-    QCOMPARE(playlist->previousIndex(6), 0);
-    QCOMPARE(playlist->previousIndex(11), 1);
-    QCOMPARE(playlist->previousIndex(21), 3);
-    QCOMPARE(playlist->previousIndex(19), 5);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::verifyPlaybackModeCurrentItemInLoop()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    connectSignal(playlist, Signals::MediaInserted);
-
-    QList<QMediaContent> content;
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    playlist->addMedia(content);
-
-    // Wait until the first track is set as the current one
-    waitTrackChange(playlist);
-    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
-    QCOMPARE(playlist->mediaCount(), 2);
-
-    waitPlaybackModeChange(playlist, [playlist]()
-        {
-            playlist->setPlaybackMode(QMediaPlaylist::CurrentItemInLoop);
-        });
-
-    player->play();
-
-    // Wait for the currentMediaChanged signal to be emited
-    waitTrackChange(playlist);
-
-    QCOMPARE(playlist->currentIndex(), 0);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::verifyPlaybackModeSequential()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    connectSignal(playlist, Signals::MediaInserted);
-
-    QList<QMediaContent> content;
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    content.push_back(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    playlist->addMedia(content);
-
-    // Wait until the first track is set as the current one
-    waitTrackChange(playlist);
-    Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaInserted);
-    QCOMPARE(playlist->mediaCount(), 2);
-
-    waitPlaybackModeChange(playlist, [playlist]()
-        {
-            playlist->setPlaybackMode(QMediaPlaylist::Sequential);
-        });
-
-    player->play();
-
-    // Wait until the second track is selected
-    waitTrackChange(playlist);
-
-    QCOMPARE(playlist->currentIndex(), 1);
-
-    delete playlist;
-    delete player;
-}
-
-void tst_MediaPlaylist::playReusePlayTrackList()
-{
-    QMediaPlayer *player = new QMediaPlayer;
-    QMediaPlaylist *playlist = new QMediaPlaylist;
-    player->setPlaylist(playlist);
-
-    const QUrl audio(QUrl("file://" + QFINDTESTDATA("testdata/testfile.ogg")));
-    const QUrl video(QUrl("file://" + QFINDTESTDATA("testdata/testfile.mp4")));
-
-    for (int i = 0; i < 5; ++i) {
-        playlist->addMedia(audio);
-        waitTrackInserted(playlist);
-        playlist->addMedia(video);
-        waitTrackInserted(playlist);
-        playlist->addMedia(audio);
-        waitTrackInserted(playlist);
-        QCOMPARE(playlist->mediaCount(), 3);
-
-        player->play();
-
-        const QUrl audioToVerify(playlist->currentMedia().canonicalUrl());
-        QCOMPARE(audioToVerify, audio);
-
-        player->stop();
-
-        connectSignal(playlist, Signals::MediaRemoved);
-        playlist->clear();
-
-        Q_ASSERT(m_signalsDeque.pop_front() == Signals::MediaRemoved);
-
-        QCOMPARE(playlist->mediaCount(), 0);
-    }
-
-    delete playlist;
-    delete player;
-}
-
-template<typename R>
-void tst_MediaPlaylist::wait_for_signal(std::future<R> const& f)
-{
-    while (!is_ready<R>(f))
-    {
-        // Make sure we don't block the main QEventLoop, which
-        // would hinder receiving the currentMediaChanged event above
-        QCoreApplication::processEvents();
-        std::this_thread::yield();
-    }
-}
-
-void tst_MediaPlaylist::waitTrackChange(QMediaPlaylist *playlist)
-{
-    QMediaContent current_media;
-    std::promise<QMediaContent> promise;
-    std::future<QMediaContent> future{promise.get_future()};
-
-    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::currentMediaChanged,
-        [&](const QMediaContent& content)
-        {
-            qDebug() << "currentMediaChanged to: " << content.canonicalUrl().toString();
-            current_media = content;
-            promise.set_value(current_media);
-            // Make sure the promise is not fulfilled twice
-            QObject::disconnect(c);
-        });
-
-    wait_for_signal(future);
-}
-
-void tst_MediaPlaylist::waitTrackInserted(QMediaPlaylist *playlist)
-{
-    int index = 0;
-    std::promise<int> promise;
-    std::future<int> future{promise.get_future()};
-
-    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::mediaInserted,
-        [&](int start, int end)
-        {
-            qDebug() << "mediaInserted start: " << start << ", end: " << end;
-            index = end;
-            promise.set_value(index);
-            // Make sure the promise is not fulfilled twice
-            QObject::disconnect(c);
-        });
-
-    wait_for_signal(future);
-}
-
-void tst_MediaPlaylist::waitTrackRemoved(QMediaPlaylist *playlist)
-{
-    int index = 0;
-    std::promise<int> promise;
-    std::future<int> future{promise.get_future()};
-
-    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::mediaRemoved,
-        [&](int start, int end)
-        {
-            qDebug() << "mediaRemoved start: " << start << ", end: " << end;
-            index = end;
-            promise.set_value(index);
-            // Make sure the promise is not fulfilled twice
-            QObject::disconnect(c);
-        });
-
-    wait_for_signal(future);
-}
-
-void tst_MediaPlaylist::waitPlaybackModeChange(QMediaPlaylist *playlist,
-                                               const std::function<void()>& action)
-{
-    QMediaPlaylist::PlaybackMode current_mode;
-    std::promise<QMediaPlaylist::PlaybackMode> promise;
-    std::future<QMediaPlaylist::PlaybackMode> future{promise.get_future()};
-
-    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::playbackModeChanged,
-        [&](QMediaPlaylist::PlaybackMode mode)
-        {
-            qDebug() << "playbackModeChanged to: " << mode;
-            current_mode = mode;
-            promise.set_value(current_mode);
-            // Make sure the promise is not fulfilled twice
-            QObject::disconnect(c);
-        });
-
-    action();
-
-    wait_for_signal(future);
-}
-
-void tst_MediaPlaylist::waitCurrentIndexChange(QMediaPlaylist *playlist)
-{
-    int index = 0;
-    std::promise<int> promise;
-    std::future<int> future{promise.get_future()};
-
-    QMetaObject::Connection c = connect(playlist, &QMediaPlaylist::currentIndexChanged,
-        [&](int i)
-        {
-            qDebug() << "currentIndexChanged index: " << i;
-            index = i;
-            promise.set_value(index);
-            // Make sure the promise is not fulfilled twice
-            QObject::disconnect(c);
-        });
-
-    wait_for_signal(future);
-}
-
-void tst_MediaPlaylist::connectSignal(QMediaPlaylist *playlist, Signals signal)
-{
-    switch (signal)
-    {
-        case Signals::Unknown:
-            break;
-        case Signals::CurrentMediaChanged:
-        {
-            connect(playlist, &QMediaPlaylist::currentMediaChanged, [&](const QMediaContent& content)
-            {
-                (void) content;
-                qDebug() << "Pushing CurrentMediaChanged onto m_signalsDeque";
-                m_signalsDeque.push_back(signal);
-            });
-            break;
-        }
-        case Signals::MediaInserted:
-        {
-            connect(playlist, &QMediaPlaylist::mediaInserted, [&](int start, int end)
-            {
-                (void) start;
-                (void) end;
-                qDebug() << "Pushing MediaInserted onto m_signalsDeque";
-                m_signalsDeque.push_back(signal);
-            });
-            break;
-        }
-        case Signals::MediaRemoved:
-        {
-            connect(playlist, &QMediaPlaylist::mediaRemoved, [&](int index)
-            {
-                (void) index;
-                qDebug() << "Pushing MediaRemoved onto m_signalsDeque";
-                m_signalsDeque.push_back(signal);
-            });
-            break;
-        }
-        default:
-            qWarning() << "Unknown signal type, can't add to queue:" << signal;
-    }
-}
-
-QTEST_GUILESS_MAIN(tst_MediaPlaylist)
 
=== removed file 'tests/integration/tst_mediaplaylist.h'
--- tests/integration/tst_mediaplaylist.h	2015-11-17 22:25:36 +0000
+++ tests/integration/tst_mediaplaylist.h	1970-01-01 00:00:00 +0000
@@ -1,110 +0,0 @@
-/*
- * Copyright (C) 2015 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TST_MEDIAPLAYLIST_H
-#define TST_MEDIAPLAYLIST_H
-
-#include <core/media/player.h>
-
-#include <deque>
-#include <future>
-#include <memory>
-
-#include <QMediaPlayer>
-#include <QMediaPlaylist>
-#include <QObject>
-
-class AalMediaPlaylistControl;
-class QMediaPlayer;
-
-class tst_MediaPlaylist : public QObject
-{
-    Q_OBJECT
-
-    AalMediaPlaylistControl *m_mediaPlaylistControl;
-
-public:
-    enum Signals {
-        Unknown,
-        CurrentMediaChanged,
-        MediaInserted,
-        MediaRemoved
-    };
-
-Q_SIGNALS:
-
-private Q_SLOTS:
-    // We want the setup to be run prior to every test case to
-    // ensure correct test isolation, see http://qt-project.org/doc/qt-5/qtest-overview.html.
-    void initTestCase();
-    void cleanupTestCase();
-
-    void init();
-
-    void constructDestroyRepeat();
-
-    void addTwoTracksAndVerify();
-    void insertTracksAtPositionAndVerify();
-    void moveTrackAndVerify();
-    void movePlayingTrackAndVerify();
-    void addListOfTracksAndVerify();
-    void addLargeListOfTracksAndVerify();
-    void addLargeListOfTracksAtOnceAndVerify();
-    void addTwoListsOfTracksAtOnceAndVerify();
-
-    void goToNextTrack();
-    void goToPreviousTrack();
-    void verifyMedia();
-
-    void removeTrackAndVerify();
-    void removeCurrentNonPlayingTrackAndVerify();
-    void removeCurrentPlayingTrackAndVerify();
-    void removeLastCurrentPlayingTrackAndVerify();
-
-    void verifyCurrentIndex();
-    void verifyNextIndex();
-    void verifyPreviousIndex();
-
-    void verifyPlaybackModeCurrentItemInLoop();
-    void verifyPlaybackModeSequential();
-
-    void playReusePlayTrackList();
-
-private:
-    std::deque<Signals> m_signalsDeque;
-
-    template<typename R>
-        bool is_ready(std::future<R> const& f)
-        { return f.wait_for(std::chrono::seconds(0)) == std::future_status::ready; }
-
-    template<typename R>
-        void wait_for_signal(std::future<R> const& f);
-
-    void waitTrackChange(QMediaPlaylist *playlist);
-    void waitTrackInserted(QMediaPlaylist *playlist);
-    void waitTrackRemoved(QMediaPlaylist *playlist);
-    void waitPlaybackModeChange(QMediaPlaylist *playlist,
-                                const std::function<void()>& action);
-    void waitCurrentIndexChange(QMediaPlaylist *playlist);
-
-    // A generic way of getting a signal registered into m_signalsDeque without blocking
-    // which can be used to later check the order of signals that were emitted. Simply call
-    // this method for each signal that you'd like to check and it'll be pushed onto the deque
-    // when it's fired.
-    void connectSignal(QMediaPlaylist *playlist, Signals signal);
-};
-
-#endif // TST_MEDIAPLAYLIST_H
 
=== added directory 'tests/integration/uris'
=== added file 'tests/integration/uris/generate_test_files.sh'
--- tests/integration/uris/generate_test_files.sh	1970-01-01 00:00:00 +0000
+++ tests/integration/uris/generate_test_files.sh	2016-02-22 16:57:32 +0000
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+WORKING_DIR=/tmp/qtubuntu-media
+BASE_FILE=$1/testdata/Ubuntu.ogg
+
+mkdir $WORKING_DIR
+
+echo "WORKING_DIR: $WORKING_DIR"
+echo "BASE_FILE: $BASE_FILE"
+
+# Creates several files with a single character filename that starts
+# at ASCII char #32 and ends with #126
+for i in {32..127}  # from 'Space' to '~'
+do
+    # skip '"', '%', '<', '>', '.', 'DEL'
+    if [ $i -eq 127 ]
+    then
+        continue
+    else
+        chr=$(printf \\$(printf '%03o' $i))
+
+        echo "Creating file $chr.ogg from $BASE_FILE" > "$WORKING_DIR/log.txt"
+        cp $BASE_FILE "$WORKING_DIR/track$chr.ogg"
+    fi
+done
 
=== added file 'tests/integration/uris/remove_test_files.sh'
--- tests/integration/uris/remove_test_files.sh	1970-01-01 00:00:00 +0000
+++ tests/integration/uris/remove_test_files.sh	2016-02-22 16:57:32 +0000
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+WORKING_DIR=/tmp/qtubuntu-media
+
+if [ -d "$WORKING_DIR" ]; then
+    rm -r $WORKING_DIR
+fi
 
=== added directory 'tests/integration/uris/testdata'
=== added file 'tests/integration/uris/testdata/Ubuntu.ogg'
 Binary files tests/integration/uris/testdata/Ubuntu.ogg	1970-01-01 00:00:00 +0000 and tests/integration/uris/testdata/Ubuntu.ogg	2016-02-22 16:57:32 +0000 differ
=== added file 'tests/integration/uris/tst_mediauris.cpp'
--- tests/integration/uris/tst_mediauris.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration/uris/tst_mediauris.cpp	2016-02-22 16:57:32 +0000
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "tst_mediauris.h"
+
+#include <unistd.h>
+
+#include <QMediaPlayer>
+#include <QMediaPlaylist>
+#include <QProcess>
+
+#include <QtTest/QtTest>
+
+void tst_MediaUris::initTestCase()
+{
+    QProcess p;
+    qDebug() << "Current working dir:" << QDir::currentPath();
+    p.start("../../../../tests/integration/uris/generate_test_files.sh",
+            QStringList() << QString{QDir::currentPath() + "/../../../../tests/integration/uris"});
+    p.waitForFinished();
+    QVERIFY(p.exitStatus() == QProcess::NormalExit);
+    QVERIFY(p.exitCode() == 0);
+}
+
+void tst_MediaUris::cleanupTestCase()
+{
+    QProcess p;
+    p.start("../../../../tests/integration/uris/remove_test_files.sh");
+    p.waitForFinished();
+    QVERIFY(p.exitStatus() == QProcess::NormalExit);
+    QVERIFY(p.exitCode() == 0);
+}
+
+void tst_MediaUris::init()
+{
+    // NOTE: This sleep is currently needed in order to give media-hub a bit of time
+    // between our different tests to cleanup and come back in a state where it can
+    // respond to our requests.
+    sleep(1);
+}
+
+void tst_MediaUris::verifySpecialAsciiCharsCanPlaySetMedia()
+{
+    QDir generatedFilesDir("/tmp/qtubuntu-media");
+    QStringList mediaFiles = generatedFilesDir.entryList(QDir::NoDotAndDotDot | QDir::System
+           | QDir::Hidden | QDir::AllDirs | QDir::Files, QDir::DirsFirst);
+
+    qDebug() << "mediaFiles.size():" << mediaFiles.size();
+
+    QMediaPlayer *player = new QMediaPlayer;
+
+    for (const QString &file : mediaFiles)
+    {
+        const QString fullFileUri {"file://" + generatedFilesDir.absolutePath() + "/" + file};
+        const QMediaContent content {QUrl{fullFileUri}};
+        qDebug() << "Trying to play file:" << fullFileUri;
+        player->setMedia(content);
+
+        player->play();
+        sleep(1);
+        qDebug() << "player->error():" << player->error();
+        qDebug() << "player->mediaStatus():" << player->mediaStatus();
+        QVERIFY(player->mediaStatus() != QMediaPlayer::InvalidMedia);
+        QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
+        player->stop();
+    }
+
+    delete player;
+}
+
+void tst_MediaUris::verifySpecialAsciiCharsCanPlayPlaylist()
+{
+    QDir generatedFilesDir("/tmp/qtubuntu-media");
+    QStringList mediaFiles = generatedFilesDir.entryList(QDir::NoDotAndDotDot | QDir::System
+           | QDir::Hidden | QDir::AllDirs | QDir::Files, QDir::DirsFirst);
+
+    qDebug() << "mediaFiles.size():" << mediaFiles.size();
+
+    QMediaPlayer *player = new QMediaPlayer;
+    QMediaPlaylist *playlist = new QMediaPlaylist;
+    player->setPlaylist(playlist);
+
+    for (const QString &file : mediaFiles)
+    {
+        QString fullFileUri {"file://" + generatedFilesDir.absolutePath() + "/" + file};
+        qDebug() << "Trying to play file:" << fullFileUri;
+        playlist->addMedia(QUrl(fullFileUri));
+
+        player->play();
+        sleep(1);
+        qDebug() << "player->error():" << player->error();
+        qDebug() << "player->mediaStatus():" << player->mediaStatus();
+        QVERIFY(player->mediaStatus() != QMediaPlayer::InvalidMedia);
+        QCOMPARE(player->state(), QMediaPlayer::State::PlayingState);
+        player->stop();
+        playlist->clear();
+    }
+
+    delete playlist;
+    delete player;
+}
+
+QTEST_GUILESS_MAIN(tst_MediaUris)
 
=== added file 'tests/integration/uris/tst_mediauris.h'
--- tests/integration/uris/tst_mediauris.h	1970-01-01 00:00:00 +0000
+++ tests/integration/uris/tst_mediauris.h	2016-02-22 16:57:32 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TST_MEDIAURIS_H
+#define TST_MEDIAURIS_H
+
+#include <core/media/player.h>
+
+#include <deque>
+#include <future>
+#include <memory>
+
+#include <QMediaPlayer>
+#include <QMediaPlaylist>
+#include <QObject>
+
+class AalMediaPlaylistControl;
+class QMediaPlayer;
+
+class tst_MediaUris : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    // We want the setup to be run prior to every test case to
+    // ensure correct test isolation, see http://qt-project.org/doc/qt-5/qtest-overview.html.
+    void initTestCase();
+    void cleanupTestCase();
+
+    void init();
+
+    void verifySpecialAsciiCharsCanPlaySetMedia();
+    void verifySpecialAsciiCharsCanPlayPlaylist();
+
+private:
+};
+
+#endif // TST_MEDIAURIS_H
 
=== added file 'tests/integration/uris/uris.pro'
--- tests/integration/uris/uris.pro	1970-01-01 00:00:00 +0000
+++ tests/integration/uris/uris.pro	2016-02-22 16:57:32 +0000
@@ -0,0 +1,23 @@
+include(../../coverage.pri)
+
+CONFIG += testcase
+QMAKE_CXXFLAGS += -std=c++11
+DEFINES += QT_NO_KEYWORDS
+TARGET = tst_uris
+
+QT += core multimedia testlib
+
+QT_TESTCASE_BUILDDIR = .
+
+INCLUDEPATH += ../../src/aal \
+    /usr/include/qt5/QtMultimedia \
+
+HEADERS += \
+    tst_mediauris.h
+
+SOURCES += \
+    tst_mediauris.cpp \
+    ../../../src/aal/aalutility.cpp
+
+# media-hub is required to be running for these tests
+#system(/sbin/stop media-hub; /sbin/start media-hub)