/****************************************************************************+
−
**+
−
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).+
−
** All rights reserved.+
−
** Contact: Nokia Corporation (qt-info@nokia.com)+
−
**+
−
** This file is part of the test suite of the Qt Toolkit.+
−
**+
−
** $QT_BEGIN_LICENSE:LGPL$+
−
** No Commercial Usage+
−
** This file contains pre-release code and may not be distributed.+
−
** You may use this file in accordance with the terms and conditions+
−
** contained in the Technology Preview License Agreement accompanying+
−
** this package.+
−
**+
−
** GNU Lesser General Public License Usage+
−
** Alternatively, this file may be used under the terms of the GNU Lesser+
−
** General Public License version 2.1 as published by the Free Software+
−
** Foundation and appearing in the file LICENSE.LGPL included in the+
−
** packaging of this file.  Please review the following information to+
−
** ensure the GNU Lesser General Public License version 2.1 requirements+
−
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.+
−
**+
−
** In addition, as a special exception, Nokia gives you certain additional+
−
** rights.  These rights are described in the Nokia Qt LGPL Exception+
−
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.+
−
**+
−
** If you have questions regarding the use of this file, please contact+
−
** Nokia at qt-info@nokia.com.+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
** $QT_END_LICENSE$+
−
**+
−
****************************************************************************/+
−
/*  This file is part of the KDE project+
−
    Copyright (C) 2006-2007 Matthias Kretz <kretz@kde.org>+
−
+
−
    This program is free software; you can redistribute it and/or+
−
    modify it under the terms of the GNU General Public License as+
−
    published by the Free Software Foundation; either version 2 of+
−
    the License, or (at your option) 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 General Public License+
−
    along with this program.  If not, see <http://www.gnu.org/licenses/>.+
−
+
−
*/+
−
+
−
#include <QtTest/QtTest>+
−
#include <QtCore/QDate>+
−
#include <QtCore/QDebug>+
−
#include <QtCore/QObject>+
−
#include <QtCore/QUrl>+
−
+
−
#ifndef QT_NO_PHONON+
−
#include <phonon/path.h>+
−
#include <phonon/audiooutput.h>+
−
#include <phonon/mediaobject.h>+
−
#include <phonon/phononnamespace.h>+
−
#include <phonon/audiooutput.h>+
−
#include <phonon/seekslider.h>+
−
#include <phonon/mediaobject.h>+
−
#include <phonon/volumeslider.h>+
−
#include <phonon/videowidget.h>+
−
#include <phonon/backendcapabilities.h>+
−
+
−
#include "qtesthelper.h"+
−
#include <cstdlib>+
−
#endif+
−
+
−
#ifndef Q_WS_WIN+
−
#include <unistd.h>+
−
#endif+
−
+
−
#ifdef Q_OS_WINCE+
−
#define MEDIA_FILE "/sax.wav"+
−
#define MEDIA_FILEPATH ":/media/sax.wav"+
−
const qint64 SEEK_BACKWARDS = 2000;+
−
const qint64 ALLOWED_TIME_FOR_SEEKING = 1500; // 1.5s+
−
const qint64 SEEKING_TOLERANCE = 250;+
−
#else +
−
#if defined(Q_OS_WIN) || defined(Q_OS_MAC) || defined(Q_OS_SYMBIAN)+
−
#define MEDIA_FILE "/sax.mp3"+
−
#define MEDIA_FILEPATH ":/media/sax.mp3"+
−
#else+
−
#define MEDIA_FILE "/sax.ogg"+
−
#define MEDIA_FILEPATH ":/media/sax.ogg"+
−
#endif+
−
const qint64 SEEK_BACKWARDS = 4000;+
−
const qint64 ALLOWED_TIME_FOR_SEEKING = 1000; // 1s+
−
const qint64 SEEKING_TOLERANCE = 0;+
−
#endif //Q_OS_WINCE+
−
+
−
class tst_MediaObject : public QObject+
−
{+
−
    Q_OBJECT+
−
    public:+
−
        tst_MediaObject()+
−
            : m_success(false)+
−
    {+
−
        qputenv("PHONON_GST_AUDIOSINK", "fake");+
−
    }+
−
+
−
#ifndef QT_NO_PHONON+
−
+
−
    Q_SIGNALS:+
−
        void continueTestPlayOnFinish();+
−
+
−
    protected Q_SLOTS:+
−
        void enqueueMedia();+
−
        void setMediaAndPlay();+
−
        void stateChanged(Phonon::State, Phonon::State);+
−
    private Q_SLOTS:+
−
        void init();+
−
        void cleanup();+
−
+
−
        void testPlayFromResource();+
−
        void testPlayIllegalFile();+
−
        void initTestCase();+
−
        void checkForDefaults();+
−
+
−
        // state change tests+
−
        void stopToStop();+
−
        void stopToPause();+
−
        void stopToPlay();+
−
        void playToPlay();+
−
        void playToPause();+
−
        void playToStop();+
−
        void pauseToPause();+
−
        void pauseToPlay();+
−
        void pauseToStop();+
−
        void playSDP();+
−
+
−
        void testPrefinishMark();+
−
        void testSeek();+
−
        void testTickSignal();+
−
        void testJustInTimeQueuing();+
−
        void testPlayOnFinish();+
−
        void testPlayBeforeFinish();+
−
        void testPauseOnFinish();+
−
        void testReconnectBetweenTwoMediaObjects();+
−
        void volumeSliderMuteVisibility();+
−
        void cleanupTestCase();+
−
    private:+
−
        void _startPlayback(Phonon::State currentState = Phonon::StoppedState);+
−
        void _stopPlayback(Phonon::State currentState);+
−
        void _pausePlayback();+
−
        void _testOneSeek(qint64 seekTo);+
−
+
−
        QUrl m_url;+
−
        Phonon::MediaObject *m_media;+
−
        QSignalSpy *m_stateChangedSignalSpy;+
−
        QString m_tmpFileName;+
−
+
−
        static void copyMediaFile(const QString &original,+
−
                                  const QString &name,+
−
                                  QString &resultFilePath,+
−
                                  QUrl *const asURL = 0);+
−
#endif //QT_NO_PHONON+
−
        bool m_success;+
−
};+
−
+
−
#ifndef QT_NO_PHONON+
−
+
−
#define startPlayback() _startPlayback(); if (!m_success) return; m_success = false;+
−
#define startPlayback2(currentState) _startPlayback(currentState); if (!m_success) return; m_success = false;+
−
#define stopPlayback(currentState) _stopPlayback(currentState); if (!m_success) return; m_success = false;+
−
#define pausePlayback() _pausePlayback(); if (!m_success) return; m_success = false;+
−
#define testOneSeek(seekTo) _testOneSeek(seekTo); if (!m_success) return; m_success = false;+
−
+
−
const qint64 ALLOWED_SEEK_INACCURACY = 300; // 0.3s+
−
const qint64 ALLOWED_TICK_INACCURACY = 350; // allow +/- 350 ms inaccuracy+
−
+
−
using namespace Phonon;+
−
+
−
static qint64 castQVariantToInt64(const QVariant &variant)+
−
{+
−
    return *reinterpret_cast<const qint64 *>(variant.constData());+
−
}+
−
+
−
static qint32 castQVariantToInt32(const QVariant &variant)+
−
{+
−
    return *reinterpret_cast<const qint32 *>(variant.constData());+
−
}+
−
+
−
static const char *const red    = "\033[0;31m";+
−
static const char *const green  = "\033[0;32m";+
−
static const char *const yellow = "\033[0;33m";+
−
static const char *const blue   = "\033[0;34m";+
−
static const char *const purple = "\033[0;35m";+
−
static const char *const cyan   = "\033[0;36m";+
−
static const char *const white  = "\033[0;37m";+
−
static const char *const normal = "\033[0m";+
−
+
−
void tst_MediaObject::stateChanged(Phonon::State newstate, Phonon::State oldstate)+
−
{+
−
    if (newstate == Phonon::ErrorState) {+
−
        QWARN(QByteArray(QByteArray(red) + ".......................................................... ") + QByteArray(QTest::toString(oldstate)) + " to " + QByteArray(QTest::toString(newstate)) + normal);+
−
    } else {+
−
        //qDebug() << ".........................................................." << cyan << QTest::toString(oldstate) << "to" << QTest::toString(newstate) << normal;+
−
    }+
−
}+
−
+
−
void tst_MediaObject::testPlayFromResource()+
−
{+
−
#ifdef Q_OS_SYMBIAN+
−
    QSKIP("Not implemented yet.", SkipAll);+
−
    return;+
−
#endif+
−
+
−
    QFile file(MEDIA_FILEPATH);+
−
    MediaObject media;+
−
    media.setCurrentSource(&file);+
−
    QVERIFY(media.state() != Phonon::ErrorState);+
−
    if (media.state() != Phonon::StoppedState)+
−
        QTest::waitForSignal(&media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 10000);+
−
    QCOMPARE(media.state(), Phonon::StoppedState);+
−
    media.play();+
−
    if (media.state() != Phonon::PlayingState)+
−
        QTest::waitForSignal(&media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 10000);+
−
    QCOMPARE(media.state(), Phonon::PlayingState);+
−
}+
−
+
−
void tst_MediaObject::testPlayIllegalFile()+
−
{+
−
    QString filename = QDir::tempPath() + QString("/test.wav");+
−
    QFile::remove(filename);+
−
    QFile file(filename);+
−
    file.open(QIODevice::WriteOnly);+
−
    for (int i=0;i<0xffff;i++) {+
−
        int r = qrand();+
−
        file.write((const char*)&r, 2);+
−
    }+
−
    file.close();+
−
    MediaObject media;+
−
    media.setCurrentSource(filename);+
−
    QTest::waitForSignal(&media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 10000);+
−
    QCOMPARE(media.state(), Phonon::ErrorState);+
−
    media.play();+
−
    QCOMPARE(media.state(), Phonon::ErrorState);+
−
    QFile::remove(filename);+
−
}+
−
+
−
void tst_MediaObject::init()+
−
{+
−
    QCOMPARE(m_media->outputPaths().size(), 1);+
−
    if (m_media->state() == Phonon::ErrorState) {+
−
        m_media->setCurrentSource(m_url);+
−
        if (m_media->state() == Phonon::ErrorState) {+
−
            QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)));+
−
        }+
−
        if (m_media->state() == Phonon::LoadingState) {+
−
            QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)));+
−
        }+
−
        m_stateChangedSignalSpy->clear();+
−
    }+
−
}+
−
+
−
void tst_MediaObject::cleanup()+
−
{+
−
    switch (m_media->state()) {+
−
    case Phonon::PlayingState:+
−
    case Phonon::BufferingState:+
−
    case Phonon::PausedState:+
−
        stopPlayback(m_media->state());+
−
        break;+
−
    default:+
−
        break;+
−
    }+
−
    m_stateChangedSignalSpy->clear();+
−
}+
−
+
−
void tst_MediaObject::_startPlayback(Phonon::State currentState)+
−
{+
−
    m_stateChangedSignalSpy->clear();+
−
    Phonon::State s = m_media->state();+
−
    QCOMPARE(s, currentState);+
−
    m_media->play();+
−
    while (s != Phonon::PlayingState) {+
−
        if (m_stateChangedSignalSpy->isEmpty()) {+
−
            QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 3000);+
−
            QApplication::processEvents();+
−
        }+
−
        while (!m_stateChangedSignalSpy->isEmpty()) {+
−
            QList<QVariant> args = m_stateChangedSignalSpy->takeFirst();+
−
            Phonon::State laststate = qvariant_cast<Phonon::State>(args.at(1));+
−
            QCOMPARE(laststate, s);+
−
            s = qvariant_cast<Phonon::State>(args.at(0));+
−
            QVERIFY(s == Phonon::BufferingState || s == Phonon::PlayingState);+
−
        }+
−
    }+
−
    QCOMPARE(s, Phonon::PlayingState);+
−
    QCOMPARE(m_media->state(), Phonon::PlayingState);+
−
    m_success = true;+
−
}+
−
+
−
void tst_MediaObject::_stopPlayback(Phonon::State currentState)+
−
{+
−
    QVERIFY(currentState != Phonon::ErrorState);+
−
    m_stateChangedSignalSpy->clear();+
−
    Phonon::State s = m_media->state();+
−
    QCOMPARE(s, currentState);+
−
    m_media->stop();+
−
    while (s != Phonon::StoppedState) {+
−
        if (m_stateChangedSignalSpy->isEmpty()) {+
−
            QVERIFY(QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 4000));+
−
        }+
−
        while (!m_stateChangedSignalSpy->isEmpty()) {+
−
            QList<QVariant> args = m_stateChangedSignalSpy->takeFirst();+
−
            Phonon::State laststate = qvariant_cast<Phonon::State>(args.at(1));+
−
            QCOMPARE(laststate, s);+
−
            s = qvariant_cast<Phonon::State>(args.at(0));+
−
            if (s == Phonon::StoppedState) {+
−
                QVERIFY(m_stateChangedSignalSpy->isEmpty());+
−
                break;+
−
            }+
−
            QVERIFY(s == Phonon::BufferingState || s == Phonon::PlayingState);+
−
        }+
−
    }+
−
    QCOMPARE(s, Phonon::StoppedState);+
−
    QCOMPARE(m_media->state(), Phonon::StoppedState);+
−
    m_success = true;+
−
}+
−
+
−
void tst_MediaObject::_pausePlayback()+
−
{+
−
    m_stateChangedSignalSpy->clear();+
−
    Phonon::State s = m_media->state();+
−
    m_media->pause();+
−
    while (s != Phonon::PausedState) {+
−
        if (m_stateChangedSignalSpy->isEmpty()) {+
−
            QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)));+
−
        }+
−
        while (!m_stateChangedSignalSpy->isEmpty()) {+
−
            QList<QVariant> args = m_stateChangedSignalSpy->takeFirst();+
−
            Phonon::State laststate = qvariant_cast<Phonon::State>(args.at(1));+
−
            QCOMPARE(laststate, s);+
−
            s = qvariant_cast<Phonon::State>(args.at(0));+
−
            if (s == Phonon::PausedState) {+
−
                QVERIFY(m_stateChangedSignalSpy->isEmpty());+
−
                break;+
−
            }+
−
            QVERIFY(s == Phonon::BufferingState || s == Phonon::PlayingState);+
−
        }+
−
    }+
−
    QCOMPARE(s, Phonon::PausedState);+
−
    QCOMPARE(m_media->state(), Phonon::PausedState);+
−
    m_success = true;+
−
}+
−
+
−
/*!+
−
  Copies the file \a name to the testing area. The resulting file name path is+
−
  returned in resultFilePath, and also set as a URL in \a asURL.+
−
 */+
−
void tst_MediaObject::copyMediaFile(const QString &original,+
−
                                    const QString &name,+
−
                                    QString &resultFilePath,+
−
                                    QUrl *const asURL)+
−
{+
−
    resultFilePath = QDir::toNativeSeparators(QDir::tempPath() + name);+
−
    if (asURL)+
−
        *asURL = QUrl::fromLocalFile(resultFilePath);+
−
+
−
    QFile::remove(resultFilePath);+
−
    QVERIFY(QFile::copy(original, resultFilePath));+
−
    QFile::setPermissions(resultFilePath, QFile::permissions(resultFilePath) | QFile::WriteOther);+
−
}+
−
+
−
void tst_MediaObject::initTestCase()+
−
{+
−
    QCoreApplication::setApplicationName("tst_MediaObject");+
−
    m_stateChangedSignalSpy = 0;+
−
    m_media = 0;+
−
+
−
#ifdef Q_OS_WINCE+
−
    QString pluginsPath = QLibraryInfo::location(QLibraryInfo::PluginsPath);+
−
#ifdef DEBUG+
−
    QVERIFY(QFile::exists(pluginsPath + "/phonon_backend/phonon_waveoutd4.dll") || QFile::exists(pluginsPath + "/phonon_backend/phonon_phonon_ds9d4.dll"));+
−
#else+
−
    QVERIFY(QFile::exists(pluginsPath + "/phonon_backend/phonon_waveout4.dll") || QFile::exists(pluginsPath + "/phonon_backend/phonon_phonon_ds94.dll"));+
−
#endif+
−
#endif+
−
+
−
+
−
    m_url = qgetenv("PHONON_TESTURL");+
−
    m_media = new MediaObject(this);+
−
    connect(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), SLOT(stateChanged(Phonon::State, Phonon::State)));+
−
    m_stateChangedSignalSpy = new QSignalSpy(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)));+
−
    QVERIFY(m_stateChangedSignalSpy->isValid());+
−
    m_stateChangedSignalSpy->clear();+
−
+
−
    if (m_url.isEmpty())+
−
        copyMediaFile(MEDIA_FILEPATH, MEDIA_FILE, m_tmpFileName, &m_url);+
−
    +
−
    qDebug() << "Using url:" << m_url.toString();+
−
+
−
    // AudioOutput is needed else the backend might have no time source+
−
    AudioOutput *audioOutput = new AudioOutput(Phonon::MusicCategory, this);+
−
    //audioOutput->setVolume(0.0f);+
−
+
−
    QSignalSpy totalTimeChangedSignalSpy(m_media, SIGNAL(totalTimeChanged(qint64)));+
−
    QVERIFY(m_media->queue().isEmpty());+
−
    QCOMPARE(m_media->currentSource().type(), MediaSource::Empty);+
−
    QCOMPARE(m_media->state(), Phonon::LoadingState);+
−
    QCOMPARE(m_stateChangedSignalSpy->count(), 0);+
−
+
−
    m_media->setCurrentSource(m_url);+
−
    QCOMPARE(m_media->currentSource().type(), MediaSource::Url);+
−
    QCOMPARE(m_media->currentSource().url(), m_url);+
−
+
−
    int emits = m_stateChangedSignalSpy->count();+
−
    Phonon::State s = m_media->state();+
−
    if (s == Phonon::LoadingState) {+
−
        // still in LoadingState, there should be no state change+
−
        QCOMPARE(emits, 0);+
−
        QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 6000);+
−
        emits = m_stateChangedSignalSpy->count();+
−
        s = m_media->state();+
−
    }+
−
    if (s != Phonon::LoadingState) {+
−
        // there should exactly be one state change+
−
        QCOMPARE(emits, 1);+
−
        QList<QVariant> args = m_stateChangedSignalSpy->takeFirst();+
−
        Phonon::State newstate = qvariant_cast<Phonon::State>(args.at(0));+
−
        Phonon::State oldstate = qvariant_cast<Phonon::State>(args.at(1));+
−
+
−
        QCOMPARE(Phonon::LoadingState, oldstate);+
−
        QCOMPARE(s, newstate);+
−
        if (Phonon::ErrorState == s) {+
−
#ifdef Q_WS_WIN+
−
            if (m_media->errorString().contains(QLatin1String("no audio hardware is available")))+
−
                QSKIP("On Windows we need an audio devide to perform the MediaObject tests", SkipAll); +
−
            else+
−
#endif+
−
            QFAIL("Loading the URL put the MediaObject into the ErrorState. Check that PHONON_TESTURL is set to a valid URL.");+
−
        }+
−
        QCOMPARE(Phonon::StoppedState, s);+
−
        QCOMPARE(m_stateChangedSignalSpy->count(), 0);+
−
+
−
        // check for totalTimeChanged signal+
−
        QVERIFY(totalTimeChangedSignalSpy.count() > 0);+
−
        args = totalTimeChangedSignalSpy.takeLast();+
−
        QCOMPARE(m_media->totalTime(), castQVariantToInt64(args.at(0)));+
−
    } else {+
−
        QFAIL("Still in LoadingState after a stateChange signal was emitted. Cannot go on.");+
−
    }+
−
+
−
    Path path = createPath(m_media, audioOutput);+
−
    QVERIFY(path.isValid());+
−
+
−
+
−
    QCOMPARE(m_media->outputPaths().size(), 1);+
−
    QCOMPARE(audioOutput->inputPaths().size(), 1);+
−
+
−
}+
−
+
−
void tst_MediaObject::checkForDefaults()+
−
{+
−
    QCOMPARE(m_media->tickInterval(), qint32(0));+
−
    QCOMPARE(m_media->prefinishMark(), qint32(0));+
−
}+
−
+
−
void tst_MediaObject::stopToStop()+
−
{+
−
    QCOMPARE(m_stateChangedSignalSpy->count(), 0);+
−
    QCOMPARE(m_media->state(), Phonon::StoppedState);+
−
    m_media->stop();+
−
    QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 2000);+
−
    QCOMPARE(m_stateChangedSignalSpy->count(), 0);+
−
    QCOMPARE(m_media->state(), Phonon::StoppedState);+
−
}+
−
+
−
void tst_MediaObject::stopToPause()+
−
{+
−
    QCOMPARE(m_stateChangedSignalSpy->count(), 0);+
−
    QCOMPARE(m_media->state(), Phonon::StoppedState);+
−
    m_media->pause();+
−
    if (m_stateChangedSignalSpy->isEmpty()) {+
−
        QVERIFY(QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 6000));+
−
    }+
−
    QCOMPARE(m_stateChangedSignalSpy->count(), 1);+
−
    QCOMPARE(m_media->state(), Phonon::PausedState);+
−
}+
−
+
−
void tst_MediaObject::stopToPlay()+
−
{+
−
    startPlayback();+
−
    QTest::waitForSignal(m_media, SIGNAL(finished()), 1000);+
−
    stopPlayback(Phonon::PlayingState);+
−
}+
−
+
−
void tst_MediaObject::playToPlay()+
−
{+
−
    startPlayback();+
−
+
−
    m_media->play();+
−
    QCOMPARE(m_stateChangedSignalSpy->count(), 0);+
−
    QCOMPARE(m_media->state(), Phonon::PlayingState);+
−
+
−
    stopPlayback(Phonon::PlayingState);+
−
}+
−
+
−
void tst_MediaObject::playToPause()+
−
{+
−
    startPlayback();+
−
    QCOMPARE(m_media->state(), Phonon::PlayingState);+
−
    pausePlayback();+
−
    stopPlayback(Phonon::PausedState);+
−
}+
−
+
−
void tst_MediaObject::playToStop()+
−
{+
−
    startPlayback();+
−
    stopPlayback(Phonon::PlayingState);+
−
}+
−
+
−
void tst_MediaObject::pauseToPause()+
−
{+
−
    startPlayback();+
−
    pausePlayback();+
−
+
−
    m_media->pause();+
−
    QCOMPARE(m_stateChangedSignalSpy->count(), 0);+
−
    QCOMPARE(m_media->state(), Phonon::PausedState);+
−
+
−
    stopPlayback(Phonon::PausedState);+
−
}+
−
+
−
void tst_MediaObject::pauseToPlay()+
−
{+
−
    startPlayback();+
−
    pausePlayback();+
−
    startPlayback2(Phonon::PausedState);+
−
    stopPlayback(Phonon::PlayingState);+
−
}+
−
+
−
void tst_MediaObject::pauseToStop()+
−
{+
−
    startPlayback();+
−
    pausePlayback();+
−
    stopPlayback(Phonon::PausedState);+
−
}+
−
+
−
/*!+
−
+
−
    We attempt to play a SDP file. An SDP file essentially describes different+
−
    media streams and is hence a layer in front of the actual media(s).+
−
    Sometimes the backend handles the SDP file, in other cases not.+
−
+
−
    Some Phonon backends doesn't support SDP at all, ifdef appropriately. Real+
−
    Player and Helix, the two backends for Symbian, are known to support SDP.+
−
 */+
−
void tst_MediaObject::playSDP()+
−
{+
−
#ifdef Q_OS_SYMBIAN+
−
    QString sdpFile;+
−
    copyMediaFile(QLatin1String(":/media/test.sdp"), QLatin1String("test.sdp"), sdpFile);+
−
+
−
    // Let's verify our test setup.+
−
    QVERIFY(QFileInfo(sdpFile).isReadable());+
−
+
−
    // We need a window in order to setup the video.+
−
    QWidget widget;+
−
    widget.show();+
−
+
−
    const MediaSource oldSource(m_media->currentSource());+
−
    const MediaSource sdpSource(sdpFile);+
−
    m_media->setCurrentSource(sdpSource);+
−
    if (m_media->state() != Phonon::StoppedState)+
−
        QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 10000);+
−
+
−
    // At this point we're in error state due to absent media, but it has now loaded the SDP:+
−
    QCOMPARE(m_media->errorString(), QString::fromLatin1("Buffering clip failed: Unknown error (-39)"));+
−
+
−
    // We cannot play the SDP, we can neither attempt to play it, because we+
−
    // won't get a state change from ErrorState to ErrorState, and hence block+
−
    // on a never occuring signal.+
−
    m_media->setCurrentSource(oldSource);+
−
+
−
#else+
−
    QSKIP("Unsupported on this platform.", SkipAll);+
−
#endif+
−
}+
−
+
−
void tst_MediaObject::testPrefinishMark()+
−
{+
−
    const qint32 requestedPrefinishMarkTime = 2000;+
−
    m_media->setPrefinishMark(requestedPrefinishMarkTime);+
−
    QCOMPARE(m_media->prefinishMark(), requestedPrefinishMarkTime);+
−
    QSignalSpy prefinishMarkReachedSpy(m_media, SIGNAL(prefinishMarkReached(qint32)));+
−
    QSignalSpy finishSpy(m_media, SIGNAL(finished()));+
−
    startPlayback();+
−
    if (m_media->isSeekable()) {+
−
        m_media->seek(m_media->totalTime() - SEEK_BACKWARDS - requestedPrefinishMarkTime); // give it 4 seconds+
−
    }+
−
    int wait = 10000;+
−
    int total = 0;+
−
    while (prefinishMarkReachedSpy.count() == 0 && (m_media->state() == Phonon::PlayingState ||+
−
                m_media->state() == Phonon::BufferingState)) {+
−
        wait = qMax(1000, wait / 2);+
−
        QTest::waitForSignal(m_media, SIGNAL(prefinishMarkReached(qint32)), wait);+
−
        total += wait;+
−
        if (total >= 60*1000) // we wait 1 minute+
−
            QFAIL("Timeout failure waiting for signal");+
−
    }+
−
    // at this point the media should be about to finish playing+
−
    qint64 r = m_media->remainingTime();+
−
    Phonon::State state = m_media->state();+
−
    QCOMPARE(prefinishMarkReachedSpy.count(), 1);+
−
    const qint32 prefinishMark = castQVariantToInt32(prefinishMarkReachedSpy.first().at(0));+
−
    QVERIFY(prefinishMark <= requestedPrefinishMarkTime + 150); // allow it to be up to 150ms too early+
−
    if (state == Phonon::PlayingState || state == Phonon::BufferingState) {+
−
        if (r > prefinishMark) {+
−
            qDebug() << "remainingTime =" << r;+
−
            QFAIL("remainingTime needs to be less than or equal to prefinishMark");+
−
        }+
−
        QVERIFY(r <= prefinishMark);+
−
        QTest::waitForSignal(m_media, SIGNAL(finished()), 10000);+
−
    } else {+
−
        QVERIFY(prefinishMark >= 0);+
−
    }+
−
    QCOMPARE(finishSpy.count(), 1);+
−
}+
−
+
−
void tst_MediaObject::enqueueMedia()+
−
{+
−
    m_media->enqueue(m_url);+
−
}+
−
+
−
Q_DECLARE_METATYPE(Phonon::MediaSource)+
−
void tst_MediaObject::testJustInTimeQueuing()+
−
{+
−
#ifdef Q_OS_WINCE+
−
    QSKIP("crashes on Windows CE", SkipAll);+
−
#endif+
−
    qRegisterMetaType<Phonon::MediaSource>("Phonon::MediaSource");+
−
    QSignalSpy currentSourceChanged(m_media, SIGNAL(currentSourceChanged(const Phonon::MediaSource &)));+
−
    QSignalSpy finished(m_media, SIGNAL(finished()));+
−
    connect(m_media, SIGNAL(aboutToFinish()), SLOT(enqueueMedia()));+
−
+
−
    startPlayback();+
−
    if (m_media->isSeekable()) {+
−
        m_media->seek(m_media->totalTime() - SEEK_BACKWARDS);+
−
        QVERIFY(QTest::waitForSignal(m_media, SIGNAL(aboutToFinish()), 6000));+
−
    } else {+
−
        QVERIFY(QTest::waitForSignal(m_media, SIGNAL(aboutToFinish()), 3000 + m_media->remainingTime()));+
−
    }+
−
    disconnect(m_media, SIGNAL(aboutToFinish()), this, SLOT(enqueueMedia()));+
−
    if (currentSourceChanged.isEmpty()) {+
−
        QVERIFY(QTest::waitForSignal(m_media, SIGNAL(currentSourceChanged(const Phonon::MediaSource &)), 3000));+
−
    }+
−
    QCOMPARE(currentSourceChanged.size(), 1);+
−
    QCOMPARE(finished.size(), 0);+
−
    QVERIFY(m_media->queue().isEmpty());+
−
    stopPlayback(m_media->state());+
−
}+
−
+
−
void tst_MediaObject::testPauseOnFinish()+
−
{+
−
    startPlayback();+
−
    QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 1000);+
−
    QCOMPARE(m_media->state(), Phonon::PlayingState);+
−
    if (m_media->isSeekable() && m_media->totalTime() > 2000)+
−
        m_media->seek(m_media->totalTime() - 2000);+
−
    QTest::waitForSignal(m_media, SIGNAL(finished()), 4000);+
−
    QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 1000);+
−
+
−
    QCOMPARE(m_media->state(), Phonon::PausedState);+
−
    connect(m_media, SIGNAL(finished()), m_media, SLOT(stop()));+
−
    m_media->seek(m_media->totalTime() - 2000);+
−
    m_media->play();+
−
+
−
    QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 1000);+
−
    QCOMPARE(m_media->state(), Phonon::PlayingState);+
−
    QTest::waitForSignal(m_media, SIGNAL(finished()), 4000);+
−
    QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 1000);+
−
    stopPlayback(Phonon::StoppedState);+
−
}+
−
+
−
void tst_MediaObject::testReconnectBetweenTwoMediaObjects(){+
−
    // Purpose: Test that phonon can handle swithing the same sink+
−
    // between different media objects.+
−
+
−
    Phonon::MediaObject obj1;+
−
    Phonon::MediaObject obj2;+
−
    Phonon::AudioOutput audio1;+
−
    Phonon::Path p1 = Phonon::createPath(&obj1, &audio1);+
−
    QVERIFY(p1.isValid());+
−
+
−
    QVERIFY(p1.reconnect(&obj1, &audio1));+
−
    QVERIFY(p1.isValid());+
−
    QVERIFY(p1.reconnect(&obj2, &audio1));+
−
    QVERIFY(p1.isValid());+
−
    QVERIFY(p1.reconnect(&obj1, &audio1));+
−
    QVERIFY(p1.isValid());+
−
+
−
    // Repeat the same test while playing:+
−
    QFile file(MEDIA_FILEPATH);+
−
    obj1.setCurrentSource(&file);+
−
    QFile file2(MEDIA_FILEPATH);+
−
    obj2.setCurrentSource(&file2);+
−
    obj1.play();+
−
    obj2.play();+
−
    +
−
    QVERIFY(p1.reconnect(&obj1, &audio1));+
−
    QVERIFY(p1.isValid());+
−
    QVERIFY(p1.reconnect(&obj2, &audio1));+
−
    QVERIFY(p1.isValid());+
−
    QVERIFY(p1.reconnect(&obj1, &audio1));+
−
    QVERIFY(p1.isValid());+
−
}+
−
+
−
void tst_MediaObject::testPlayOnFinish()+
−
{+
−
    connect(m_media, SIGNAL(finished()), SLOT(setMediaAndPlay()));+
−
    startPlayback();+
−
    if (m_media->isSeekable()) {+
−
        m_media->seek(m_media->totalTime() - SEEK_BACKWARDS);+
−
        QVERIFY(QTest::waitForSignal(this, SIGNAL(continueTestPlayOnFinish()), 6000));+
−
    } else {+
−
        QVERIFY(QTest::waitForSignal(this, SIGNAL(continueTestPlayOnFinish()), 3000 + m_media->remainingTime()));+
−
    }+
−
    QTest::waitForSignal(m_media, SIGNAL(finished()), 1000);+
−
    stopPlayback(m_media->state());+
−
}+
−
+
−
void tst_MediaObject::testTickSignal()+
−
{+
−
    QTime start1;+
−
    QTime start2;+
−
#ifdef Q_OS_WINCE //On Windows CE we only provide ticks above 400ms+
−
    for (qint32 tickInterval = 400; tickInterval <= 1000; tickInterval *= 2)+
−
#else+
−
    for (qint32 tickInterval = 80; tickInterval <= 500; tickInterval *= 2)+
−
#endif+
−
    {+
−
        QSignalSpy tickSpy(m_media, SIGNAL(tick(qint64)));+
−
        //qDebug() << "Test 20 ticks with an interval of" <<  tickInterval << "ms";+
−
        m_media->setTickInterval(tickInterval);+
−
        QVERIFY(m_media->tickInterval() <= tickInterval);+
−
        QVERIFY(m_media->tickInterval() >= tickInterval/2);+
−
        QVERIFY(tickSpy.isEmpty());+
−
        m_media->seek(0); //let's go back to the beginning+
−
        start1.start();+
−
        startPlayback();+
−
        start2.start();+
−
        int lastCount = 0;+
−
        qint64 s1, s2 = start2.elapsed();+
−
        while (tickSpy.count() < 20 && (m_media->state() == Phonon::PlayingState || m_media->state() == Phonon::BufferingState))+
−
        {+
−
            if (tickSpy.count() > lastCount)+
−
            {+
−
                s1 = start1.elapsed();+
−
                qint64 tickTime = castQVariantToInt64(tickSpy.last().at(0));+
−
                lastCount = tickSpy.count();+
−
                // s1 is the time from before the beginning of the playback to+
−
                // after the tick signal+
−
                // s2 is the time from after the beginning of the playback to+
−
                // before the tick signal+
−
                // so: s2 <= s1+
−
                QVERIFY(tickTime <= m_media->currentTime());+
−
                if (s1 + ALLOWED_TICK_INACCURACY < tickTime || s2 - ALLOWED_TICK_INACCURACY > tickTime) {+
−
                    qDebug()+
−
                        << "\n" << lastCount << "ticks have been received"+
−
                        << "\ntime from before playback was started to after the tick signal was received:" << s1 << "ms"+
−
                        << "\ntime from after playback was started to before the tick signal was received:" << s2 << "ms"+
−
                        << "\nreported tick time:" << tickTime << "ms"+
−
                        << "\nallowed inaccuracy: +/-" << ALLOWED_TICK_INACCURACY << "ms";+
−
                    for (int i = 0; i < tickSpy.count(); ++i) {+
−
                        qDebug() << castQVariantToInt64(tickSpy[i].at(0));+
−
                    }+
−
                }+
−
                QVERIFY(s1 + ALLOWED_TICK_INACCURACY >= tickTime);+
−
                QVERIFY(s2 - ALLOWED_TICK_INACCURACY <= tickTime);+
−
#ifndef Q_OS_WINCE+
−
                QVERIFY(s1 >= lastCount * m_media->tickInterval());+
−
#else+
−
                QVERIFY(s1 >= lastCount * m_media->tickInterval() - ALLOWED_TICK_INACCURACY);+
−
#endif+
−
                if (s2 > (lastCount + 1) * m_media->tickInterval())+
−
                    QWARN(qPrintable(QString("%1. tick came too late: %2ms elapsed while this tick should have come before %3ms")+
−
                            .arg(lastCount).arg(s2).arg((lastCount + 1) * m_media->tickInterval())));+
−
            } else if (lastCount == 0 && s2 > 20 * m_media->tickInterval()) {+
−
                QFAIL("no tick signals are being received");+
−
            }+
−
            s2 = start2.elapsed();+
−
            QTest::waitForSignal(m_media, SIGNAL(tick(qint64)), 2000);+
−
        }+
−
#ifndef Q_OS_WINCE //the shorter wave file is finished on Windows CE...+
−
        stopPlayback(Phonon::PlayingState);+
−
#else+
−
        stopPlayback(m_media->state());+
−
#endif+
−
    }+
−
}+
−
+
−
void tst_MediaObject::testSeek()+
−
{+
−
    m_media->seek(0); // let's seek back to the beginning+
−
    startPlayback();+
−
    QTime timer;+
−
    timer.start();+
−
    qint64 t = m_media->totalTime();+
−
    qint64 c = m_media->currentTime();+
−
    qint64 r = m_media->remainingTime();+
−
    int elapsed = timer.elapsed();+
−
    if (c + r > t + elapsed || c + r < t - elapsed) {+
−
    //  qDebug() << "currentTime:" << c+
−
    //      << "remainingTime:" << r+
−
    //      << "totalTime:" << t;+
−
        QFAIL("currentTime + remainingTime doesn't come close enough to totalTime");+
−
    }+
−
+
−
    QVERIFY(c + r <= t + elapsed);+
−
    QVERIFY(c + r >= t - elapsed);+
−
    if (m_media->isSeekable())+
−
        if (r > 0)+
−
        {+
−
            m_media->setTickInterval(20);+
−
            qint64 s = c + r / 2;+
−
            testOneSeek(s);+
−
+
−
            s /= 2;+
−
            testOneSeek(s);+
−
            s = s * 3 / 2;+
−
            testOneSeek(s);+
−
+
−
            pausePlayback();+
−
+
−
            s = s * 3 / 2;+
−
            testOneSeek(s);+
−
            s /= 2;+
−
            testOneSeek(s);+
−
+
−
            m_media->setTickInterval(0);+
−
+
−
+
−
            stopPlayback(Phonon::PausedState);+
−
            return;+
−
        }+
−
        else+
−
            QWARN("didn't test seeking as the MediaObject reported a remaining size <= 0");+
−
    else+
−
        QWARN("didn't test seeking as the MediaObject is not seekable");+
−
    stopPlayback(Phonon::PlayingState);+
−
}+
−
+
−
+
−
void tst_MediaObject::setMediaAndPlay()+
−
{+
−
    m_stateChangedSignalSpy->clear();+
−
    QCOMPARE(m_stateChangedSignalSpy->count(), 0);+
−
+
−
    QSignalSpy totalTimeChangedSignalSpy(m_media, SIGNAL(totalTimeChanged(qint64)));+
−
    QVERIFY(m_media->currentSource().type() != MediaSource::Invalid);+
−
    Phonon::State state = m_media->state();+
−
    QVERIFY(state == Phonon::StoppedState || state == Phonon::PlayingState || Phonon::PausedState);+
−
    m_media->setCurrentSource(m_url);+
−
    // before calling play() we better make sure that if play() finishes very fast that we don't get+
−
    // called again+
−
    disconnect(m_media, SIGNAL(finished()), this, SLOT(setMediaAndPlay()));+
−
    state = m_media->state();+
−
    startPlayback2(state);+
−
+
−
    emit continueTestPlayOnFinish();+
−
}+
−
+
−
void tst_MediaObject::testPlayBeforeFinish()+
−
{+
−
    startPlayback();+
−
    QCOMPARE(m_stateChangedSignalSpy->size(), 0);+
−
    Phonon::State state = m_media->state();+
−
    QCOMPARE(state, Phonon::PlayingState);+
−
    m_media->setCurrentSource(m_url);+
−
    m_media->play();+
−
    if (m_stateChangedSignalSpy->isEmpty()) {+
−
        QVERIFY(QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 4000));+
−
    }+
−
    // first (optional) state to reach is StoppedState+
−
    QList<QVariant> args = m_stateChangedSignalSpy->takeFirst();+
−
    Phonon::State oldstate = qvariant_cast<Phonon::State>(args.at(1));+
−
    QCOMPARE(oldstate, state);+
−
    state = qvariant_cast<Phonon::State>(args.at(0));+
−
    if (state == Phonon::StoppedState) {+
−
        if (m_stateChangedSignalSpy->isEmpty()) {+
−
            QVERIFY(QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 4000));+
−
        }+
−
        args = m_stateChangedSignalSpy->takeFirst();+
−
        oldstate = qvariant_cast<Phonon::State>(args.at(1));+
−
        QCOMPARE(oldstate, state);+
−
        state = qvariant_cast<Phonon::State>(args.at(0));+
−
    }+
−
    // next LoadingState+
−
    QCOMPARE(state, Phonon::LoadingState);+
−
    if (m_stateChangedSignalSpy->isEmpty()) {+
−
        QVERIFY(QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 4000));+
−
    }+
−
    // next either BufferingState or PlayingState+
−
    args = m_stateChangedSignalSpy->takeFirst();+
−
    oldstate = qvariant_cast<Phonon::State>(args.at(1));+
−
    QCOMPARE(oldstate, state);+
−
    state = qvariant_cast<Phonon::State>(args.at(0));+
−
    if (state == Phonon::BufferingState) {+
−
        if (m_stateChangedSignalSpy->isEmpty()) {+
−
            QVERIFY(QTest::waitForSignal(m_media, SIGNAL(stateChanged(Phonon::State, Phonon::State)), 4000)); // buffering can take a while+
−
        }+
−
        args = m_stateChangedSignalSpy->takeFirst();+
−
        oldstate = qvariant_cast<Phonon::State>(args.at(1));+
−
        QCOMPARE(oldstate, state);+
−
        state = qvariant_cast<Phonon::State>(args.at(0));+
−
    }+
−
#ifdef Q_WS_MAC+
−
    // m_media->setCurrentSource(m_url) in phonon frontend will always call+
−
    // 'stop' on the backend before calling 'setSource'. So the QT7 backend+
−
    // goes into stop, and naturally remains there after setting the new source.+
−
    // So going into playing state cannot happend when the backend is synchronized.+
−
    // Thats the reason for the ifdef.+
−
    QCOMPARE(state, Phonon::StoppedState);+
−
#else+
−
    stopPlayback(Phonon::PlayingState);+
−
#endif+
−
}+
−
+
−
void tst_MediaObject::cleanupTestCase()+
−
{+
−
    if (m_stateChangedSignalSpy)+
−
      delete m_stateChangedSignalSpy;+
−
    if (m_media)+
−
      delete m_media;+
−
#ifdef Q_OS_WINCE+
−
    QTest::qWait(200);+
−
#endif+
−
    if (!m_tmpFileName.isNull()) {+
−
        QVERIFY(QFile::remove(m_tmpFileName));+
−
    }+
−
}+
−
+
−
void tst_MediaObject::_testOneSeek(qint64 seekTo)+
−
{+
−
   qint64 t = m_media->totalTime();+
−
    qint64 oldTime = m_media->currentTime();+
−
    if (oldTime == seekTo) {+
−
        return;+
−
    }+
−
+
−
    QTime seekDuration;+
−
    seekDuration.start();+
−
    m_media->seek(seekTo);+
−
+
−
    QVERIFY(oldTime == 0 || seekTo == 0 || m_media->currentTime() != 0);+
−
+
−
    int bufferingTime = 0;+
−
    Phonon::State s = m_media->state();+
−
    QTime timer;+
−
    if (s == Phonon::BufferingState) {+
−
        timer.start();+
−
    }+
−
    QEventLoop loop;+
−
    connect(m_media, SIGNAL(tick(qint64)), &loop, SLOT(quit()));+
−
    connect(m_media, SIGNAL(stateChanged(Phonon::State,Phonon::State)), &loop, SLOT(quit()));+
−
+
−
    qint64 c = m_media->currentTime();+
−
    qint64 r = m_media->remainingTime();+
−
    int elapsed = 0;+
−
    while (qAbs(c - seekTo) > ALLOWED_SEEK_INACCURACY){+
−
        QTimer::singleShot(ALLOWED_TIME_FOR_SEEKING, &loop, SLOT(quit()));+
−
+
−
        loop.exec();+
−
        c = m_media->currentTime();+
−
        r = m_media->remainingTime();+
−
        if (s == Phonon::BufferingState) {+
−
            bufferingTime += timer.restart();+
−
        } else {+
−
            timer.start();+
−
        }+
−
        s = m_media->state();+
−
        elapsed = seekDuration.elapsed();+
−
        QVERIFY(elapsed - bufferingTime < (ALLOWED_TIME_FOR_SEEKING + SEEKING_TOLERANCE));+
−
    }+
−
+
−
    QVERIFY(c >= seekTo - ALLOWED_SEEK_INACCURACY);+
−
    if (s == Phonon::PausedState) {+
−
        QVERIFY(bufferingTime == 0);+
−
        elapsed = 0;+
−
    }+
−
    if (c > seekTo + ALLOWED_SEEK_INACCURACY + elapsed - bufferingTime) {+
−
        QFAIL("currentTime is greater than the requested time + the time that elapsed since the seek started.");+
−
    }+
−
    if (c + r > t + 200 || c + r < t - 200) {+
−
        QFAIL("currentTime + remainingTime doesn't come close enough to totalTime");+
−
    }+
−
    m_success = true;+
−
}+
−
+
−
void tst_MediaObject::volumeSliderMuteVisibility()+
−
{+
−
    //this test doesn't really belong to mediaobject+
−
    // ### see if we should create a realy Phonon::VolumeSlider autotest+
−
    Phonon::VolumeSlider slider;+
−
    QVERIFY(slider.isMuteVisible()); // that is the default value+
−
    slider.setMuteVisible(true);+
−
    QVERIFY(slider.isMuteVisible());+
−
+
−
    //let's check that changing the visibility of the slider itself+
−
    //doesn't change what the slider reports+
−
    slider.setVisible(false);+
−
    QVERIFY(slider.isMuteVisible());+
−
    slider.setVisible(true);+
−
+
−
    slider.setMuteVisible(false);+
−
    QVERIFY(!slider.isMuteVisible());+
−
    slider.setMuteVisible(true);+
−
    QVERIFY(slider.isMuteVisible());+
−
}+
−
+
−
+
−
#endif //QT_NO_PHONON+
−
+
−
+
−
QTEST_MAIN(tst_MediaObject)+
−
+
−
#include "tst_mediaobject.moc"+
−
// vim: sw=4 ts=4+
−