/*

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

*

*/

#include "unittest_mediamodel.h"

#include "glxmediamodel.h"

#include "glxmlwrapper.h"

#include "glxmodelparm.h"

#include "glxcollectionpluginall.hrh"

#include "hbicon.h"

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

// initTestCase

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

//

void TestGlxMediaModel::initTestCase()

{    

    GlxModelParm modelParm;

    modelParm.setCollection( KGlxCollectionPluginAllImplementationUid );

    modelParm.setDepth(0);

    modelParm.setContextMode( GlxContextLsGrid ) ;

    mModel = new GlxMediaModel( modelParm );

    QTest::qWait(2000);

    QVERIFY( mModel );

    QVERIFY( mModel->mMLWrapper );

    QVERIFY( mModel->mDRMUtilityWrapper );

    QVERIFY( mModel->m_DefaultIcon );

    QVERIFY( mModel->m_CorruptIcon );

    QCOMPARE( mModel->thumbnailPopulatedFlag, false );

    QCOMPARE( mModel->mPaintPage, true );

}

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

// init

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

//

void TestGlxMediaModel::init()

{

}

void TestGlxMediaModel::rowCountTestCase()

{

    QVERIFY( mModel->rowCount() >= 0 );

}

void TestGlxMediaModel::columnCountTestCase()

{

    QCOMPARE( mModel->columnCount(), 1 );

}

void TestGlxMediaModel::parentTestCase()

{

    QModelIndex index = mModel->parent( mModel->index( 0, 0 ) );

    QCOMPARE( index.isValid(), false);

}

void TestGlxMediaModel::itemImageDataInvalidIndexTestCase()

{

    QVariant variant = mModel->itemImageData( QModelIndex(), GlxFsImageRole );

    QCOMPARE( variant.isValid(), false );

    variant = mModel->itemImageData( mModel->createIndex( mModel->rowCount(), 0 ), GlxFsImageRole );

    QCOMPARE( variant.isValid(), false );

}

void TestGlxMediaModel::itemImageDataGridImagetestCase()

{

    mModel->itemIconCache.insert( 0, NULL );

    QVariant variant = mModel->itemImageData( mModel->index( 0, 0), Qt::DecorationRole );

    QCOMPARE( variant.isValid(), true );

    mModel->itemIconCache.insert( 0, new HbIcon() );

    variant = mModel->itemImageData( mModel->index( 0, 0), Qt::DecorationRole );

    QCOMPARE( variant.isValid(), true );

}

void TestGlxMediaModel::itemImageDataHdmiBitmapTestCase()

{

    QVariant variant = mModel->itemImageData( mModel->index( 0, 0), GlxHdmiBitmap );

    QCOMPARE( variant.isValid(), true );

}

void TestGlxMediaModel::ItemPropertyViewTitleTestCase()

{

   QVariant variant = mModel->collectionProperty( GlxViewTitle );

   QCOMPARE( variant.isValid(), true );

}

void TestGlxMediaModel::ItemPropertyImageTitleTestCase()

{

   QVariant variant = mModel->collectionProperty( GlxImageTitle );

   QCOMPARE( variant.isValid(), false );

}

void TestGlxMediaModel::ItemPropertyDateTestCase()

{

   QVariant variant = mModel->collectionProperty( GlxDateRole );

   QCOMPARE( variant.isValid(), false );

}

void TestGlxMediaModel::ItemPropertyCorruptImageTestCase()

{

   QVariant variant = mModel->collectionProperty( GlxImageCorruptRole );

   QCOMPARE( variant.isValid(), false );

}

void TestGlxMediaModel::ItemPropertyTimeTestCase()

{

   QVariant variant = mModel->collectionProperty( GlxTimeRole );

   QCOMPARE( variant.isValid(), false );

}

void TestGlxMediaModel::ItemPropertySizeTestCase()

{

   QVariant variant = mModel->collectionProperty( GlxSizeRole );

   QCOMPARE( variant.isValid(), false );

}

void TestGlxMediaModel::ItemPropertyDescTestCase()

{

   QVariant variant = mModel->collectionProperty( GlxDescRole );

   QCOMPARE( variant.isValid(), false );

}

void TestGlxMediaModel::indexTestCase()

{

    QModelIndex index = mModel->index( -1, 0 );

    QCOMPARE( index.isValid(), false);

    index = mModel->index( 0, -1 );

    QCOMPARE( index.isValid(), false);

    index = mModel->index( mModel->rowCount(), 1 );

    QCOMPARE( index.isValid(), false);

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

    QCOMPARE( index.isValid(), true);

}

void TestGlxMediaModel::setDataContextRoleTestCase()

{

    mModel->setData( mModel->index( 0, 0 ), GlxContextPtGrid, GlxContextRole );

    QCOMPARE( mModel->mContextMode, GlxContextPtGrid );

    mModel->setData( mModel->index( 0, 0), QVariant( QVariant::Invalid ), GlxContextRole );

    QCOMPARE( mModel->mContextMode, GlxContextPtGrid );

}

void TestGlxMediaModel::setDataRemoveContextRoleTestCase()

{

    mModel->setData( mModel->index( 0, 0), GlxContextPtGrid, GlxContextRole );

    mModel->setData( mModel->index( 0, 0), QVariant( QVariant::Invalid ), GlxRemoveContextRole );

    QCOMPARE( mModel->mContextMode, GlxContextPtGrid );

}

void TestGlxMediaModel::setDataFocusIndexRoleTestCase()

{

    mModel->setData( mModel->index( 0, 0), 1, GlxFocusIndexRole );

    QCOMPARE( mModel->mFocusIndex, 1 );

    mModel->setData( mModel->index( 0, 0), QVariant( QVariant::Invalid ), GlxFocusIndexRole );

    QCOMPARE( mModel->mFocusIndex, 1 );

}

void TestGlxMediaModel::setDataVisualIndexTestCase()

{

    mModel->setData( mModel->index( 0, 0), 1, GlxVisualWindowIndex );

    int visualIndex = mModel->mMLWrapper->getVisibleWindowIndex();

    QCOMPARE( visualIndex, 1 );    

    mModel->setData( mModel->index( 0, 0), QVariant( QVariant::Invalid ), GlxVisualWindowIndex );

    visualIndex = mModel->mMLWrapper->getVisibleWindowIndex();

    QCOMPARE( visualIndex, 1 );    

}

void TestGlxMediaModel::setDataSelectedIndexTestCase()

{

    bool result = mModel->setData( mModel->index( 0, 0), 1, GlxSelectedIndexRole  );

    QCOMPARE( result, true );    

    result = mModel->setData( mModel->index( 0, 0), QVariant( QVariant::Invalid ), GlxSelectedIndexRole );

    QCOMPARE( result, false );  

}

void TestGlxMediaModel::setDataSubStateTestCase()

{

    bool result = mModel->setData( mModel->index( 0, 0), 5, GlxSubStateRole );

    QCOMPARE( result, true );

    QCOMPARE( mModel->mSubState, 5 );

    result = mModel->setData( mModel->index( 0, 0), QVariant( QVariant::Invalid ), GlxSubStateRole  );

    QCOMPARE( result, false );

    QCOMPARE( mModel->mSubState, 5 );

}

void TestGlxMediaModel::setDataTempVisualIndexTestCase()

{

    bool result = mModel->setData( mModel->index( 0, 0), 2, GlxTempVisualWindowIndex );

    QCOMPARE( result, true );

    QCOMPARE( mModel->mTempVisibleWindowIndex,  2 );

    result = mModel->setData( mModel->index( 0, 0), QVariant( QVariant::Invalid ), GlxTempVisualWindowIndex  );

    QCOMPARE( result, false );

    QCOMPARE( mModel->mTempVisibleWindowIndex, 2 );    

}

void TestGlxMediaModel::GetGridIconItemTestCase()

{

    QTest::qWait( 2000 );

    mModel->itemIconCache.insert( 0, NULL );

    HbIcon *icon = mModel->GetGridIconItem( 0, GlxTBContextGrid );

    QVERIFY( icon || icon == NULL );

    mModel->itemIconCache.insert( 0, new HbIcon() );

    icon = mModel->GetGridIconItem( 0, GlxTBContextGrid );

    QVERIFY( icon );

}

void TestGlxMediaModel::GetFsIconItemTestCase()

{

    mModel->setContextMode( GlxContextPtFs );

    HbIcon *icon = mModel->GetFsIconItem( 0, GlxTBContextPtFs );

    QTest::qWait( 2000 );

    QVERIFY( icon || icon == NULL );

    mModel->setContextMode( GlxContextLsGrid );

}

void TestGlxMediaModel::getFullScreenIconTestCase()

{

    HbIcon icon = mModel->getFullScreenIcon( 0 );

    QCOMPARE( icon.isNull(), false );

    mModel->itemIconCache.insert( 0, NULL );

    icon = mModel->getFullScreenIcon( 0 );

    QCOMPARE( icon.isNull(), false );

    mModel->itemIconCache.insert( 0, new HbIcon() );

    icon = mModel->getFullScreenIcon( 0 );

    QCOMPARE( icon.isNull(), false );

}

void TestGlxMediaModel::getFullScreenImagetestCase()

{

    mModel->setContextMode( GlxContextLsFs );

    QTest::qWait( 2000 );

    QImage img = mModel->getFullScreenImage( 0 );

    QVERIFY( img.isNull() == true || img.isNull() == false );

    mModel->setContextMode( GlxContextPtFs );

    QTest::qWait( 2000 );

    img = mModel->getFullScreenImage( 0 );

    QVERIFY( img.isNull() == true || img.isNull() == false );  

}

void TestGlxMediaModel::setContextModeTestCase()

{

    mModel->setContextMode( GlxContextPtFs );

    QCOMPARE( mModel->mContextMode, GlxContextPtFs );

    mModel->setContextMode( GlxContextComment );

    QCOMPARE( mModel->mContextMode, GlxContextPtFs ); 

    mModel->removeContextMode( GlxContextComment );

    mModel->setContextMode( GlxContextLsGrid );

    QCOMPARE( mModel->mContextMode, GlxContextLsGrid );

    QCOMPARE( mModel->itemFsIconCache.size(), 0 );

    QCOMPARE( mModel->itemIconCache.size(), 0 );

}

void TestGlxMediaModel::removeContextModeTestCase()

{

    mModel->removeContextMode( GlxContextComment );

    QCOMPARE( mModel->mContextMode, GlxContextLsGrid );

}

void TestGlxMediaModel::setFocusIndexTestCase()

{

    mModel->setFocusIndex( mModel->index( 1, 0 ) );

    QModelIndex modelIndex = mModel->getFocusIndex();

    QCOMPARE( mModel->mFocusIndex, 1 );

    QCOMPARE( 1, modelIndex.row() );    

    int index = mModel->rowCount() - 1;

    mModel->setFocusIndex( mModel->index( index, 0 ) );

    modelIndex = mModel->getFocusIndex();

    QCOMPARE( mModel->mFocusIndex, modelIndex.row() );

    QCOMPARE( index, modelIndex.row() );

    index = mModel->rowCount();

    mModel->setFocusIndex( mModel->index( index, 0 ) );

    modelIndex = mModel->getFocusIndex();

    QCOMPARE( mModel->mFocusIndex, modelIndex.row() );

    QCOMPARE( 0, modelIndex.row() );    

}

void TestGlxMediaModel::getFocusIndexTestcase()

{

    mModel->mFocusIndex = -1;

    mModel->setFocusIndex( mModel->index( 1, 0 ) );

    QModelIndex index = mModel->getFocusIndex();

    QCOMPARE( 1, index.row() );

    mModel->mFocusIndex = 2;

    mModel->setFocusIndex( mModel->index( 1, 0 ) );

    index = mModel->getFocusIndex();

    QCOMPARE( 1, index.row() );

}

void TestGlxMediaModel::setSelectedIndexTestCase()

{

    mModel->setSelectedIndex( mModel->index( 1, 0 ) );

}

void TestGlxMediaModel::getCorruptDefaultIconTestCase()

{

    HbIcon *icon = mModel->getCorruptDefaultIcon( mModel->index( 0, 0 ) );

    QVERIFY( icon );

}

void TestGlxMediaModel::thumbnailPopulatedCheckTestCase()

{

    mModel->thumbnailPopulatedFlag = false;

    mModel->thumbnailPopulatedCheck( 1 );

    QCOMPARE( mModel->thumbnailPopulatedFlag, false );

    mModel->thumbnailPopulatedCheck( 30 );

    QCOMPARE( mModel->thumbnailPopulatedFlag, true );

}

void TestGlxMediaModel::itemUpdatedTestCase()

{

    mModel->itemUpdated( 0, GlxTBContextGrid );

    QVERIFY( mModel->itemIconCache[0] == NULL );

    mModel->thumbnailPopulatedFlag = false;

    mModel->itemUpdated( 0, GlxTBContextGrid );

    QVERIFY( mModel->itemIconCache[0] == NULL );

    mModel->itemUpdated( 0, GlxTBContextPtFs );

    QVERIFY( mModel->itemFsIconCache[0] == NULL );

    mModel->itemUpdated( 0, GlxTBContextPtFs );

    QVERIFY( mModel->itemFsIconCache[0] == NULL );

}

void TestGlxMediaModel::itemsAddedTestCase()

{

    mModel->itemsAdded( 1, 5 );

    QCOMPARE( mModel->mFocusIndex, -1 );

    QCOMPARE( mModel->itemIconCache.size(), 0 );

    QCOMPARE( mModel->itemFsIconCache.size(), 0 );

}

void TestGlxMediaModel::itemsRemovedTestCase()

{

    mModel->itemsRemoved( 1, 5 );

    QCOMPARE( mModel->mFocusIndex, -1 );

    QCOMPARE( mModel->itemIconCache.size(), 0 );

    QCOMPARE( mModel->itemFsIconCache.size(), 0 );

}

void TestGlxMediaModel::itemCorruptedTestCase()

{

    mModel->thumbnailPopulatedFlag = false;

    mModel->itemCorrupted( 1 );

    QCOMPARE( mModel->thumbnailPopulatedFlag, false );

    mModel->itemCorrupted( 30 );

    QCOMPARE( mModel->thumbnailPopulatedFlag, true );    

}

void TestGlxMediaModel::albumTitleUpdatedTestCase()

{

    mModel->albumTitleUpdated( QString( "Album" ) );

}

void TestGlxMediaModel::modelpopulatedTestCase()

{

    int visualIndex = mModel->mMLWrapper->getVisibleWindowIndex();

    mModel->mTempVisibleWindowIndex = -1;

    mModel->modelpopulated();

    QCOMPARE( mModel->mTempVisibleWindowIndex, -1 );

    QCOMPARE( visualIndex,  mModel->mMLWrapper->getVisibleWindowIndex() );

    mModel->mTempVisibleWindowIndex = mModel->rowCount() - 1;

    mModel->modelpopulated();

    visualIndex = mModel->mMLWrapper->getVisibleWindowIndex();

    QCOMPARE( mModel->mTempVisibleWindowIndex, -1 );

    QCOMPARE( visualIndex, mModel->rowCount() - 1 );

    mModel->mTempVisibleWindowIndex = mModel->rowCount();

    mModel->modelpopulated();

    visualIndex = mModel->mMLWrapper->getVisibleWindowIndex();

    QCOMPARE( mModel->mTempVisibleWindowIndex, -1 );

    QCOMPARE( visualIndex, 0 );

}

void TestGlxMediaModel::updateDetailItemsTestCase()

{

    mModel->updateDetailItems();

}

void TestGlxMediaModel::updateItemIconTestCase()

{

    mModel->updateItemIcon( 1, new HbIcon(), GlxTBContextGrid );

    QVERIFY( mModel->itemIconCache[1] );

    mModel->updateItemIcon( 1, new HbIcon(), GlxTBContextLsFs );

    QVERIFY( mModel->itemFsIconCache[1] );

    mModel->updateItemIcon( 1, new HbIcon(), GlxTBContextPtFs );

    QVERIFY( mModel->itemFsIconCache[1] );  

}

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

// cleanup

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

//

void TestGlxMediaModel::cleanup()

{

}

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

// cleanupTestCase

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

//

void TestGlxMediaModel::cleanupTestCase()

{

    if( mModel ) {        

        delete mModel;

        mModel = 0;

    }  

}

QTEST_MAIN(TestGlxMediaModel)

#include "moc_unittest_mediamodel.cpp"