/**

* 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 "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;

    char *pass[3];

    pass[0] = argv[0];

    pass[1] = "-o";

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

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

    return res;

}

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

// init

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

//

void TestVideoSortFilterProxyModel::init()

{

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

    QVERIFY(mTestObject);

    mStubModel = new VideoListDataModel();

    QVERIFY(mStubModel);  

    mCollectionClient = new VideoCollectionClient();

    QVERIFY(mCollectionClient);

}

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

// cleanup

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

//

void TestVideoSortFilterProxyModel::cleanup()

{

	delete mCollectionClient;

	mCollectionClient = 0;

	delete mStubModel;

    mStubModel = 0;

    delete mTestObject;

    mTestObject = 0;

}

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

// testInitialize

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

//

void TestVideoSortFilterProxyModel::testInitialize()

{

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

}

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

// testInitializeSignalConnectFail

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

//

void TestVideoSortFilterProxyModel::testInitializeSignalConnectFail()

{	

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

}

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

// testInitializeDataModelInitFail

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

//

void TestVideoSortFilterProxyModel::testInitializeDataModelInitFail()

{

	VideoListDataModel::mInitFails = true; 

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

}

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

// testInitializeCollectionInitFail

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

//

void TestVideoSortFilterProxyModel::testInitializeCollectionInitFail()

{

	VideoCollectionClient::mFailInit = true; 

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

}

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

// testSecondInitialize

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

//

void TestVideoSortFilterProxyModel::testSecondInitialize()

{

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

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

}

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

// testSecondInitializeModelInitFail

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

//

void TestVideoSortFilterProxyModel::testSecondInitializeModelInitFail()

{

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

	VideoListDataModel::mInitFails = true; 

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

}

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

// testOpen

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

//

void TestVideoSortFilterProxyModel::testOpen()

{

	// 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()

{

    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

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

	mStubModel->setUsedRowCount(5);

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

    QModelIndexList list;

    QModelIndex index; 

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

    {

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

        list.append(index);

    }

    QModelIndexList emptyList;

	User::Heap().__DbgMarkStart();

    VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;

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

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

	QVERIFY(mStubModel->mLastDeletedIndexRow == 0);

	QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 2);

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testDeleteItemsModelNull

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

//

void TestVideoSortFilterProxyModel::testDeleteItemsModelNull()

{

	mStubModel->appendData("Test");

	mStubModel->setUsedRowCount(1);

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

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

	QModelIndexList list;

	list.append(index);	

	User::Heap().__DbgMarkStart();

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

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testDeleteItemsRemoveRowsFail

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

//

void TestVideoSortFilterProxyModel::testDeleteItemsRemoveRowsFail()

{

	VideoListDataModel::mRemoveRowsFails = true;

	mStubModel->appendData("Test");

	mStubModel->setUsedRowCount(1);

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

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

	QModelIndexList list;

	list.append(index);

	User::Heap().__DbgMarkStart();

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

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testOpenItem

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

//

void TestVideoSortFilterProxyModel::testOpenItem()

{	

	mStubModel->appendData("Test");

	mStubModel->setUsedRowCount(1);

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

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

	User::Heap().__DbgMarkStart();

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

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testOpenItemGetMediaIdFail

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

//

void TestVideoSortFilterProxyModel::testOpenItemGetMediaIdFail()

{

	VideoListDataModel::mGetMediaIdAtIndexFails = true;

	mStubModel->appendData("Test");

	mStubModel->setUsedRowCount(1);

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

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

	User::Heap().__DbgMarkStart();

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

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testOpenItemModelNull

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

//

void TestVideoSortFilterProxyModel::testOpenItemModelNull()

{	

	mStubModel->appendData("Test");

	mStubModel->setUsedRowCount(1);

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

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

	User::Heap().__DbgMarkStart();

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

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testOpenItemOpenVideoFails

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

//

void TestVideoSortFilterProxyModel::testOpenItemOpenVideoFails()

{

	VideoCollectionClient::mFailMediaPlayback = true;

	mStubModel->appendData("Test");

	mStubModel->setUsedRowCount(1);

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

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

	User::Heap().__DbgMarkStart();

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

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testBack

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

//

void TestVideoSortFilterProxyModel::testBack()

{	

	//mStubModel->appendData("Test");

	//mStubModel->setUsedRowCount(1);

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

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

	User::Heap().__DbgMarkStart();

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

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testBack

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

//

void TestVideoSortFilterProxyModel::testBackClientNull()

{	

	//mStubModel->appendData("Test");

	//mStubModel->setUsedRowCount(1);

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

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

	VideoCollectionClient *tmpCollectionClient = mTestObject->getClient();

	mTestObject->setClient(0);

	User::Heap().__DbgMarkStart();

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

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

	mTestObject->setClient(tmpCollectionClient);

}

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

// testFetchItemDetails

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

//

void TestVideoSortFilterProxyModel::testFetchItemDetails()

{

	mStubModel->appendData("Test");

	mStubModel->setUsedRowCount(1);

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

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

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

	QList<QVariant> arguments;

	User::Heap().__DbgMarkStart();

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

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

	arguments = fetchSpy.takeFirst();

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

	arguments.clear();

	fetchSpy.clear();

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testFetchItemDetails

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

//

void TestVideoSortFilterProxyModel::testFetchItemDetailsGetMediaIdFail()

{

	VideoListDataModel::mGetMediaIdAtIndexFails = true;

	mStubModel->appendData("Test");

	mStubModel->setUsedRowCount(1);

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

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

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

	User::Heap().__DbgMarkStart();

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

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

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testFetchItemDetails

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

//

void TestVideoSortFilterProxyModel::testFetchItemDetailsGetVideoDetailsFails()

{

	VideoCollectionClient::mFailMediaDetails = true;

	mStubModel->appendData("Test");

	mStubModel->setUsedRowCount(1);

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

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

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

	User::Heap().__DbgMarkStart();

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

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

	int remHeap = User::Heap().__DbgMarkEnd(0);

	QVERIFY(remHeap == 0);

}

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

// testLessThanProxyModelNotInitialized

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

//

void TestVideoSortFilterProxyModel::testLessThanProxyModelNotInitialized()

{

	QVERIFY(mTestObject->initialize(mStubModel) == 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

    mStubModel->setUsedRowCount(5);

    mTestObject->setSortRole(Qt::DisplayRole);

    User::Heap().__DbgMarkStart();  

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

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

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

    int remHeap = User::Heap().__DbgMarkEnd(0);

    QVERIFY(remHeap == 0);

}

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

// testLessThanName

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

//

void TestVideoSortFilterProxyModel::testLessThanName()

{

	QVERIFY(mTestObject->initialize(mStubModel) == 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

    mStubModel->setUsedRowCount(5);

    mTestObject->setSortRole(Qt::DisplayRole);

    User::Heap().__DbgMarkStart();  

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

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

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