/*

* 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:  Testclas for testing VideoListDataModel class methods*

*/

#include <QObject>

#include <qabstractitemmodel.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediaarray.h>

#include <mpxmedia.h>

#include "videocollectioncommon.h"

#include "videodeleteworker.h"

#include "videocollectionclient.h"

#include "videolistdatamodel_p.h"

#include "videocollectionwrapper.h"

#include "testvideolistdatamodel.h"

#include "mediaobjectfactory.h"

#include "videocollectioncommon.h"

#define private public

#include "videolistdatamodel.h"

#undef private

const int MEDIA_COUNT = 10;

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

// main

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

//

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

{

    Q_UNUSED(argc);

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

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

    }

    return res;

}

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

// initTestCase

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

//

void TestVideoListDataModel::initTestCase()

{

    mMediaFactory = new MediaObjectFactory();

}

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

// init

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

//

void TestVideoListDataModel::init()

{

    QVERIFY2(initializeTestObjects(), "making sure if testable object creation ok");  

}

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

// cleanup

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

//   

void TestVideoListDataModel::cleanup()

{

    cleanupTestObjects();

}

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

// cleanupTestCase

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

//

void TestVideoListDataModel::cleanupTestCase()

{

    delete mMediaFactory;

}

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

// testInitializeFails

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

//

void TestVideoListDataModel::testConstructor()

{

    QObject *parent = new QObject();

    delete mTestObjectNotInitialized;

    mTestObjectNotInitialized = new VideoListDataModel(parent);

    QVERIFY( mTestObjectNotInitialized->QObject::parent() == parent );

    QVERIFY( mTestObjectNotInitialized->mCollectionClient == 0);

    QVERIFY( mTestObjectNotInitialized->d_ptr != 0);

    delete parent; // also deletes the test object;

    mTestObjectNotInitialized = 0;

}

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

// testInitializeFails

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

//

void TestVideoListDataModel::testInitializeFails()

{

    // Test all possible failures in the initialisation -call

    // NOTE: signal connecting or new operator failures cannot be tested

    // - collection client init fails

    VideoCollectionClient::mFailInitialize = true;

    QVERIFY(mTestObjectNotInitialized->initialize() == -1 );

    VideoCollectionClient::mFailInitialize = false;

    // - private impl init fails

    VideoListDataModelPrivate::mFailInit = true;

    QVERIFY( mTestObjectNotInitialized->initialize() == -1 );

}

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

// testInitialize

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

//

void TestVideoListDataModel::testInitialize()

{

    VideoListDataModelPrivate::mFailInit = false;

    VideoCollectionClient::mFailInitialize = false;

    VideoCollectionClient::mFailConnectSignals = false;

    VideoCollectionClient::mInitializeCount = 0;

    VideoDeleteWorker::mCreateCount = 0;

    QVERIFY(mTestObjectNotInitialized->initialize() == 0);

    // second call should succeed right away

    QVERIFY(mTestObjectNotInitialized->initialize() == 0);

    QVERIFY(mTestObjectNotInitialized->getCollectionClient() != 0);

    // for the coverity, cannot be verified, because cannot get count from

    // connected signals runtime

    mTestObjectNotInitialized->d_ptr->callModelDisconnect();

    QVERIFY(VideoCollectionClient::mInitializeCount == 1);

    QVERIFY(VideoDeleteWorker::mCreateCount == 1);

}

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

// testRowCount

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

//

void TestVideoListDataModel::testRowCount()

{

    // Test to make sure model queries correct amount of items

    // - at beginning row count should be 0

    // - create defined amount of items

    // - call rowCount to get matching count

    mMediaFactory->removeArray();  

    // row count with invalid parent and zero -array should be 0

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

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());

    // check row count is ok

    QVERIFY( mTestObjectInitialized->rowCount() == MEDIA_COUNT);

    // with valid parent: according to Qt documentation if parent is valid rowCount should return 0

    QModelIndex validIndex = mTestObjectInitialized->index(0,0);

    QVERIFY( mTestObjectInitialized->rowCount(validIndex) == 0);

    mMediaFactory->removeArray();

}

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

// testMediaIdAtIndex

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

//

void TestVideoListDataModel::testMediaIdAtIndex() 

{

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    // ownership of media-array transferred

    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());

    // invalid index: below bounds

    QVERIFY(mTestObjectInitialized->mediaIdAtIndex(-1) == TMPXItemId::InvalidId());

    //invalid index: above bounds

    QVERIFY(mTestObjectInitialized->mediaIdAtIndex(MEDIA_COUNT) == TMPXItemId::InvalidId());

    // first

    QVERIFY(mTestObjectInitialized->mediaIdAtIndex(0).iId1 == 0);

    // middle

    QVERIFY(mTestObjectInitialized->mediaIdAtIndex(MEDIA_COUNT / 2).iId1 == (MEDIA_COUNT / 2));

    // last

    QVERIFY(mTestObjectInitialized->mediaIdAtIndex(MEDIA_COUNT - 1).iId1 == (MEDIA_COUNT - 1));

    // no items

    mMediaFactory->removeArray();

    mTestObjectInitialized->d_ptr->newVideoListSlot(0);

    QVERIFY( mTestObjectInitialized->mediaIdAtIndex(MEDIA_COUNT / 2) == TMPXItemId::InvalidId());

}

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

// testIndexOfId

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

//

void TestVideoListDataModel::testIndexOfId()

{

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    // ownership of media-array transferred

    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());

    QModelIndex index;

    // invalid id

    TMPXItemId id = TMPXItemId::InvalidId();

    index = mTestObjectInitialized->indexOfId(id);

    QVERIFY(!index.isValid());

    //invalid index: does not exists

    id = TMPXItemId(MEDIA_COUNT, 0);

    index = mTestObjectInitialized->indexOfId(id);

    QVERIFY(!index.isValid());

    // existing

    id = TMPXItemId(0, 0);

    index = mTestObjectInitialized->indexOfId(id);

    QVERIFY(index.isValid());

    QVERIFY(index.row() == 0);

    id = TMPXItemId(MEDIA_COUNT / 2, 0);

    index = mTestObjectInitialized->indexOfId(id);

    QVERIFY(index.isValid());

    QVERIFY(index.row() == MEDIA_COUNT / 2);

    id = TMPXItemId(MEDIA_COUNT - 1, 0);

    index = mTestObjectInitialized->indexOfId(id);

    QVERIFY(index.isValid());

    QVERIFY(index.row() == MEDIA_COUNT - 1);

}

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

// testMediaFilePathForId

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

//

void TestVideoListDataModel::testMediaFilePathForId() 

{

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    // ownership of media-array transferred

    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());

    TMPXItemId id;

    // invalid id

    QVERIFY(mTestObjectInitialized->mediaFilePathForId( TMPXItemId::InvalidId()) == "");

    // first

    id.iId1 = 0;

    id.iId2 = 0;

    QVERIFY(mTestObjectInitialized->mediaFilePathForId(id) == 

        QString(gQTMediaNamePrefix + QString::number(id.iId1)));

    // middle

    id.iId1 = MEDIA_COUNT / 2;

    id.iId2 = 0;

    QVERIFY(mTestObjectInitialized->mediaFilePathForId(id) == 

        QString(gQTMediaNamePrefix + QString::number(id.iId1)));

    // last

    id.iId1 = MEDIA_COUNT - 1;

    id.iId2 = 0;

    QVERIFY(mTestObjectInitialized->mediaFilePathForId(id) == 

        QString(gQTMediaNamePrefix + QString::number(id.iId1)));

    // no items

    mMediaFactory->removeArray();

    id.iId1 = MEDIA_COUNT / 2;

    id.iId2 = 0;

    mTestObjectInitialized->d_ptr->newVideoListSlot(0);

    QVERIFY( mTestObjectInitialized->mediaFilePathForId(id) == "" );

}

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

// testItemData

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

//

void TestVideoListDataModel::testItemData()

{

    // Test to make sure item data is passed ok throught model

    // - create defined amount of items

    // - setup their data as predefined values

    // - call item data to make sure data is passed ok from the model

    // Qt::DisplayRole

    // Qt::DecorationRole

    // Qt::BackgroundRole

    QModelIndex index;

    QMap<int, QVariant> mapData;

    VideoListDataModelPrivate::mFailInit = false;

    mMediaFactory->removeArray();

    mTestObjectInitialized->d_ptr->newVideoListSlot(0);

    // no items

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

    mapData = mTestObjectInitialized->itemData(index);

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

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());

    // below index bounds, should not even get correct index

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

    QVERIFY(!index.isValid());

    mapData = mTestObjectInitialized->itemData(index);

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

    // above index bounds, should not even get correct index

    index = mTestObjectInitialized->index(MEDIA_COUNT, 0, QModelIndex());

    QVERIFY(!index.isValid());

    mapData = mTestObjectInitialized->itemData(index);

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

    // first

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

    QVERIFY(index.isValid());

    mapData = mTestObjectInitialized->itemData(index);

    QVERIFY(mapData.count() == 3);

    // middle

    index = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0, QModelIndex());

    QVERIFY(index.isValid());

    mapData = mTestObjectInitialized->itemData(index);

    QVERIFY(mapData.count() == 3);

    // last

    index = mTestObjectInitialized->index(MEDIA_COUNT - 1, 0, QModelIndex());

    QVERIFY(index.isValid());

    mapData = mTestObjectInitialized->itemData(index);

    QVERIFY(mapData.count() == 3);

}

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

// testData

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

//

void TestVideoListDataModel::testData()

{

    VideoListDataModelPrivate::mFailInit = false;

    mMediaFactory->removeArray();

    const int TEST_INDEX = 3;

    mMediaFactory->createMediaItems(TEST_INDEX + 1);

    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());

    QModelIndex index = QModelIndex();

    QVariant data;

    // test with invalid QModelIndex

    data = mTestObjectInitialized->data(index, Qt::DisplayRole);

    QVERIFY(data.toStringList().count() == 0);

    // test with correct data

    index = mTestObjectInitialized->index(TEST_INDEX,0, QModelIndex());

    data = mTestObjectInitialized->data(index, Qt::DisplayRole);

    QVERIFY(data.toStringList().count() == 2);

    QVERIFY(data.toStringList().at(0) == QString(gQTMediaNamePrefix + QString::number(TEST_INDEX)));

    data.clear();

    data = mTestObjectInitialized->data(index, Qt::DecorationRole);

    QVERIFY(data.isValid());

    data.clear();

    data = mTestObjectInitialized->data(index, Qt::BackgroundRole); 

    // at the moment we do not have background role -data, when it becomes available,

    // this will fail and needs to be changed

    QVERIFY(!data.isValid());

    data.clear();

    QDate date = QDate(2009, TEST_INDEX+1, TEST_INDEX+1);

    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyDateTime); 

    QCOMPARE(data.toDate(), date);

    data.clear();

    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeySizeValue); 

    QVERIFY(data.toUInt() == (1+TEST_INDEX));

    data.clear();

    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyStatus); 

    QVERIFY(data.toInt() == VideoCollectionCommon::StatusNone);

    data.clear();

    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyFilePath); 

    QCOMPARE(data.toString(), gQTMediaFilePathPrefix + QString::number(TEST_INDEX));

    // invalid role

    data.clear();

    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyLast); 

    QVERIFY(!data.isValid());

    // test with incorrect (== missing details) data

    mMediaFactory->removeArray();

    mMediaFactory->createMediaItems(TEST_INDEX + 1, 0, MediaDetailNone);

    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());

    data.clear();

    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyDateTime); 

    QVERIFY(!data.toDateTime().isValid());

    data.clear();

    data = mTestObjectInitialized->data(index, VideoCollectionCommon::KeyFilePath);

    QVERIFY(!data.toString().length());

}

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

// testColumnCount

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

//

void TestVideoListDataModel::testColumnCount()

{

    mMediaFactory->removeArray();

    const int TEST_INDEX = 3;

    // test with correct data

    mMediaFactory->createMediaItems(1);

    QModelIndex index = QModelIndex();

    // test with invalid "parent" index

    QVERIFY(mTestObjectInitialized->columnCount(index) == 1);

    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());

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

    // test with valid "parent index

    QVERIFY(mTestObjectInitialized->columnCount(index) == 0);

}

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

// testIndex

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

//

void TestVideoListDataModel::testIndex()

{

    QModelIndex indexToGet;

    mMediaFactory->removeArray();

    mTestObjectInitialized->d_ptr->newVideoListSlot(0);

    mMediaFactory->createMediaItems(MEDIA_COUNT);

    mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());

    // index below bounds

    indexToGet = mTestObjectInitialized->index(-1, 0);

    QVERIFY(!indexToGet.isValid()); 

    // index above bounds

    indexToGet = mTestObjectInitialized->index(MEDIA_COUNT, 0);

    QVERIFY(!indexToGet.isValid()); 

    // first

    indexToGet = mTestObjectInitialized->index(0, 0);

    QVERIFY(indexToGet.isValid()); 

    QVERIFY(indexToGet.row() == 0); 

    // middle

    indexToGet = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);

    QVERIFY(indexToGet.isValid()); 

    QVERIFY(indexToGet.row() == (MEDIA_COUNT / 2)); 

    // last

    indexToGet = mTestObjectInitialized->index(MEDIA_COUNT - 1, 0);

    QVERIFY(indexToGet.isValid()); 

    QVERIFY(indexToGet.row() == (MEDIA_COUNT -1)); 

}

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

// testParent

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

//

void TestVideoListDataModel::testParent()

{