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

**

** 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 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 "tst_qmediaplayer.h"

QT_USE_NAMESPACE

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

    QCOMPARE(player.isAvailable(), false);

    QCOMPARE(player.availabilityError(), QtMultimediaKit::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;

        player.setPlaylist(&playlist);

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

        mockService->setPosition(position);

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

        player->setPosition(duration);

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

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

        mockService->setPosition(position);

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

        player->setPosition(-1);

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

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

        mockService->setPosition(position);

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

        player->setPosition(duration + 1);

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

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

    }

    else {

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

        player->setPosition(position);

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

        QCOMPARE(spy.count(), 0);

    }

}

void tst_QMediaPlayer::testVolume()

{

    QFETCH_GLOBAL(bool, valid);

    QFETCH_GLOBAL(int, volume);

    mockService->setVolume(volume);

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

    if (valid) {

        { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));

        player->setVolume(10);

        QCOMPARE(player->volume(), 10);

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

        { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));

        player->setVolume(-1000);

        QCOMPARE(player->volume(), 0);

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

        { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));

        player->setVolume(100);

        QCOMPARE(player->volume(), 100);

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

        { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));

        player->setVolume(1000);

        QCOMPARE(player->volume(), 100);

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

    }

}

void tst_QMediaPlayer::testMuted()

{

    QFETCH_GLOBAL(bool, valid);

    QFETCH_GLOBAL(bool, muted);

    QFETCH_GLOBAL(int, volume);

    if (valid) {

        mockService->setMuted(muted);

        mockService->setVolume(volume);

        QVERIFY(player->isMuted() == muted);

        QSignalSpy spy(player, SIGNAL(mutedChanged(bool)));

        player->setMuted(!muted);

        QCOMPARE(player->isMuted(), !muted);

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

        QCOMPARE(spy.count(), 1);

    }

}

void tst_QMediaPlayer::testVideoAvailable()

{

    QFETCH_GLOBAL(bool, videoAvailable);

    mockService->setVideoAvailable(videoAvailable);

    QVERIFY(player->isVideoAvailable() == videoAvailable);

}

void tst_QMediaPlayer::testBufferStatus()

{

    QFETCH_GLOBAL(int, bufferStatus);

    mockService->setBufferStatus(bufferStatus);

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

}

void tst_QMediaPlayer::testSeekable()

{

    QFETCH_GLOBAL(bool, seekable);

    mockService->setSeekable(seekable);

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

}

void tst_QMediaPlayer::testPlaybackRate()

{

    QFETCH_GLOBAL(bool, valid);

    QFETCH_GLOBAL(qreal, playbackRate);

    if (valid) {

        mockService->setPlaybackRate(playbackRate);

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

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

        player->setPlaybackRate(playbackRate + 0.5f);

        QCOMPARE(player->playbackRate(), playbackRate + 0.5f);

        QCOMPARE(spy.count(), 1);

    }

}

void tst_QMediaPlayer::testError()

{

    QFETCH_GLOBAL(QMediaPlayer::Error, error);

    mockService->setError(error);

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

}

void tst_QMediaPlayer::testErrorString()

{

    QFETCH_GLOBAL(QString, errorString);

    mockService->setErrorString(errorString);

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

}

void tst_QMediaPlayer::testIsAvailable()

{

    QCOMPARE(player->isAvailable(), true);

    QCOMPARE(player->availabilityError(), QtMultimediaKit::NoError);

}

void tst_QMediaPlayer::testService()

{

    /*

    QFETCH_GLOBAL(bool, valid);

    mockService->setIsValid(valid);

    if (valid)

        QVERIFY(player->service() != 0);

    else

        QVERIFY(player->service() == 0);

        */

}

void tst_QMediaPlayer::testPlay()

{

    QFETCH_GLOBAL(bool, valid);

    QFETCH_GLOBAL(QMediaContent, mediaContent);

    QFETCH_GLOBAL(QMediaPlayer::State, state);

    mockService->setIsValid(valid);

    mockService->setState(state);

    mockService->setMedia(mediaContent);

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

    QVERIFY(player->media() == mediaContent);

    QSignalSpy spy(player, SIGNAL(stateChanged(QMediaPlayer::State)));

    player->play();

    if (!valid || mediaContent.isNull())  {

        QCOMPARE(player->state(), QMediaPlayer::StoppedState);

        QCOMPARE(spy.count(), 0);

    }

    else {

        QCOMPARE(player->state(), QMediaPlayer::PlayingState);

        QCOMPARE(spy.count(), state == QMediaPlayer::PlayingState ? 0 : 1);

    }

}

void tst_QMediaPlayer::testPause()

{

    QFETCH_GLOBAL(bool, valid);

    QFETCH_GLOBAL(QMediaContent, mediaContent);

    QFETCH_GLOBAL(QMediaPlayer::State, state);

    mockService->setIsValid(valid);

    mockService->setState(state);

    mockService->setMedia(mediaContent);

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

    QVERIFY(player->media() == mediaContent);

    QSignalSpy spy(player, SIGNAL(stateChanged(QMediaPlayer::State)));

    player->pause();

    if (!valid || mediaContent.isNull()) {

        QCOMPARE(player->state(), QMediaPlayer::StoppedState);

        QCOMPARE(spy.count(), 0);

    }

    else {

        QCOMPARE(player->state(), QMediaPlayer::PausedState);

        QCOMPARE(spy.count(), state == QMediaPlayer::PausedState ? 0 : 1);

    }

}

void tst_QMediaPlayer::testStop()

{

    QFETCH_GLOBAL(QMediaContent, mediaContent);

    QFETCH_GLOBAL(QMediaPlayer::State, state);

    mockService->setState(state);

    mockService->setMedia(mediaContent);

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

    QVERIFY(player->media() == mediaContent);

    QSignalSpy spy(player, SIGNAL(stateChanged(QMediaPlayer::State)));

    player->stop();

    if (mediaContent.isNull() || state == QMediaPlayer::StoppedState) {

        QCOMPARE(player->state(), QMediaPlayer::StoppedState);

        QCOMPARE(spy.count(), 0);

    }

    else {

        QCOMPARE(player->state(), QMediaPlayer::StoppedState);

        QCOMPARE(spy.count(), 1);

    }

}

void tst_QMediaPlayer::testMediaStatus()

{

    QFETCH_GLOBAL(int, bufferStatus);

    int bufferSignals = 0;

    player->setNotifyInterval(10);

    mockService->setMediaStatus(QMediaPlayer::NoMedia);

    mockService->setBufferStatus(bufferStatus);

    AutoConnection connection(

            player, SIGNAL(bufferStatusChanged(int)),

            &QTestEventLoop::instance(), SLOT(exitLoop()));

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

    QSignalSpy bufferSpy(player, SIGNAL(bufferStatusChanged(int)));

    QCOMPARE(player->mediaStatus(), QMediaPlayer::NoMedia);

    mockService->setMediaStatus(QMediaPlayer::LoadingMedia);

    QCOMPARE(player->mediaStatus(), QMediaPlayer::LoadingMedia);

    QCOMPARE(statusSpy.count(), 1);