videocollection/videocollectionwrapper/tsrc/testvideomodel/src/testvideolistdatamodel.cpp
/*
* 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::KeyMetaData);
QMap<QString, QVariant> map = data.toMap();
QVERIFY(map.contains("metadata"));
QCOMPARE(map["metadata"].toString(), QString("metadata"));
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()
{
mMediaFactory->createMediaItems(MEDIA_COUNT);
mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
QModelIndex index = mTestObjectInitialized->index(0,0);
QVERIFY(index.isValid());
QModelIndex parentIndex = mTestObjectInitialized->parent(index);
QVERIFY(!parentIndex.isValid());
}
// -----------------------------------------------------------------------------
// testPrepareDetails
// -----------------------------------------------------------------------------
//
void TestVideoListDataModel::testPrepareDetails()
{
// cannot call preparedetails directly, need to call indirectly using
// public data -method.
QString details("");
QModelIndex modelIndex;
QVariant result;
mMediaFactory->removeArray();
mMediaFactory->createMediaItems(MEDIA_COUNT);
mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
// missing size
mMediaFactory->removeArray();
mMediaFactory->createMediaItems(MEDIA_COUNT, 0, MediaDetailDurationFlag);
mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
details.clear();
modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY (result.toStringList().count() == 2 );
QVERIFY(!result.toStringList().at(1).contains(","));
// missing duration
mMediaFactory->removeArray();
mMediaFactory->createMediaItems(MEDIA_COUNT, 0, MediaDetailSizeFlag);
mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
details.clear();
modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY (result.toStringList().count() == 2 );
// missing both
mMediaFactory->removeArray();
mMediaFactory->createMediaItems(MEDIA_COUNT, 0, MediaDetailNone);
mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
details.clear();
modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY (result.toStringList().count() == 2 );
// album typed data
mMediaFactory->removeArray();
mMediaFactory->createMediaItems(5, 2, MediaDetailCategoryVideoCount);
mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
modelIndex = mTestObjectInitialized->index(3, 0);
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY (result.toStringList().count() == 2 );
}
// -----------------------------------------------------------------------------
// testPrepareVideoCountString
// -----------------------------------------------------------------------------
//
void TestVideoListDataModel::testPrepareVideoCountString()
{
QString details("");
QModelIndex modelIndex;
QVariant result;
// Cagegory typed data.
mMediaFactory->removeArray();
mMediaFactory->createMediaItems(MEDIA_COUNT, 1, MediaDetailCategoryVideoCount);
mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY (result.toStringList().count() == 2 );
modelIndex = mTestObjectInitialized->index(MEDIA_COUNT-1, 0);
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY (result.toStringList().count() == 2 );
}
// -----------------------------------------------------------------------------
// testPrepareSizeString
// -----------------------------------------------------------------------------
//
void TestVideoListDataModel::testPrepareSizeString()
{
// This tests the CVideoCollectionUtils::prepareSizeString at the same time
// as we do not have separate tests for that.
// cannot call prepareSizeStrings directly, need to call indirectly using
// public data -method. That means:
// - we cannot test without videolistdata -object -case because tested throught data -call and
// existence is tested there already
// cannot chck the actual string due localization
QString details("");
QModelIndex modelIndex;
QVariant result;
mMediaFactory->removeArray();
mMediaFactory->createMediaItems(MEDIA_COUNT);
mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
// zero size
VideoListDataModelPrivate::mOverrideSize = true;
VideoListDataModelPrivate::mSize = 0;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(!result.toStringList().at(1).contains(","));
result = QVariant();
// 1 byte
VideoListDataModelPrivate::mSize = 1;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// under kB
VideoListDataModelPrivate::mSize = 1023;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// exactly on kB
VideoListDataModelPrivate::mSize = 1024;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// over kB but under under MB
VideoListDataModelPrivate::mSize = 0xFFFFF;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// MB
VideoListDataModelPrivate::mSize = 0x100000;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// larger than MB but smaller than GB
VideoListDataModelPrivate::mSize = 0x3FFFFFFF;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// 1 GB
VideoListDataModelPrivate::mSize = 0x40000000;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// larger than 1 GB
VideoListDataModelPrivate::mSize = 0x90000000;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
VideoListDataModelPrivate::mOverrideSize = false;
}
// -----------------------------------------------------------------------------
// testPrepareLengthString
// -----------------------------------------------------------------------------
//
void TestVideoListDataModel::testPrepareLengthString()
{
// This tests the CVideoCollectionUtils::prepareSizeString at the same time
// as we do not have separate tests for that.
//
// cannot check the actual strin due localisation
//
// cannot call prepareLengthStrings directly, need to call indirectly using
// public data -method. That means:
// - we cannot test without videolistdata -object -case because tested throught data -call and
// existence is tested there already
QString details("");
QModelIndex modelIndex;
QVariant result;
mMediaFactory->removeArray();
mMediaFactory->createMediaItems(MEDIA_COUNT);
mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
modelIndex = mTestObjectInitialized->index(MEDIA_COUNT / 2, 0);
// override size to zero, so prepareDetailRow doesn't include size in the detail row text.
VideoListDataModelPrivate::mOverrideSize = true;
VideoListDataModelPrivate::mSize = 0;
VideoListDataModelPrivate::mOverrideDuration = true;
VideoListDataModelPrivate::mDuration = 0;
// zero
VideoListDataModelPrivate::mDuration = 0;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
result = QVariant();
// second
VideoListDataModelPrivate::mDuration = 1;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// over 1 second, under minute
VideoListDataModelPrivate::mDuration = 59;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// one minute
VideoListDataModelPrivate::mDuration = 60;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// one minute one second
VideoListDataModelPrivate::mDuration = 61;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// more than one minute and one second
VideoListDataModelPrivate::mDuration = 3599;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// one hour
VideoListDataModelPrivate::mDuration = 3600;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// one hour, one minute
VideoListDataModelPrivate::mDuration = 3660;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
// over hour
VideoListDataModelPrivate::mDuration = 8654;
result = mTestObjectInitialized->data(modelIndex, Qt::DisplayRole);
QVERIFY(result.toStringList().at(1).length() > 0);
result = QVariant();
VideoListDataModelPrivate::mOverrideSize = false;
VideoListDataModelPrivate::mOverrideDuration = true;
VideoListDataModelPrivate::mDuration = 0;
}
// -----------------------------------------------------------------------------
// testRemoveRows
// -----------------------------------------------------------------------------
//
void TestVideoListDataModel::testRemoveRows()
{
QSignalSpy spysignal(mTestObjectInitialized, SIGNAL(modelChanged()));
QModelIndexList indexList;
mMediaFactory->removeArray();
// no collection neither deleteworker
QVERIFY(!mTestObjectNotInitialized->removeRows(indexList));
// empty list provided
QVERIFY(!mTestObjectInitialized->removeRows(indexList));
QVERIFY(spysignal.count() == 1);
QVERIFY(mTestObjectInitialized->mDeleteWorker->mRequestList.count() == 0);
spysignal.clear();
mMediaFactory->createMediaItems(MEDIA_COUNT);
mTestObjectInitialized->d_ptr->newVideoListSlot(mMediaFactory->mediaArray());
indexList.append(mTestObjectInitialized->index(0,0));
indexList.append(mTestObjectInitialized->index(1,0));
// invalid id from mark -call (for coverity's sake
VideoListDataModelPrivate::mReturnInvalidMarked = true;
QVERIFY(!mTestObjectInitialized->removeRows(indexList));
QVERIFY(spysignal.count() == 1);
QVERIFY(mTestObjectInitialized->mDeleteWorker->mRequestList.count() == 0);
spysignal.clear();
VideoListDataModelPrivate::mReturnInvalidMarked = false;
// no invalid ids
QVERIFY(mTestObjectInitialized->removeRows(indexList));
QVERIFY(spysignal.count() == 1);
QVERIFY(mTestObjectInitialized->mDeleteWorker->mRequestList.count() == 2);
QVERIFY(mTestObjectInitialized->mDeleteWorker->mRequestList.at(0) != TMPXItemId::InvalidId());
QVERIFY(mTestObjectInitialized->mDeleteWorker->mRequestList.at(1) != TMPXItemId::InvalidId());
}
void TestVideoListDataModel::testDeleteStartingFailsSlot()
{
QSignalSpy spysignal(mTestObjectInitialized, SIGNAL(modelChanged()));
mTestObjectInitialized->mDeleteWorker->mIsDeleting = false;
VideoCollectionWrapper::mLatestStatusCode = -1;
VideoCollectionWrapper::mLatestAdditional = QVariant();
QList<TMPXItemId> idList;
// empty list
emit mTestObjectInitialized->mDeleteWorker->deleteStartupFailed(idList);
QVERIFY(VideoCollectionWrapper::mLatestStatusCode == -1);
QVERIFY(!VideoCollectionWrapper::mLatestAdditional.isValid());
QVERIFY(spysignal.count() == 1);
spysignal.clear();
idList.append(TMPXItemId(0,0));
// list containing something
emit mTestObjectInitialized->mDeleteWorker->deleteStartupFailed(idList);
QVERIFY(VideoCollectionWrapper::mLatestStatusCode == VideoCollectionCommon::statusMultipleDeleteFail);
QVERIFY(VideoCollectionWrapper::mLatestAdditional.isValid());
QVERIFY(VideoCollectionWrapper::mLatestAdditional.toInt() == 1);
QVERIFY(spysignal.count() == 1);
spysignal.clear();
}
// -----------------------------------------------------------------------------
// testBelongsToAlbum
// -----------------------------------------------------------------------------
//
void TestVideoListDataModel::testBelongsToAlbum()
{
VideoListDataModelPrivate::mBelongsToAlbum = true;
TMPXItemId dummyId(1,1);
TMPXItemId dummyVideoId(1,0);
QVERIFY(mTestObjectInitialized->belongsToAlbum(dummyVideoId, dummyId));
}
// -----------------------------------------------------------------------------
// testSetAlbumInUse
// -----------------------------------------------------------------------------
//
void TestVideoListDataModel::testSetAlbumInUse()
{
TMPXItemId dummyId(1,1);
mTestObjectInitialized->setAlbumInUse(dummyId);
QVERIFY(mTestObjectInitialized->albumInUse() == dummyId);
}
// -----------------------------------------------------------------------------
// testRemoveItemsFromAlbum
// -----------------------------------------------------------------------------
//
void TestVideoListDataModel::testRemoveItemsFromAlbum()
{
VideoListDataModelPrivate::mRemoveFrAlbumReturn = 0;
VideoCollectionClient::mRemoveItemsReturn = 0;
TMPXItemId id(0,0);
QList<TMPXItemId> items;
items.append(id);
// remove count == 0
QVERIFY(mTestObjectInitialized->removeItemsFromAlbum(id, items) == 0);
VideoListDataModelPrivate::mRemoveFrAlbumReturn = 1;
VideoCollectionClient::mRemoveItemsReturn = -1;
// collectionclient returns < 0
QVERIFY(mTestObjectInitialized->removeItemsFromAlbum(id, items) < 0);
VideoListDataModelPrivate::mRemoveFrAlbumReturn = 1;
VideoCollectionClient::mRemoveItemsReturn = 0;
// succeeds
QVERIFY(mTestObjectInitialized->removeItemsFromAlbum(id, items) == 1);
}
// -----------------------------------------------------------------------------
// testreportAsyncStatus
// -----------------------------------------------------------------------------
//
void TestVideoListDataModel::testreportAsyncStatus()
{
mTestObjectInitialized->mDeleteWorker->mIsDeleting = false;
VideoCollectionWrapper::mLatestStatusCode = -1;
VideoCollectionWrapper::mLatestAdditional = QVariant();
QVariant data = QString("test");
// no deleteworker
VideoDeleteWorker *tmp = mTestObjectInitialized->mDeleteWorker;
mTestObjectInitialized->mDeleteWorker = 0;
mTestObjectInitialized->d_ptr->callModelAsyncReport(VideoCollectionCommon::statusMultipleDeleteFail, data);
QVERIFY(VideoCollectionWrapper::mLatestStatusCode == -1);
QVERIFY(!VideoCollectionWrapper::mLatestAdditional.isValid());
mTestObjectInitialized->mDeleteWorker = tmp;
// code == VideoCollectionCommon::statusSingleDeleteFail
mTestObjectInitialized->mDeleteWorker->mIsDeleting = true;
mTestObjectInitialized->d_ptr->callModelAsyncReport(VideoCollectionCommon::statusSingleDeleteFail, data);
QVERIFY(VideoCollectionWrapper::mLatestStatusCode == -1);
QVERIFY(!VideoCollectionWrapper::mLatestAdditional.isValid());
mTestObjectInitialized->mDeleteWorker->mIsDeleting = false;
mTestObjectInitialized->d_ptr->callModelAsyncReport(VideoCollectionCommon::statusSingleDeleteFail, data);
QVERIFY(VideoCollectionWrapper::mLatestStatusCode == VideoCollectionCommon::statusSingleDeleteFail);
QVERIFY(VideoCollectionWrapper::mLatestAdditional.isValid());
QVERIFY(VideoCollectionWrapper::mLatestAdditional.toString() == data.toString());
VideoCollectionWrapper::mLatestStatusCode = -1;
VideoCollectionWrapper::mLatestAdditional = QVariant();
// code == VideoCollectionCommon::statusMultipleDeleteFail
mTestObjectInitialized->mDeleteWorker->mIsDeleting = true;
mTestObjectInitialized->d_ptr->callModelAsyncReport(VideoCollectionCommon::statusMultipleDeleteFail, data);
QVERIFY(VideoCollectionWrapper::mLatestStatusCode == -1);
QVERIFY(!VideoCollectionWrapper::mLatestAdditional.isValid());
mTestObjectInitialized->mDeleteWorker->mIsDeleting = false;
mTestObjectInitialized->d_ptr->callModelAsyncReport(VideoCollectionCommon::statusMultipleDeleteFail, data);
QVERIFY(VideoCollectionWrapper::mLatestStatusCode == VideoCollectionCommon::statusMultipleDeleteFail);
QVERIFY(VideoCollectionWrapper::mLatestAdditional.isValid());
QVERIFY(VideoCollectionWrapper::mLatestAdditional.toString() == data.toString());
// code is neither above
mTestObjectInitialized->d_ptr->callModelAsyncReport(-2, data);
QVERIFY(VideoCollectionWrapper::mLatestStatusCode == -2);
QVERIFY(VideoCollectionWrapper::mLatestAdditional.isValid());
QVERIFY(VideoCollectionWrapper::mLatestAdditional.toString() == data.toString());
}
// -----------------------------------------------------------------------------
// initializeTestObjects
// -----------------------------------------------------------------------------
//
bool TestVideoListDataModel::initializeTestObjects()
{
mCollectionStub = NULL;
mTestObjectInitialized = NULL;
mTestObjectNotInitialized = NULL;
mCollectionStub = new VideoCollectionClient();
if(!mCollectionStub)
{
return false;
}
mTestObjectInitialized = new VideoListDataModel();
if(!mTestObjectInitialized)
{
return false;
}
VideoCollectionClient::mFailConnectSignals = false;
VideoCollectionClient::mFailInitialize = false;
VideoListDataModelPrivate::mFailInit = false;
if( mTestObjectInitialized->initialize() == -1)
{
return false;
}
mTestObjectNotInitialized = new VideoListDataModel();
if(!mTestObjectNotInitialized)
{
return false;
}
return true;
}
// -----------------------------------------------------------------------------
// cleanupTestObjects
// -----------------------------------------------------------------------------
//
void TestVideoListDataModel::cleanupTestObjects()
{
delete mCollectionStub;
delete mTestObjectInitialized;
delete mTestObjectNotInitialized;
}
// End of file