/****************************************************************************

**

** 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());

}

void tst_MediaObject::stateChanged(Phonon::State newstate, Phonon::State oldstate)

{

}

void tst_MediaObject::testPlayFromResource()

{

#ifdef Q_OS_SYMBIAN

    QSKIP("Not implemented yet.", SkipAll);

    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();