/**

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Unit test for methods in VideoThumbnailDataPrivate

*

*/

// INCLUDES

#include <hbapplication.h>

#include <hbinstance.h>

#include <qicon.h>

#include <qpair.h>

#include <qpointer.h>

#include <qlist.h>

#include <qvariant.h>

#include "qmetatype.h"

#include <vcxmyvideosdefs.h>

#include "testvideothumbnaildata_p.h"

#include "videothumbnailfetcher.h"

#include "videocollectionwrapper.h"

#include "e32std.h"

#define private public

#define protected public

#include "videothumbnaildatatester.h"

#undef private

#undef protected

#include "videothumbnaildata_p.h"

const int TB_PRIORITY = 1000;

// following constants are copied from videothumbnaildata.cpp

// Maximum thumbnails kept in memory.

const int THUMBNAIL_CACHE_SIZE = 60;

// Maximum of thumbnail fetches done at one background fetch round.

const int THUMBNAIL_BACKGROUND_FETCH_AMOUNT = 20;

// Milliseconds for the background fetch timer.

const int THUMBNAIL_BACKGROUND_TIMEOUT = 100;

// Milliseconds while thumbnail ready events are gathered before they 

// are signaled.

const int THUMBNAIL_READY_SIGNAL_TIMEOUT = 50;

// Priority for background thumbnail fetches.

const int BACKGROUND_FETCH_PRIORITY = 3000;

Q_DECLARE_METATYPE(QList<TMPXItemId>)

/**

 * global qHash function required fo creating hash values for TMPXItemId -keys

 */

inline uint qHash(TMPXItemId key) 

{ 

    QPair<uint, uint> keyPair(key.iId1, key.iId2); 

    return qHash(keyPair);

}

// ---------------------------------------------------------------------------

// main

// ---------------------------------------------------------------------------

//

int main(int argc, char *argv[])

{

    HbApplication app(argc, argv);

    HbMainWindow window;

    TestVideoThumbnailData_p tv;

    int res;

    if(argc > 1)

    {   

        res = QTest::qExec(&tv, argc, argv);

    }

    else

    {

        char *pass[3];

        pass[0] = argv[0];

        pass[1] = "-o";

        pass[2] = "c:\\data\\TestVideoThumbnailData_p.txt";

        res = QTest::qExec(&tv, 3, pass);

    }

    return res;

}

// ---------------------------------------------------------------------------

// init

// ---------------------------------------------------------------------------

//

void TestVideoThumbnailData_p::init()

{

    VideoCollectionWrapper::mReferenceCount = 0;

    VideoThumbnailFetcher::mConstructorCallCount = 0;

    VideoThumbnailFetcher::mDestructorCallCount = 0;

    VideoThumbnailFetcher::mAddFetchCallCount = 0;

    VideoThumbnailFetcher::mCancelFetchesCallCount = 0;

    VideoThumbnailFetcher::mFetchCountCallCount = 0;

    VideoThumbnailFetcher::mPauseFetchingCallCount = 0;

    VideoThumbnailFetcher::mContinueFetchingCallCount = 0;

    VideoThumbnailFetcher::mEnableThumbnailCreationCallCount = 0;

    VideoThumbnailFetcher::mAddFetchFails = false;

    VideoThumbnailFetcher::mThumbnailReadyError = 0;

    VideoCollectionWrapper::instance().setModel(mModel);

    mTestObject = new VideoThumbnailDataTester();

    mTestObject->initialize();

    mTestObject->mCurrentModel = mModel;

    qRegisterMetaType<QList<TMPXItemId> >("QList<TMPXItemId>& ");

}

// ---------------------------------------------------------------------------

// cleanup

// ---------------------------------------------------------------------------

//

void TestVideoThumbnailData_p::cleanup()

{

    delete mTestObject; mTestObject = 0;

}

// ---------------------------------------------------------------------------

// checkThumbnailReadyCount

// ---------------------------------------------------------------------------

//

bool TestVideoThumbnailData_p::checkThumbnailReadyCount(QSignalSpy *spy, int count)

{

    if(!mTestObject || !spy) 

        {

        qWarning("TestVideoThumbnailData_p::checkThumbnailReadyCount: error, mTestObject = %d, spy = %d", mTestObject, spy); 

        return false;

        }

    mTestObject->emitReportThumbnailsReady();

    if(spy->count() != 1)

    {

        qWarning("TestVideoThumbnailData_p::checkThumbnailReadyCount: error, spy->count() is %d, 1 was expected.", spy->count());

        return false;

    }

    QList<TMPXItemId> mediaIds = qvariant_cast<QList<TMPXItemId> >(spy->at(0).at(0));

    return mediaIds.count() == count;

}

// ---------------------------------------------------------------------------

// testDestructor

// ---------------------------------------------------------------------------

//

void TestVideoThumbnailData_p::testDestructor()

{

    init();

    mTestObject->getThumbnail(TMPXItemId(1, 0));

    mTestObject->getThumbnail(TMPXItemId(0, 1));

    QPointer<VideoThumbnailFetcher> thumbFetcher = mTestObject->mThumbnailFetcher;

    QPointer<QTimer> reportTimer = mTestObject->mTbnReportTimer;

    QPointer<QTimer> fetchTimer = mTestObject->mBgFetchTimer;

    cleanup();

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    QVERIFY(thumbFetcher == 0);

    QVERIFY(reportTimer == 0);

    QVERIFY(fetchTimer == 0);

}

// ---------------------------------------------------------------------------

// testInitialize

// ---------------------------------------------------------------------------

//

void TestVideoThumbnailData_p::testInitialize()

{

    mTestObject = new VideoThumbnailDataTester();

    QVERIFY(mTestObject->mThumbnailFetcher != 0);

    QVERIFY(mTestObject->mBgFetchTimer != 0);

    cleanup();

}

// ---------------------------------------------------------------------------

// testGetThumbnail

// ---------------------------------------------------------------------------

//

void TestVideoThumbnailData_p::testGetThumbnail()

{

    int mediaid(50);

    QPixmap pixmap(100,100);

    pixmap.fill(Qt::blue);

    init();

    mTestObject->mThumbnailData.insert(TMPXItemId(mediaid, 0), new QIcon(pixmap));

    QCOMPARE( *(mTestObject->getThumbnail(TMPXItemId(mediaid, 0))), *(mTestObject->mThumbnailData[TMPXItemId(mediaid, 0)]) );

    QVERIFY( mTestObject->getThumbnail(TMPXItemId(mediaid+100, 0)) != 0);

    cleanup();

}

// ---------------------------------------------------------------------------

// testStartFetchingThumbnail

// ---------------------------------------------------------------------------

//

void TestVideoThumbnailData_p::testStartFetchingThumbnail()

{

    QSignalSpy* spy = 0;

    // Tests when mModel is null.

    init();

    mTestObject->mCurrentModel = NULL;

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), -1);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    delete spy;

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    mTestObject->mCurrentModel = backupProxyModel;

    cleanup();

    // Tests when thumbnail fetcher is null.

    init();

    VideoThumbnailFetcher* backup = mTestObject->mThumbnailFetcher;

    mTestObject->mThumbnailFetcher = NULL;

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), -1);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    delete spy;

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    mTestObject->mThumbnailFetcher = backup;

    cleanup();

    // Thumbnail has been already fetched.

    init();

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    mTestObject->mThumbnailData.insert(TMPXItemId(10, 0), 0);

    QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(10, 0), TB_PRIORITY), 0);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    delete spy;

    cleanup();

    // Thumbnail fetch request to tn fetcher fails.

    init();

    VideoThumbnailFetcher::mAddFetchFails = true;

    mTestObject->mCurrentModel->appendData("testfile");

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), 0);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    delete spy;

    cleanup();

    // Filename is empty.

    init();

    mTestObject->mCurrentModel->appendData("");

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), 0);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    delete spy;

    cleanup();

    // Filename is null.

    init();

    mTestObject->mCurrentModel->appendData(QString());

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), 0);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    delete spy;

    cleanup();

    VideoThumbnailFetcher::TnRequest req;

    // Good case.

    init();

    QString fileName("video.mp4");

    mTestObject->mCurrentModel->appendData(fileName);

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), 0);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 1);

    req = VideoThumbnailFetcher::mRequests[0];

    QVERIFY(req.name == fileName);

    QCOMPARE(req.priority, TB_PRIORITY);

    delete spy;

    cleanup();

    // Already fetching same thumbnail.

    init();

    mTestObject->mCurrentModel->appendData(fileName);

    VideoThumbnailFetcher::mRequests.insert(1, VideoThumbnailFetcher::TnRequest("test1", 0, -1, false));

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), 0);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 1);

    req = VideoThumbnailFetcher::mRequests[1];

    QVERIFY(req.name == fileName);

    QCOMPARE(req.priority, TB_PRIORITY);

    delete spy;

    cleanup();

}

// ---------------------------------------------------------------------------

// testStartFetchingThumbnails

// ---------------------------------------------------------------------------

//

void TestVideoThumbnailData_p::testStartFetchingThumbnails()

{

    VideoThumbnailFetcher::TnRequest req;

    QList<QModelIndex> indexes;

    QSignalSpy* spy = 0;

    // Tests when mModel is null.

    init();

    indexes.clear();

    indexes.append(mTestObject->mCurrentModel->index(0, 0, QModelIndex()));

    indexes.append(mTestObject->mCurrentModel->index(10, 0, QModelIndex()));

    indexes.append(mTestObject->mCurrentModel->index(20, 0, QModelIndex()));

    mTestObject->mCurrentModel = NULL;

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnails(indexes,

            BACKGROUND_FETCH_PRIORITY), -1);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    delete spy;

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    mTestObject->mCurrentModel = backupProxyModel;

    QVERIFY(mTestObject->mCurrentFetchIndex == 0);

    cleanup();

    // Tests when mThumbnailFetcher is null.

    init();

    indexes.clear();

    VideoThumbnailFetcher* backup = mTestObject->mThumbnailFetcher;

    mTestObject->mThumbnailFetcher = NULL;

    indexes.append(mTestObject->mCurrentModel->index(0, 0, QModelIndex()));

    indexes.append(mTestObject->mCurrentModel->index(10, 0, QModelIndex()));

    indexes.append(mTestObject->mCurrentModel->index(20, 0, QModelIndex()));

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnails(indexes,

            BACKGROUND_FETCH_PRIORITY), -1);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    delete spy;

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    mTestObject->mThumbnailFetcher = backup;

    QVERIFY(mTestObject->mCurrentFetchIndex == 0);

    cleanup();

    // Tests when parameter array indexes is empty.

    init();

    indexes.clear();

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnails(indexes,

            BACKGROUND_FETCH_PRIORITY), 0);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    delete spy;

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    QVERIFY(mTestObject->mCurrentFetchIndex == 0);

    cleanup();

    // Already fetching some thumbnails.

    init();

    QString fileName("video.mp4");

    mTestObject->mCurrentModel->appendData(fileName);

    indexes.clear();

    VideoThumbnailFetcher::mRequests[50] = VideoThumbnailFetcher::TnRequest("test1", 0, -1, false);

    VideoThumbnailFetcher::mRequests[40] = VideoThumbnailFetcher::TnRequest("test2", 0, -1, false);

    VideoThumbnailFetcher::mRequests[30] = VideoThumbnailFetcher::TnRequest("test3", 0, -1, false);

    indexes.append(mTestObject->mCurrentModel->index(0, 0, QModelIndex()));

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnails(indexes,

            BACKGROUND_FETCH_PRIORITY), 1);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    delete spy;

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 4);

    req = VideoThumbnailFetcher::mRequests[50];

    QVERIFY(req.name == "test1");

    QCOMPARE(req.priority, -1);

    req = VideoThumbnailFetcher::mRequests[40];

    QVERIFY(req.name == "test2");

    QCOMPARE(req.priority, -1);

    req = VideoThumbnailFetcher::mRequests[30];

    QVERIFY(req.name == "test3");

    QCOMPARE(req.priority, -1);

    req = VideoThumbnailFetcher::mRequests[3];

    QVERIFY(req.name == fileName);

    QCOMPARE(req.priority, static_cast<int>(BACKGROUND_FETCH_PRIORITY));

    VideoThumbnailFetcher::mRequests.clear();

    QVERIFY(mTestObject->mCurrentFetchIndex == 0);

    cleanup();

    // Ok case

    init();

    mTestObject->mCurrentModel->appendData("file1");

    mTestObject->mCurrentModel->appendData("file2");

    mTestObject->mCurrentModel->appendData("file3");

    mTestObject->mCurrentModel->appendData("file4");

    mTestObject->mCurrentModel->appendData("file5");

    mTestObject->mCurrentModel->appendData("file6");

    indexes.clear();

    indexes.append(mTestObject->mCurrentModel->index(2, 0, QModelIndex()));

    indexes.append(mTestObject->mCurrentModel->index(3, 0, QModelIndex()));

    indexes.append(mTestObject->mCurrentModel->index(4, 0, QModelIndex()));

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    QCOMPARE(mTestObject->startFetchingThumbnails(indexes,

            BACKGROUND_FETCH_PRIORITY), 3);

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    delete spy;

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 3);

    req = VideoThumbnailFetcher::mRequests[0];

    QVERIFY(req.name == "file3");

    QCOMPARE(req.priority, static_cast<int>(BACKGROUND_FETCH_PRIORITY));

    req = VideoThumbnailFetcher::mRequests[1];

    QVERIFY(req.name == "file4");

    QCOMPARE(req.priority, static_cast<int>(BACKGROUND_FETCH_PRIORITY) - 1);

    req = VideoThumbnailFetcher::mRequests[2];

    QVERIFY(req.name == "file5");

    QCOMPARE(req.priority, static_cast<int>(BACKGROUND_FETCH_PRIORITY) - 2);

    cleanup();

}

// ---------------------------------------------------------------------------

// testDoBackgroundFetching

// ---------------------------------------------------------------------------

//

void TestVideoThumbnailData_p::testDoBackgroundFetching()

{

    VideoThumbnailFetcher::TnRequest req;

    QSignalSpy* spy = 0;

    // Tests when mModel is null.

    init();

    mTestObject->mCurrentModel = NULL;

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    mTestObject->emitDoBackgroundFetching();

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    delete spy;

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    mTestObject->mCurrentModel = backupProxyModel;

    QVERIFY(mTestObject->mCurrentFetchIndex == 0);

    cleanup();

    // Tests when mThumbnailFetcher is null.

    init();

    VideoThumbnailFetcher* backup = mTestObject->mThumbnailFetcher;

    mTestObject->mThumbnailFetcher = NULL;

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    mTestObject->emitDoBackgroundFetching();

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    delete spy;

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

    mTestObject->mThumbnailFetcher = backup;

    QVERIFY(mTestObject->mCurrentFetchIndex == 0);

    cleanup();

    // THUMBNAIL_BACKGROUND_FETCH_AMOUNT items in model and fetch index at 0

    init();

    for(int i = 0; i < THUMBNAIL_BACKGROUND_FETCH_AMOUNT; i++)

    {

        mTestObject->mCurrentModel->appendData(QString("file") + QString::number(i));

    }

    spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId> &)));

    mTestObject->emitDoBackgroundFetching();

    QVERIFY(checkThumbnailReadyCount(spy, 0));

    QCOMPARE(VideoThumbnailFetcher::mRequests.count(), THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2);

    int previousPriority = -1;

    for(int i = 0; i < THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2; i++)

    {

        req = VideoThumbnailFetcher::mRequests[i];

        QVERIFY(req.name == "file" + QString::number(i));

        if(previousPriority != -1)

        {

            QVERIFY(previousPriority > req.priority);    

        }

        previousPriority = req.priority;

        QVERIFY(previousPriority != -1);

    }

    QVERIFY(mTestObject->mCurrentFetchIndex == 0);

    QVERIFY(mTestObject->mCurrentBackgroundFetchCount == THUMBNAIL_BACKGROUND_FETCH_AMOUNT);

    QVERIFY(mTestObject->mBgFetchTimer->isActive() == false);

    // Continue fetching.

    spy->clear();

    mTestObject->emitDoBackgroundFetching();

    QVERIFY(checkThumbnailReadyCount(spy, 0));