/**

* 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:   tester for methods in VideoProxyModelGeneric

* 

*/

#include <QModelIndex>

#include <QModelIndexList>

#include <hbapplication.h>

#define private public

#include "videoproxymodelgeneric.h"

#undef private

#include "filterproxytester.h"

#include "videocollectionwrapper.h"

#include "videocollectioncommon.h"

#include "testvideoproxymodelgeneric.h"

#include "videolistdatamodel.h"

#include "videocollectionclient.h"

#include "videocollectioncommon.h"

#include "videothumbnaildata.h"

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

// main

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

//

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

{

    HbApplication app(argc, argv);

    TestVideoProxyModelGeneric 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\\testVideoProxyModelGeneric.txt";

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

    }    

    return res;

}

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

// init

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

//

void TestVideoProxyModelGeneric::init()

{

    qRegisterMetaType<TMPXItemId>("TMPXItemId");

	VideoListDataModel::mInitFails = false;

	VideoListDataModel::mRemoveRowsFails = false;

	VideoListDataModel::mGetMediaIdAtIndexFails = false;

	VideoListDataModel::mGetCollectionClientFails = false;

	VideoCollectionClient::mFailMediaPlayback = false;

	VideoCollectionClient::mFailMediaDetails = false;

	VideoCollectionClient::mFailInit = false;

	VideoCollectionClient::mFailAddNewCollection = false;

	VideoCollectionClient::mSortOrderSetCount = 0;

	VideoCollectionClient::mAddNewCollectionName = QString();

	VideoCollectionClient::mAddNewCollectionThumb = QString();

	VideoCollectionClient::mAddNewCollectionIds = QList<TMPXItemId>();

	VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;

    mCollectionClient = new VideoCollectionClient();

    mStubModel = new VideoListDataModel();

    mTestObject = new FilterProxyTester();

    mCollectionModel = new VideoProxyModelGeneric();

}

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

// cleanup

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

//

void TestVideoProxyModelGeneric::cleanup()

{

	delete mCollectionClient;

	mCollectionClient = 0;

    delete mTestObject;

    mTestObject = 0;

    delete mCollectionModel;

    mCollectionModel = 0;

    delete mStubModel;

    mStubModel = 0;

}

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

// testInitialize

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

//

void TestVideoProxyModelGeneric::testInitialize()

{

	// Test without model.

    mTestObject = new FilterProxyTester();

    QCOMPARE(mCollectionModel->initialize(0), -1);

    QVERIFY(mTestObject->getModel() == 0);

    QVERIFY(mTestObject->getClient() == 0);

    // Test when collection client get fails.

    VideoListDataModel::mGetCollectionClientFails = true;

    QCOMPARE(mTestObject->initialize(mStubModel), -1);

    QVERIFY(mTestObject->getModel() == 0);

    QVERIFY(mTestObject->getClient() == 0);

    VideoListDataModel::mGetCollectionClientFails = false;

    QCOMPARE(mTestObject->initialize(mStubModel), 0);

}

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

// testOpen

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

//

void TestVideoProxyModelGeneric::testOpen()

{

    // no mCollectionClient

    QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelInvalid) == -1);

    QCOMPARE(mTestObject->initialize(mStubModel), 0);

	// First open.

	QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0); 

	// Open again with same level.

	QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0); 

	// Fail open.

	VideoCollectionClient::mFailStartOpen = true;

	QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == -1);

}

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

// testDeleteItems

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

//

void TestVideoProxyModelGeneric::testDeleteItems()

{

    // No model.

    QModelIndexList list;

    QCOMPARE(mTestObject->deleteItems(list), -1);

    // Ok cases.     

    VideoThumbnailData::mEnableBackgroundThumbnailFetchingCallCount = 0;

    VideoCollectionClient::mFailStartOpen = false;

    QCOMPARE(mTestObject->initialize(mStubModel), 0);

    QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);

    QString name1 = "cc";

    QString name2 = "bb";

    QString name3 = "aa";

    QString name4 = "11";

    QString name5 = "12";

    mStubModel->appendData(name1); // to source model index 0, proxy index after sort 4   

    mStubModel->appendData(name2); // to source model index 1, proxy index after sort 3

    mStubModel->appendData(name3); // to source model index 2, proxy index after sort 2

    mStubModel->appendData(name4); // to source model index 3, proxy index after sort 0

    mStubModel->appendData(name5); // to source model index 4, proxy index after sort 1

	// Sort to make sure that list order is different compared to source model

	mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::AscendingOrder);

    // Need to wait for awhile to make sure zero-counter gets 

    // processing time.

    QTest::qWait(500);

    QVERIFY(mTestObject->sortRole() == VideoCollectionCommon::KeyTitle);

    // Build list.

	int count = mTestObject->rowCount();

    QModelIndex index; 

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

    {

        index = mTestObject->index(i,0);

        list.append(index);

    }

    // Empty list.

    QModelIndexList emptyList;

    VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;

    QVERIFY(mTestObject->deleteItems(emptyList) == 0);

	QCOMPARE(VideoThumbnailData::mEnableBackgroundThumbnailFetchingCallCount, 2);

	QVERIFY(VideoThumbnailData::mBackgroundThumbnailFetchingEnabled == true);

	// List has items.

	VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;

	VideoThumbnailData::mEnableBackgroundThumbnailFetchingCallCount = 0;

	QVERIFY(mTestObject->deleteItems(list) == 0);

	QCOMPARE(VideoThumbnailData::mEnableBackgroundThumbnailFetchingCallCount, 2);

	QVERIFY(VideoThumbnailData::mBackgroundThumbnailFetchingEnabled == true);

	QCOMPARE(mStubModel->mLastDeletedIndexRow, 0);

	QCOMPARE(VideoThumbnailData::mStartBackgroundFetchingCallCount, 1);

}

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

// testDeleteItemsModelNull

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

//

void TestVideoProxyModelGeneric::testDeleteItemsModelNull()

{

	mStubModel->appendData("Test");

	QModelIndex index = mStubModel->index(0, 0);

	QModelIndexList list;

	list.append(index);	

	QVERIFY(mTestObject->deleteItems(list) == -1);

}

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

// testDeleteItemsRemoveRowsFail

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

//

void TestVideoProxyModelGeneric::testDeleteItemsRemoveRowsFail()

{

	VideoListDataModel::mRemoveRowsFails = true;

	VideoCollectionClient::mFailStartOpen = false;

	QCOMPARE(mTestObject->initialize(mStubModel), 0);

    QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);

	mStubModel->appendData("Test");

	QCOMPARE(mTestObject->initialize(mStubModel), 0);

	QModelIndex index = mTestObject->index(0, 0);

	QModelIndexList list;

	list.append(index);

	QVERIFY(mTestObject->deleteItems(list) == -1);

}

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

// testOpenItemInvalidId

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

//

void TestVideoProxyModelGeneric::testOpenItemInvalidId()

{

	VideoListDataModel::mGetMediaIdAtIndexFails = true;

	VideoCollectionClient::mFailStartOpen = false;

    QCOMPARE(mTestObject->initialize(mStubModel), 0);

    QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);

	mStubModel->appendData("Test");

	QCOMPARE(mTestObject->initialize(mStubModel), 0);

	QModelIndex index = mTestObject->index(0, 0);

	TMPXItemId itemId = TMPXItemId::InvalidId();

	QVERIFY(mTestObject->openItem(itemId) == -1);

}

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

// testOpenItemCollectionNull

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

//

void TestVideoProxyModelGeneric::testOpenItemCollectionNull()

{	

	mStubModel->appendData("Test");

	TMPXItemId itemId(1,0);

	QVERIFY(mTestObject->openItem(itemId) == -1);

}

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

// testOpenItemOpenVideoFails

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

//

void TestVideoProxyModelGeneric::testOpenItemOpenVideoFails()

{

	VideoCollectionClient::mFailMediaPlayback = true;

	mStubModel->appendData("Test");

	QCOMPARE(mTestObject->initialize(mStubModel), 0);

	TMPXItemId itemId(1,0);

	QVERIFY(mTestObject->openItem(itemId) == -1);

	VideoCollectionClient::mFailMediaPlayback = false;

}

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

// testOpenItem

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

//

void TestVideoProxyModelGeneric::testOpenItem()

{   

    mStubModel->appendData("Test");

    QCOMPARE(mTestObject->initialize(mStubModel), 0);

    TMPXItemId itemId(1,0);

    // open video

    QVERIFY(mTestObject->openItem(itemId) == 0);

    // open category or album

    itemId = TMPXItemId(1,2);

    QVERIFY(mTestObject->openItem(itemId) == 0);

}

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

// testBack

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

//

void TestVideoProxyModelGeneric::testBack()

{	

    QVERIFY(mTestObject->back() == -1);

    QCOMPARE(mTestObject->initialize(mStubModel), 0);

	QVERIFY(mTestObject->back() == 0);

	mTestObject->open(VideoCollectionCommon::ELevelAlbum);

	QVERIFY(mTestObject->back() == 0);

	// back fails

	VideoCollectionClient::mBackReturnValue = -1;

	QVERIFY(mTestObject->back() == -1);

	VideoCollectionClient::mBackReturnValue = 0;

}

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

// testFetchItemDetails

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

//

void TestVideoProxyModelGeneric::testFetchItemDetails()

{

    QModelIndex index;

    // no collection client

    QVERIFY(mTestObject->fetchItemDetails(index) == -1);

    // Ok

    VideoCollectionClient::mFailStartOpen = false;

	QCOMPARE(mTestObject->initialize(mStubModel), 0);

	mTestObject->open(VideoCollectionCommon::ELevelVideos);

    mStubModel->appendData("Test");

    index = mTestObject->index(0, 0);

	QSignalSpy fetchSpy(mTestObject, SIGNAL(shortDetailsReady(TMPXItemId)));

	QList<QVariant> arguments;

	QVERIFY(mTestObject->fetchItemDetails(index) == 0);

	QVERIFY(fetchSpy.count() == 1);

	arguments = fetchSpy.takeFirst();

	QVERIFY(arguments.at(0).toInt() == 0);

	arguments.clear();

	fetchSpy.clear();

}

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

// testFetchItemDetails

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

//

void TestVideoProxyModelGeneric::testFetchItemDetailsGetMediaIdFail()

{

	VideoListDataModel::mGetMediaIdAtIndexFails = true;

	QSignalSpy fetchSpy(mTestObject, SIGNAL(shortDetailsReady(TMPXItemId)));	

	mStubModel->appendData("Test");

	QModelIndex index = mTestObject->index(0, 0);

	// no model

	QVERIFY(mTestObject->fetchItemDetails(index) == -1);

	QCOMPARE(mTestObject->initialize(mStubModel), 0);

	QVERIFY(mTestObject->fetchItemDetails(index) == -1);

	QVERIFY(fetchSpy.count() == 0);

}

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

// testFetchItemDetails

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

//

void TestVideoProxyModelGeneric::testFetchItemDetailsGetVideoDetailsFails()

{

	VideoCollectionClient::mFailMediaDetails = true;

	QCOMPARE(mTestObject->initialize(mStubModel), 0);

	mTestObject->open(VideoCollectionCommon::ELevelVideos);

	mStubModel->appendData("Test");

	QSignalSpy fetchSpy(mTestObject, SIGNAL(shortDetailsReady(TMPXItemId)));

	QModelIndex index = mTestObject->index(0, 0);

	QVERIFY(mTestObject->fetchItemDetails(index) == -1);

	QVERIFY(fetchSpy.count() == 0);

}

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

// testLessThanProxyModelNotInitialized

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

//

void TestVideoProxyModelGeneric::testLessThanNoModel()

{

    // "normal" comparisation

    QString name1 = "cc";

    QString name2 = "bb";

    QString name3 = "aa";

    QString name4 = "11";

    QString name5 = "11";

    mStubModel->appendData(name1); // to index 0, position 4

    mStubModel->appendData(name2); // to index 1, position 3

    mStubModel->appendData(name3); // to index 2, position 2

    mStubModel->appendData(name4); // to index 3, position 0 or 1

    mStubModel->appendData(name5); // to index 4, position 0 or 1

    mTestObject->setSortRole(VideoCollectionCommon::KeyTitle);

    QModelIndex left = mStubModel->index(0,0);

    QModelIndex right = mStubModel->index(1,0);

    QVERIFY(!mTestObject->callLessThan(left, right));

}

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

// testLessThanName

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

//

void TestVideoProxyModelGeneric::testLessThanName()

{

    VideoCollectionClient::mFailStartOpen = false;

    QCOMPARE(mTestObject->initialize(mStubModel), 0);

    QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);

    // "normal" comparisation

    QString name1 = "cc";

    QString name2 = "bb";

    QString name3 = "aa";

    QString name4 = "11";

    QString name5 = "11";

    mStubModel->appendData(name1); // to index 0, position 4

    mStubModel->appendData(name2); // to index 1, position 3

    mStubModel->appendData(name3); // to index 2, position 2

    mStubModel->appendData(name4); // to index 3, position 0 or 1

    mStubModel->appendData(name5); // to index 4, position 0 or 1

    mTestObject->setSortRole(VideoCollectionCommon::KeyTitle);

    QModelIndex left = mStubModel->index(0,0);

    QModelIndex right = mStubModel->index(1,0);

    QVERIFY(!mTestObject->callLessThan(left, right));

    left = mStubModel->index(1,0);

    right = mStubModel->index(2,0);

    QVERIFY(!mTestObject->callLessThan(left, right));

    left = mStubModel->index(2,0);

    right = mStubModel->index(3,0);

    QVERIFY(!mTestObject->callLessThan(left, right));

    left = mStubModel->index(3,0);

    right = mStubModel->index(4,0);

    QVERIFY(!mTestObject->callLessThan(left, right));

    left = mStubModel->index(4,0);

    right = mStubModel->index(0,0);

    QVERIFY(mTestObject->callLessThan(left, right));

    // reset model

    mStubModel->removeAll();;

    // case sensitive check

    name1 = "cc";

    name2 = "CC";

    name3 = "cC";

    name4 = "aa";

    name5 = "Aa";

    QString name6 = "2Aa";

    QString name7 = "1Aa";

    QString name8 = "1cc";

    mStubModel->removeAll();

    mStubModel->appendData(name1); // to index 0, position can be 5, 6 or 7

    mStubModel->appendData(name2); // to index 1, position can be 5, 6 or 7

    mStubModel->appendData(name3); // to index 2, position can be 5, 6 or 7

    mStubModel->appendData(name4); // to index 3, position can be 3 or 4

    mStubModel->appendData(name5); // to index 4, position can be 3 or 4

    mStubModel->appendData(name6); // to index 5, position is 2 

    mStubModel->appendData(name7); // to index 6, position is 0

    mStubModel->appendData(name8); // to index 7, position is 1

    mTestObject->setSortRole(VideoCollectionCommon::KeyTitle);

    left = mStubModel->index(0,0);  // "cc"

    right = mStubModel->index(1,0); // "CC"

    QVERIFY(!mTestObject->callLessThan(left, right));

    left = mStubModel->index(1,0);  // "CC"

    right = mStubModel->index(2,0); // "cC"

    QVERIFY(!mTestObject->callLessThan(left, right));

    left = mStubModel->index(2,0);  // "cC"

    right = mStubModel->index(3,0); // "aa"

    QVERIFY(!mTestObject->callLessThan(left, right));

    left = mStubModel->index(3,0);  // "aa"

    right = mStubModel->index(2,0); // "cC"

    QVERIFY(mTestObject->callLessThan(left, right));

    left = mStubModel->index(3,0);  // "aa"

    right = mStubModel->index(4,0); // "Aa"

    QVERIFY(!mTestObject->callLessThan(left, right));

    left = mStubModel->index(4,0);  // "Aa"

    right = mStubModel->index(5,0); // "2Aa"