/**

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

*

*/

#include <qmap.h>

#include <vcxmyvideosdefs.h>

#include <mpxhbvideocommondefs.h>

#include "hbglobal.h"

#include "hblistview.h"

#include "hbview.h"

#include "videosortfilterproxymodel.h"

#include "hbscrollbar.h"

#include "hbmenu.h"

#include "hbmessagebox.h"

#include "hbinstance.h"

#include "hbmainwindow.h"

#include "hbstyleloader.h"

#include "hbinputdialog.h"

#include "videothumbnaildata.h"

#include "videocollectioncommon.h"

#include "videocollectionwrapper.h"

#include "videocollectionwrapperdata.h"

#include "hbmenudata.h"

#include "videothumbnailtestdata.h"

#include "videolistdatamodel.h"

#include "videolistdatamodeldata.h"

#include "videosortfilterproxymodeldata.h"

#include "videocollectionuiloader.h"

#include "videocollectionuiloaderdata.h"

#include "videolistselectiondialog.h"

#include "videolistselectiondialogdata.h"

#include "hbmessageboxdata.h"

#include "testlistwidget.h"

#define private public

#include "videolistwidget.h"

#include "videoservices.h"

#undef private

static const int CONTEXT_MENU_COUNT = 8;

/**

 * helper class to run protected member of the test object

 */

class ListWidgetTester : public VideoListWidget

{

public:

    /**

     * constructor

     */

    ListWidgetTester(VideoCollectionUiLoader* uiLoader, HbView *parent) :

            VideoListWidget(uiLoader, parent)

    {

    }

    /**

     * calls emitActivated

     */

    void callEmiteActivated(QModelIndex index)

    {

        VideoListWidget::emitActivated(index);

    }

    /**

     * calls longPressedSlot

     */

    void callLongPressedSlot(HbAbstractViewItem *item, const QPointF &point)

    {

        VideoListWidget::longPressedSlot(item, point);

    }

};

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

// main

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

//

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

{

    TestListWidget tv;

    QApplication app(argc, argv);

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

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

    }

    return res;

}

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

// setRowCount

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

//

void TestListWidget::setRowCount(int count,

    VideoCollectionCommon::TModelType type,

    VideoListDataModel *model)

{

    if (!model)

    {

        VideoCollectionWrapper &wrapper = VideoCollectionWrapper::instance();

        VideoSortFilterProxyModel *model = wrapper.getModel(type);

        QVERIFY(model);

        VideoListDataModel *sourceModel = qobject_cast<VideoListDataModel*>(model->sourceModel());

        QVERIFY(sourceModel);

        VideoListDataModelData::setRowCount(*sourceModel, count);

        sourceModel->initialize();

    }

    else

    {

        VideoListDataModelData::setRowCount(*model, count);

        model->initialize();

    }

}

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

// initTestCase

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

//

void TestListWidget::initTestCase()

{

    qRegisterMetaType<QModelIndex>("QModelIndex");

}

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

// init

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

//

void TestListWidget::init()

{

    mDummyMainWnd = new HbMainWindow;

    mTempView = new HbView;

    mTestUiLoader = new VideoCollectionUiLoader();

    hbInstance->mWindowses.append(mDummyMainWnd);

    mTestWidget = new ListWidgetTester(mTestUiLoader, mTempView);

}

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

// cleanup

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

//

void TestListWidget::cleanup()

{

    delete mTestWidget;

    mTestWidget = 0;

    delete mTempView;

    mTempView = 0;

    delete mDummyMainWnd;

    mDummyMainWnd = 0;

    hbInstance->mWindowses.clear();

    VideoCollectionWrapperData::reset();

    HbMenuData::reset();

    VideoThumbnailTestData::reset();

    VideoListDataModelData::reset();

    VideoSortFilterProxyModelData::reset();

    HbMessageBoxData::reset();

}

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

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

//

void TestListWidget::testInitialize()

{

    VideoCollectionWrapper &wrapper = VideoCollectionWrapper::instance();

    VideoSortFilterProxyModel *model = wrapper.getModel(VideoCollectionCommon::EModelTypeAllVideos);

    // succeed case ( new operator cannot be stubbed)

    QVERIFY(mTestWidget->initialize(*model) == 0);

	QVERIFY(mTestWidget->mModel == model);  

	QVERIFY(mTestWidget->mVideoServices == 0);

	// service initialization

	VideoServices *service = VideoServices::instance();

    QVERIFY(mTestWidget->mModel == model);  

    QVERIFY(mTestWidget->mVideoServices == service);

    service->decreaseReferenceCount();

    service = 0;

}

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

// testActivate

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

//

void TestListWidget::testActivate()

{

    VideoCollectionWrapper &wrapper = VideoCollectionWrapper::instance();

    VideoSortFilterProxyModel *model = wrapper.getModel(VideoCollectionCommon::EModelTypeAllVideos);

    // no  model: fails

    QVERIFY(mTestWidget->activate() == -1);

    QCOMPARE(HbMenuData::mEnabledSetted, false);

    QCOMPARE(HbListView::mLatestVisibility, false);

    QCOMPARE(VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled, 0);

    QVERIFY(mTestWidget->initialize(*model) == 0);

    QCOMPARE(HbMenuData::mEnabledSetted, false);

    HbMenuData::mEnabledSetted = true;

    HbListView::mLatestVisibility = false;

    HbListView::mLatestEnableValue = false;

    VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled = 0;

    // model exists, current view exists, level neither ELevelAlbum nor ELevelDefaultColl 

    hbInstance->allMainWindows().value(0)->addView(tmpView);

    QVERIFY(mTestWidget->activate() == 0);

    QCOMPARE(HbMenuData::mEnabledSetted, true);

    QCOMPARE(HbListView::mLatestVisibility, true);

    QCOMPARE(VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled, 1);

    QVERIFY(mTestWidget->mNavKeyAction);

    QVERIFY(HbAction::mNavAction == Hb::QuitAction);

    HbMenuData::mEnabledSetted = true;

    HbListView::mLatestVisibility = false;

    HbListView::mLatestEnableValue = false;

    VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled = 0;

    // model exists, current view exists, level is ELevelAlbum

    delete mTestWidget;

    mTestWidget = 0;

    mTestWidget = new ListWidgetTester(mTestUiLoader, mTempView);

    model = wrapper.getModel(VideoCollectionCommon::EModelTypeCollectionContent);

    tmpView->mNavigationAction = 0;

    QVERIFY(mTestWidget->initialize(*model) == 0);

    QVERIFY(mTestWidget->activate(VideoCollectionCommon::ELevelAlbum) == 0);

    QCOMPARE(HbMenuData::mEnabledSetted, true);

    QCOMPARE(HbListView::mLatestVisibility, true);

    QCOMPARE(VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled, 1);

    QVERIFY(mTestWidget->mNavKeyAction);

    QVERIFY(HbAction::mNavAction == Hb::BackAction);

    HbMenuData::mEnabledSetted = true;

    HbListView::mLatestVisibility = false;

    HbListView::mLatestEnableValue = false;

    VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled = 0;

    // activate:

    // -is service

    // -current service is browse

    videoServices->mCurrentService = VideoServices::EBrowse;

    delete mTestWidget;

    mTestWidget = 0;

    mTestWidget = new ListWidgetTester(mTestUiLoader, mTempView);

    QVERIFY(mTestWidget->mNavKeyAction);

    QVERIFY(HbAction::mNavAction == Hb::QuitAction);

    hbInstance->allMainWindows().value(0)->removeView(tmpView);

    delete tmpView;

    // final cleanup

    videoServices->mCurrentService = VideoServices::ENoService;

    videoServices->decreaseReferenceCount();

}

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

// testDeactivate

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

//

void TestListWidget::testDeactivate()

{

    VideoCollectionWrapper &wrapper = VideoCollectionWrapper::instance();

    VideoSortFilterProxyModel *model = wrapper.getModel(VideoCollectionCommon::EModelTypeAllVideos);

    HbListView::mLatestVisibility = true;

    VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled = 1;

    mTestWidget->activate();

    // no context menu and activated without model

    mTestWidget->deactivate();

    QCOMPARE(HbListView::mLatestVisibility, false);

    QCOMPARE(VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled, 0);

    HbListView::mLatestVisibility = true;

    VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled = 1;

    // context menu exists and activated with model

    mTestWidget->mContextMenu = new HbMenu;

    QVERIFY(mTestWidget->initialize(*model) == 0);

    mTestWidget->activate();

    mTestWidget->deactivate();

    QCOMPARE(HbListView::mLatestVisibility, false);

    QCOMPARE(VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled, 0);

    // deactivate:

    // -is service

    // -current service is browse

    VideoServices *videoServices = VideoServices::instance();

    videoServices->mCurrentService = VideoServices::EBrowse;

    delete mTestWidget;

    mTestWidget = 0;

    mTestWidget = new ListWidgetTester(mTestUiLoader, mTempView);

    QVERIFY(mTestWidget->initialize(*model, videoServices) == 0);

    QVERIFY(mTestWidget->activate(VideoCollectionCommon::ELevelDefaultColl) == 0);

    mTestWidget->deactivate();

    QCOMPARE(HbListView::mLatestVisibility, false);

    QCOMPARE(VideoThumbnailTestData::mBackgroundThumbnailFetchingEnabled, 0);

    // final cleanup

    videoServices->mCurrentService = VideoServices::ENoService;

    videoServices->decreaseReferenceCount();

}

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

// testGetLevel

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

//

void TestListWidget::testGetLevel()

{

    VideoCollectionWrapper &wrapper = VideoCollectionWrapper::instance();

    VideoSortFilterProxyModel *model = wrapper.getModel(VideoCollectionCommon::EModelTypeAllVideos);

    mTestWidget->initialize(*model);

    mTestWidget->mCurrentLevel = VideoCollectionCommon::ELevelVideos;

    QCOMPARE(mTestWidget->getLevel(), VideoCollectionCommon::ELevelVideos);

}

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

// testGetModel

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

//

void TestListWidget::testGetModel()

{

    VideoCollectionWrapper &wrapper = VideoCollectionWrapper::instance();

    VideoSortFilterProxyModel *model = wrapper.getModel(VideoCollectionCommon::EModelTypeAllVideos);

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

    HbListView::mVScrollBarIsNull = false;

    HbListView::mReturnNullPrototype = false;

    mTestWidget->initialize(*model);

    QVERIFY(mTestWidget->getModel() == model);

}

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

// testEmitActivated

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

//

void TestListWidget::testEmitActivated()

{

    VideoServices *videoServices = VideoServices::instance();

    VideoCollectionWrapper &wrapper = VideoCollectionWrapper::instance();

    VideoSortFilterProxyModel *model = wrapper.getModel(VideoCollectionCommon::EModelTypeAllVideos);

    QSignalSpy spysignalFileUri(mTestWidget, SIGNAL(fileUri(const QString&)));

    QSignalSpy spysignalActivated(mTestWidget, SIGNAL(activated(const QModelIndex&)));

    mTestWidget->initialize(*model);

    mTestWidget->activate();

    VideoSortFilterProxyModelData::mLastItemId = TMPXItemId::InvalidId();

    TMPXItemId savedId = TMPXItemId(1,1);

    VideoSortFilterProxyModelData::mItemIds.clear();

    VideoSortFilterProxyModelData::mItemIds.append(savedId);

    QVariant data = QString("test");

    VideoListDataModelData::setData(VideoCollectionCommon::KeyTitle, data);

    setRowCount(2);

    VideoSortFilterProxyModelData::mItemIds.append(TMPXItemId(0,0));

    QModelIndex fetchIndex = model->index(0, 0, QModelIndex());

    // selection mode == HbAbstractItemView::MultiSelection

    mTestWidget->setSelectionMode(HbAbstractItemView::MultiSelection);

    mTestWidget->callEmiteActivated(fetchIndex);

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

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

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

    QVERIFY(VideoSortFilterProxyModelData::mLastItemId == TMPXItemId::InvalidId());

    spysignal.clear();

    spysignalFileUri.clear();

    spysignalActivated.clear();

    // modelIndex is not valid

    mTestWidget->setSelectionMode(HbAbstractItemView::NoSelection);

    fetchIndex = QModelIndex();

    mTestWidget->callEmiteActivated(fetchIndex);

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

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

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

    QVERIFY(VideoSortFilterProxyModelData::mLastItemId == TMPXItemId::InvalidId());

    // current level is ELevelCategory

    mTestWidget->mCurrentLevel = VideoCollectionCommon::ELevelCategory;

    // --> variant is not valid 

    VideoListDataModelData::setData(VideoCollectionCommon::KeyTitle, QVariant());

    fetchIndex = model->index(0, 0, QModelIndex());

    mTestWidget->callEmiteActivated(fetchIndex);

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

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

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

    QVERIFY(VideoSortFilterProxyModelData::mLastItemId == TMPXItemId::InvalidId());

    // --> variant is valid, collectionOpened -signal should be emitted

    VideoListDataModelData::setData(VideoCollectionCommon::KeyTitle, data);

    fetchIndex = model->index(1, 0, QModelIndex());

    mTestWidget->callEmiteActivated(fetchIndex);

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

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

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

    QVERIFY(VideoSortFilterProxyModelData::mLastItemId == TMPXItemId::InvalidId());

    spysignal.clear();

    spysignalFileUri.clear();

    spysignalActivated.clear();

    // current level is not ELevelCategory

    mTestWidget->mService = VideoServices::EUriFetcher;

    VideoListDataModelData::setData(VideoCollectionCommon::KeyTitle, QVariant());

    mTestWidget->mCurrentLevel = VideoCollectionCommon::ELevelVideos;

    mTestWidget->mVideoServices = videoServices;

    fetchIndex = model->index(5, 0, QModelIndex());

    mTestWidget->callEmiteActivated(fetchIndex);

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

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

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

    QVERIFY(VideoSortFilterProxyModelData::mLastItemId == TMPXItemId::InvalidId());

    // current level is not ELevelCategory