/**

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

* 

*/

#include <QModelIndex>

#include <QModelIndexList>

#include <hbapplication.h>

#include "videocollectionwrapper.h"

#include "videocollectioncommon.h"

#include "testvideosortfilterproxymodel.h"

#include "filterproxytester.h"

#include "videolistdatamodel.h"

#include "videocollectionclient.h"

#include "videocollectioncommon.h"

#include "videothumbnaildata.h"

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

// main

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

//

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

{

    HbApplication app(argc, argv);

    TestVideoSortFilterProxyModel 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\\testvideosortfilterproxymodel.txt";

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

    }    

    return res;

}

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

// init

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

//

void TestVideoSortFilterProxyModel::init()

{

    qRegisterMetaType<TMPXItemId>("TMPXItemId");

	VideoListDataModel::mInitFails = false;

	VideoListDataModel::mRemoveRowsFails = false;

	VideoListDataModel::mGetMediaIdAtIndexFails = 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;

    mTestObject = new FilterProxyTester(VideoCollectionWrapper::EGeneric);

    QVERIFY(mTestObject);

    mStubModel = new VideoListDataModel();

    QVERIFY(mStubModel);  

    mCollectionClient = new VideoCollectionClient();

    QVERIFY(mCollectionClient);

    mCollectionModel = new VideoSortFilterProxyModel(VideoCollectionWrapper::ECollections);

}

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

// cleanup

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

//

void TestVideoSortFilterProxyModel::cleanup()

{

	delete mCollectionClient;

	mCollectionClient = 0;

	delete mStubModel;

    mStubModel = 0;

    delete mTestObject;

    mTestObject = 0;

    delete mCollectionModel;

    mCollectionModel = 0;

}

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

// testInitialize

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

//

void TestVideoSortFilterProxyModel::testInitialize()

{

	QVERIFY(mTestObject->initialize(mStubModel) == 0);

}

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

// testInitializeSignalConnectFail

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

//

void TestVideoSortFilterProxyModel::testInitializeSignalConnectFail()

{	

	QVERIFY(mTestObject->initialize(NULL) == -1);

}

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

// testSecondInitialize

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

//

void TestVideoSortFilterProxyModel::testSecondInitialize()

{

	QVERIFY(mTestObject->initialize(mStubModel) == 0);

	QVERIFY(mTestObject->initialize(mStubModel) == 0);

}

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

// testOpen

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

//

void TestVideoSortFilterProxyModel::testOpen()

{

    // no mCollectionClient

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

    mTestObject->initialize(mStubModel);

	// First open.

	QVERIFY(mTestObject->open(1) == 0); 

	// Open again with same level.

	QVERIFY(mTestObject->open(1) == 0); 

	// Fail open.

	VideoCollectionClient::mFailStartOpen = true;

	QVERIFY(mTestObject->open(20) == -1);

}

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

// testDeleteItems

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

//

void TestVideoSortFilterProxyModel::testDeleteItems()

{

    VideoCollectionClient::mFailStartOpen = false;

    QVERIFY(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(Qt::DisplayRole, Qt::AscendingOrder);

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

    // processing time.

    QTest::qWait(500);

    QVERIFY(mTestObject->sortRole() == Qt::DisplayRole);

	int count = mTestObject->rowCount();

    QModelIndexList list;

    QModelIndex index; 

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

    {

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

        list.append(index);

    }

    QModelIndexList emptyList;

    VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;

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

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

	QVERIFY(mStubModel->mLastDeletedIndexRow == 0);

	QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 2);

}

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

// testDeleteItemsModelNull

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

//

void TestVideoSortFilterProxyModel::testDeleteItemsModelNull()

{

	mStubModel->appendData("Test");

	QVERIFY(mTestObject->initialize(NULL) == -1);

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

	QModelIndexList list;

	list.append(index);	

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

}

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

// testDeleteItemsRemoveRowsFail

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

//

void TestVideoSortFilterProxyModel::testDeleteItemsRemoveRowsFail()

{

	VideoListDataModel::mRemoveRowsFails = true;

	VideoCollectionClient::mFailStartOpen = false;

    QVERIFY(mTestObject->initialize(mStubModel) == 0);

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

	mStubModel->appendData("Test");

	QVERIFY(mTestObject->initialize(mStubModel) == 0);

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

	QModelIndexList list;

	list.append(index);

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

}

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

// testOpenItemInvalidId

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

//

void TestVideoSortFilterProxyModel::testOpenItemInvalidId()

{

	VideoListDataModel::mGetMediaIdAtIndexFails = true;

	VideoCollectionClient::mFailStartOpen = false;

    QVERIFY(mTestObject->initialize(mStubModel) == 0);

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

	mStubModel->appendData("Test");

	QVERIFY(mTestObject->initialize(mStubModel) == 0);

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

	TMPXItemId itemId = TMPXItemId::InvalidId();

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

}

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

// testOpenItemCollectionNull

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

//

void TestVideoSortFilterProxyModel::testOpenItemCollectionNull()

{	

	mStubModel->appendData("Test");

	TMPXItemId itemId(1,0);

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

}

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

// testOpenItemOpenVideoFails

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

//

void TestVideoSortFilterProxyModel::testOpenItemOpenVideoFails()

{

	VideoCollectionClient::mFailMediaPlayback = true;

	mStubModel->appendData("Test");

	QVERIFY(mTestObject->initialize(mStubModel) == 0);

	TMPXItemId itemId(1,0);

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

	VideoCollectionClient::mFailMediaPlayback = false;

}

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

// testOpenItem

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

//

void TestVideoSortFilterProxyModel::testOpenItem()

{   

    mStubModel->appendData("Test");

    QVERIFY(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 TestVideoSortFilterProxyModel::testBack()

{	

	QVERIFY(mTestObject->initialize(mStubModel) == 0);

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

	mTestObject->open(VideoCollectionCommon::ELevelAlbum);

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

}

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

// testBack

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

//

void TestVideoSortFilterProxyModel::testBackClientNull()

{	

	QVERIFY(mTestObject->initialize(mStubModel) == 0);

	VideoCollectionClient *tmpCollectionClient = mTestObject->getClient();

	mTestObject->setClient(0);

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

	mTestObject->setClient(tmpCollectionClient);

}

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

// testFetchItemDetails

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

//

void TestVideoSortFilterProxyModel::testFetchItemDetails()

{

    VideoCollectionClient::mFailStartOpen = false;

	mStubModel->appendData("Test");

	QVERIFY(mTestObject->initialize(mStubModel) == 0);

	mTestObject->open(3);

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

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

	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 TestVideoSortFilterProxyModel::testFetchItemDetailsGetMediaIdFail()

{

	VideoListDataModel::mGetMediaIdAtIndexFails = true;

	mStubModel->appendData("Test");

	QVERIFY(mTestObject->initialize(mStubModel) == 0);

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

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

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

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

}

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

// testFetchItemDetails

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

//

void TestVideoSortFilterProxyModel::testFetchItemDetailsGetVideoDetailsFails()

{

	VideoCollectionClient::mFailMediaDetails = true;

	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 TestVideoSortFilterProxyModel::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(Qt::DisplayRole);

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

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

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

}

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

// testLessThanName

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

//

void TestVideoSortFilterProxyModel::testLessThanName()

{

    VideoCollectionClient::mFailStartOpen = false;

    QVERIFY(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(Qt::DisplayRole);

    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(Qt::DisplayRole);

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

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

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

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