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

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $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$

**

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

#include <QtTest/QtTest>

#include <QtCore/qdebug.h>

#include <QtCore/qbuffer.h>

#include <qmediaplayer.h>

#include <qmediaplayercontrol.h>

#include <qmediaplaylist.h>

#include <qmediaservice.h>

#include <qmediastreamscontrol.h>

QT_USE_NAMESPACE

class AutoConnection

{

public:

    AutoConnection(QObject *sender, const char *signal, QObject *receiver, const char *method)

            : sender(sender), signal(signal), receiver(receiver), method(method)

    {

        QObject::connect(sender, signal, receiver, method);

    }

    ~AutoConnection()

    {

        QObject::disconnect(sender, signal, receiver, method);

    }

private:

    QObject *sender;

    const char *signal;

    QObject *receiver;

    const char *method;

};

class MockPlayerControl : public QMediaPlayerControl

{

    friend class MockPlayerService;

public:

    MockPlayerControl():QMediaPlayerControl(0) {}

    QMediaPlayer::State state() const { return _state; }

    QMediaPlayer::MediaStatus mediaStatus() const { return _mediaStatus; }

    qint64 duration() const { return _duration; }

    qint64 position() const { return _position; }

    void setPosition(qint64 position) { if (position != _position) emit positionChanged(_position = position); }

    int volume() const { return _volume; }

    void setVolume(int volume) { emit volumeChanged(_volume = volume); }

    bool isMuted() const { return _muted; }

    void setMuted(bool muted) { if (muted != _muted) emit mutedChanged(_muted = muted); }

    int bufferStatus() const { return _bufferStatus; }

    bool isAudioAvailable() const { return _audioAvailable; }

    bool isVideoAvailable() const { return _videoAvailable; }

    bool isSeekable() const { return _isSeekable; }

    QMediaTimeRange availablePlaybackRanges() const { return QMediaTimeRange(_seekRange.first, _seekRange.second); }

    void setSeekRange(qint64 minimum, qint64 maximum) { _seekRange = qMakePair(minimum, maximum); }

    qreal playbackRate() const { return _playbackRate; }

    void setPlaybackRate(qreal rate) { if (rate != _playbackRate) emit playbackRateChanged(_playbackRate = rate); }

    QMediaContent media() const { return _media; }

    void setMedia(const QMediaContent &content, QIODevice *stream)

    {

        _stream = stream;

        _media = content;

        if (_state != QMediaPlayer::StoppedState) {

            _mediaStatus = _media.isNull() ? QMediaPlayer::NoMedia : QMediaPlayer::LoadingMedia;

            emit stateChanged(_state = QMediaPlayer::StoppedState);

            emit mediaStatusChanged(_mediaStatus);

        }

        emit mediaChanged(_media = content);

    }

    QIODevice *mediaStream() const { return _stream; }

    void play() { if (_isValid && !_media.isNull() && _state != QMediaPlayer::PlayingState) emit stateChanged(_state = QMediaPlayer::PlayingState); }

    void pause() { if (_isValid && !_media.isNull() && _state != QMediaPlayer::PausedState) emit stateChanged(_state = QMediaPlayer::PausedState); }

    void stop() { if (_state != QMediaPlayer::StoppedState) emit stateChanged(_state = QMediaPlayer::StoppedState); }

    QMediaPlayer::State _state;

    QMediaPlayer::MediaStatus _mediaStatus;

    QMediaPlayer::Error _error;

    qint64 _duration;

    qint64 _position;

    int _volume;

    bool _muted;

    int _bufferStatus;

    bool _audioAvailable;

    bool _videoAvailable;

    bool _isSeekable;

    QPair<qint64, qint64> _seekRange;

    qreal _playbackRate;

    QMediaContent _media;

    QIODevice *_stream;

    bool _isValid;

    QString _errorString;

};

class MockStreamsControl : public QMediaStreamsControl

{

public:

    MockStreamsControl(QObject *parent = 0) : QMediaStreamsControl(parent) {}

    int streamCount() { return _streams.count(); }

    void setStreamCount(int count) { _streams.resize(count); }

    StreamType streamType(int index) { return _streams.at(index).type; }

    void setStreamType(int index, StreamType type) { _streams[index].type = type; }

    QVariant metaData(int index, QtMediaServices::MetaData key) {

        return _streams.at(index).metaData.value(key); }

    void setMetaData(int index, QtMediaServices::MetaData key, const QVariant &value) {

        _streams[index].metaData.insert(key, value); }

    bool isActive(int index) { return _streams.at(index).active; }

    void setActive(int index, bool state) { _streams[index].active = state; }

private:

    struct Stream

    {

        Stream() : type(UnknownStream), active(false) {}

        StreamType type;

        QMap<QtMediaServices::MetaData, QVariant> metaData;

        bool active;

    };

    QVector<Stream> _streams;

};

class MockPlayerService : public QMediaService

{

    Q_OBJECT

public:

    MockPlayerService():QMediaService(0)

    {

        mockControl = new MockPlayerControl;

        mockStreamsControl = new MockStreamsControl;

    }

    ~MockPlayerService()

    {

        delete mockControl;

        delete mockStreamsControl;

    }

    QMediaControl* control(const char *iid) const

    {

        if (qstrcmp(iid, QMediaPlayerControl_iid) == 0)

            return mockControl;

        return 0;

    }

    void setState(QMediaPlayer::State state) { emit mockControl->stateChanged(mockControl->_state = state); }

    void setState(QMediaPlayer::State state, QMediaPlayer::MediaStatus status) {

        mockControl->_state = state;

        mockControl->_mediaStatus = status;

        emit mockControl->mediaStatusChanged(status);

        emit mockControl->stateChanged(state);

    }

    void setMediaStatus(QMediaPlayer::MediaStatus status) { emit mockControl->mediaStatusChanged(mockControl->_mediaStatus = status); }

    void setIsValid(bool isValid) { mockControl->_isValid = isValid; }

    void setMedia(QMediaContent media) { mockControl->_media = media; }

    void setDuration(qint64 duration) { mockControl->_duration = duration; }

    void setPosition(qint64 position) { mockControl->_position = position; }

    void setSeekable(bool seekable) { mockControl->_isSeekable = seekable; }

    void setVolume(int volume) { mockControl->_volume = volume; }

    void setMuted(bool muted) { mockControl->_muted = muted; }

    void setVideoAvailable(bool videoAvailable) { mockControl->_videoAvailable = videoAvailable; }

    void setBufferStatus(int bufferStatus) { mockControl->_bufferStatus = bufferStatus; }

    void setPlaybackRate(qreal playbackRate) { mockControl->_playbackRate = playbackRate; }

    void setError(QMediaPlayer::Error error) { mockControl->_error = error; emit mockControl->error(mockControl->_error, mockControl->_errorString); }

    void setErrorString(QString errorString) { mockControl->_errorString = errorString; emit mockControl->error(mockControl->_error, mockControl->_errorString); }

    void reset()

    {

        mockControl->_state = QMediaPlayer::StoppedState;

        mockControl->_mediaStatus = QMediaPlayer::UnknownMediaStatus;

        mockControl->_error = QMediaPlayer::NoError;

        mockControl->_duration = 0;

        mockControl->_position = 0;

        mockControl->_volume = 0;

        mockControl->_muted = false;

        mockControl->_bufferStatus = 0;

        mockControl->_videoAvailable = false;

        mockControl->_isSeekable = false;

        mockControl->_playbackRate = 0.0;

        mockControl->_media = QMediaContent();

        mockControl->_stream = 0;

        mockControl->_isValid = false;

        mockControl->_errorString = QString();

    }

    MockPlayerControl *mockControl;

    MockStreamsControl *mockStreamsControl;

};

class MockProvider : public QMediaServiceProvider

{

public:

    MockProvider(MockPlayerService *service):mockService(service) {}

    QMediaService *requestService(const QByteArray &, const QMediaServiceProviderHint &)

    {

        return mockService;

    }

    void releaseService(QMediaService *service) { delete service; }

    MockPlayerService *mockService;

};

class tst_QMediaPlayer: public QObject

{

    Q_OBJECT

public slots:

    void initTestCase_data();

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void testNullService();

    void testValid();

    void testMedia();

    void testDuration();

    void testPosition();

    void testVolume();

    void testMuted();

    void testVideoAvailable();

    void testBufferStatus();

    void testSeekable();

    void testPlaybackRate();

    void testError();

    void testErrorString();

    void testService();

    void testPlay();

    void testPause();

    void testStop();

    void testMediaStatus();

    void testPlaylist();

private:

    MockProvider *mockProvider;

    MockPlayerService  *mockService;

    QMediaPlayer *player;

};

void tst_QMediaPlayer::initTestCase_data()

{

    QTest::addColumn<bool>("valid");

    QTest::addColumn<QMediaPlayer::State>("state");

    QTest::addColumn<QMediaPlayer::MediaStatus>("status");

    QTest::addColumn<QMediaContent>("mediaContent");

    QTest::addColumn<qint64>("duration");

    QTest::addColumn<qint64>("position");

    QTest::addColumn<bool>("seekable");

    QTest::addColumn<int>("volume");

    QTest::addColumn<bool>("muted");

    QTest::addColumn<bool>("videoAvailable");

    QTest::addColumn<int>("bufferStatus");

    QTest::addColumn<qreal>("playbackRate");

    QTest::addColumn<QMediaPlayer::Error>("error");

    QTest::addColumn<QString>("errorString");

    QTest::newRow("invalid") << false << QMediaPlayer::StoppedState << QMediaPlayer::UnknownMediaStatus <<

                                QMediaContent() << qint64(0) << qint64(0) << false << 0 << false << false << 0 <<

                                qreal(0) << QMediaPlayer::NoError << QString();

    QTest::newRow("valid+null") << true << QMediaPlayer::StoppedState << QMediaPlayer::UnknownMediaStatus <<

                                QMediaContent() << qint64(0) << qint64(0) << false << 0 << false << false << 50 <<

                                qreal(0) << QMediaPlayer::NoError << QString();

    QTest::newRow("valid+content+stopped") << true << QMediaPlayer::StoppedState << QMediaPlayer::UnknownMediaStatus <<

                                QMediaContent(QUrl("file:///some.mp3")) << qint64(0) << qint64(0) << false << 50 << false << false << 0 <<

                                qreal(1) << QMediaPlayer::NoError << QString();

    QTest::newRow("valid+content+playing") << true << QMediaPlayer::PlayingState << QMediaPlayer::LoadedMedia <<

                                QMediaContent(QUrl("file:///some.mp3")) << qint64(10000) << qint64(10) << true << 50 << true << false << 0 <<

                                qreal(1) << QMediaPlayer::NoError << QString();

    QTest::newRow("valid+content+paused") << true << QMediaPlayer::PausedState << QMediaPlayer::LoadedMedia <<

                                QMediaContent(QUrl("file:///some.mp3")) << qint64(10000) << qint64(10) << true << 50 << true << false << 0 <<

                                qreal(1)  << QMediaPlayer::NoError << QString();

    QTest::newRow("valud+streaming") << true << QMediaPlayer::PlayingState << QMediaPlayer::LoadedMedia <<

                                QMediaContent(QUrl("http://example.com/stream")) << qint64(10000) << qint64(10000) << false << 50 << false << true << 0 <<

                                qreal(1)  << QMediaPlayer::NoError << QString();

    QTest::newRow("valid+error") << true << QMediaPlayer::StoppedState << QMediaPlayer::UnknownMediaStatus <<

                                QMediaContent(QUrl("http://example.com/stream")) << qint64(0) << qint64(0) << false << 50 << false << false << 0 <<

                                qreal(0) << QMediaPlayer::ResourceError << QString("Resource unavailable");

}

void tst_QMediaPlayer::initTestCase()

{

    qRegisterMetaType<QMediaPlayer::State>("QMediaPlayer::State");

    qRegisterMetaType<QMediaPlayer::Error>("QMediaPlayer::Error");

    qRegisterMetaType<QMediaPlayer::MediaStatus>("QMediaPlayer::MediaStatus");

    qRegisterMetaType<QMediaContent>("QMediaContent");

    mockService = new MockPlayerService;

    mockProvider = new MockProvider(mockService);

    player = new QMediaPlayer(0, 0, mockProvider);

}

void tst_QMediaPlayer::cleanupTestCase()

{

    delete player;

}

void tst_QMediaPlayer::init()

{

    mockService->reset();

}

void tst_QMediaPlayer::cleanup()

{

}

void tst_QMediaPlayer::testNullService()

{

    MockProvider provider(0);

    QMediaPlayer player(0, 0, &provider);

    const QIODevice *nullDevice = 0;

    QCOMPARE(player.media(), QMediaContent());

    QCOMPARE(player.mediaStream(), nullDevice);

    QCOMPARE(player.state(), QMediaPlayer::StoppedState);

    QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);

    QCOMPARE(player.duration(), qint64(-1));

    QCOMPARE(player.position(), qint64(0));

    QCOMPARE(player.volume(), 0);

    QCOMPARE(player.isMuted(), false);

    QCOMPARE(player.isVideoAvailable(), false);

    QCOMPARE(player.bufferStatus(), 0);

    QCOMPARE(player.isSeekable(), false);

    QCOMPARE(player.playbackRate(), qreal(0));

    QCOMPARE(player.error(), QMediaPlayer::ServiceMissingError);

    {

        QFETCH_GLOBAL(QMediaContent, mediaContent);

        QSignalSpy spy(&player, SIGNAL(mediaChanged(QMediaContent)));

        QFile file;

        player.setMedia(mediaContent, &file);

        QCOMPARE(player.media(), QMediaContent());

        QCOMPARE(player.mediaStream(), nullDevice);

        QCOMPARE(spy.count(), 0);

    } {

        QSignalSpy stateSpy(&player, SIGNAL(stateChanged(QMediaPlayer::State)));

        QSignalSpy statusSpy(&player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));

        player.play();

        QCOMPARE(player.state(), QMediaPlayer::StoppedState);

        QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);

        QCOMPARE(stateSpy.count(), 0);

        QCOMPARE(statusSpy.count(), 0);

        player.pause();

        QCOMPARE(player.state(), QMediaPlayer::StoppedState);

        QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);

        QCOMPARE(stateSpy.count(), 0);

        QCOMPARE(statusSpy.count(), 0);

        player.stop();

        QCOMPARE(player.state(), QMediaPlayer::StoppedState);

        QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);

        QCOMPARE(stateSpy.count(), 0);

        QCOMPARE(statusSpy.count(), 0);

    } {

        QFETCH_GLOBAL(int, volume);

        QFETCH_GLOBAL(bool, muted);

        QSignalSpy volumeSpy(&player, SIGNAL(volumeChanged(int)));

        QSignalSpy mutingSpy(&player, SIGNAL(mutedChanged(bool)));

        player.setVolume(volume);

        QCOMPARE(player.volume(), 0);

        QCOMPARE(volumeSpy.count(), 0);

        player.setMuted(muted);

        QCOMPARE(player.isMuted(), false);

        QCOMPARE(mutingSpy.count(), 0);

    } {

        QFETCH_GLOBAL(qint64, position);

        QSignalSpy spy(&player, SIGNAL(positionChanged(qint64)));

        player.setPosition(position);

        QCOMPARE(player.position(), qint64(0));

        QCOMPARE(spy.count(), 0);

    } {

        QFETCH_GLOBAL(qreal, playbackRate);

        QSignalSpy spy(&player, SIGNAL(playbackRateChanged(qreal)));

        player.setPlaybackRate(playbackRate);

        QCOMPARE(player.playbackRate(), qreal(0));

        QCOMPARE(spy.count(), 0);

    } {

        QMediaPlaylist playlist;

        playlist.setMediaObject(&player);

        QSignalSpy mediaSpy(&player, SIGNAL(mediaChanged(QMediaContent)));

        QSignalSpy statusSpy(&player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));

        playlist.addMedia(QUrl("http://example.com/stream"));

        playlist.addMedia(QUrl("file:///some.mp3"));

        playlist.setCurrentIndex(0);

        QCOMPARE(playlist.currentIndex(), 0);

        QCOMPARE(player.media(), QMediaContent());

        QCOMPARE(mediaSpy.count(), 0);

        QCOMPARE(statusSpy.count(), 0);

        playlist.next();

        QCOMPARE(playlist.currentIndex(), 1);

        QCOMPARE(player.media(), QMediaContent());

        QCOMPARE(mediaSpy.count(), 0);

        QCOMPARE(statusSpy.count(), 0);

    }

}

void tst_QMediaPlayer::testValid()

{

    /*

    QFETCH_GLOBAL(bool, valid);

    mockService->setIsValid(valid);

    QCOMPARE(player->isValid(), valid);

    */

}

void tst_QMediaPlayer::testMedia()

{

    QFETCH_GLOBAL(QMediaContent, mediaContent);

    mockService->setMedia(mediaContent);

    QCOMPARE(player->media(), mediaContent);

    QBuffer stream;

    player->setMedia(mediaContent, &stream);

    QCOMPARE(player->media(), mediaContent);

    QCOMPARE((QBuffer*)player->mediaStream(), &stream);

}

void tst_QMediaPlayer::testDuration()

{

    QFETCH_GLOBAL(qint64, duration);

    mockService->setDuration(duration);

    QVERIFY(player->duration() == duration);

}

void tst_QMediaPlayer::testPosition()

{

    QFETCH_GLOBAL(bool, valid);

    QFETCH_GLOBAL(bool, seekable);

    QFETCH_GLOBAL(qint64, position);

    QFETCH_GLOBAL(qint64, duration);

    mockService->setIsValid(valid);

    mockService->setSeekable(seekable);

    mockService->setPosition(position);

    mockService->setDuration(duration);

    QVERIFY(player->isSeekable() == seekable);

    QVERIFY(player->position() == position);

    QVERIFY(player->duration() == duration);

    if (seekable) {

        { QSignalSpy spy(player, SIGNAL(positionChanged(qint64)));

        player->setPosition(position);

        QCOMPARE(player->position(), position);

        QCOMPARE(spy.count(), 0); }

        mockService->setPosition(position);

        { QSignalSpy spy(player, SIGNAL(positionChanged(qint64)));

        player->setPosition(0);

        QCOMPARE(player->position(), qint64(0));

        QCOMPARE(spy.count(), position == 0 ? 0 : 1); }