--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videocollection/videocollectionwrapper/tsrc/testvideosortfilterproxymodel/src/testvideosortfilterproxymodel.cpp Fri Apr 16 14:59:52 2010 +0300
@@ -0,0 +1,1264 @@
+/**
+* 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 "videocollectionwrapper.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;
+
+ 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\\testvideosortfilterproxymodel.txt";
+ res = QTest::qExec(&tv, 3, pass);
+ }
+
+ return res;
+}
+
+
+// ---------------------------------------------------------------------------
+// init
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::init()
+{
+ qRegisterMetaType<TMPXItemId>("TMPXItemId");
+
+ 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(VideoCollectionWrapper::EGeneric);
+ QVERIFY(mTestObject);
+
+ mStubModel = new VideoListDataModel();
+ QVERIFY(mStubModel);
+
+ mCollectionClient = new VideoCollectionClient();
+ QVERIFY(mCollectionClient);
+
+ mCollectionModel = new VideoSortFilterProxyModel(VideoCollectionWrapper::ECollections);
+}
+
+// ---------------------------------------------------------------------------
+// cleanup
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::cleanup()
+{
+ delete mCollectionClient;
+ mCollectionClient = 0;
+
+ delete mStubModel;
+ mStubModel = 0;
+
+ delete mTestObject;
+ mTestObject = 0;
+
+ delete mCollectionModel;
+ mCollectionModel = 0;
+}
+
+// ---------------------------------------------------------------------------
+// testInitialize
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testInitialize()
+{
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+}
+
+// ---------------------------------------------------------------------------
+// testInitializeSignalConnectFail
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testInitializeSignalConnectFail()
+{
+ QVERIFY(mTestObject->initialize(NULL) == -1);
+}
+
+// ---------------------------------------------------------------------------
+// testSecondInitialize
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testSecondInitialize()
+{
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+}
+
+// ---------------------------------------------------------------------------
+// testOpen
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testOpen()
+{
+ // no mCollectionClient
+ QVERIFY(mTestObject->open(1) == -1);
+
+ mTestObject->initialize(mStubModel);
+
+ // 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()
+{
+ VideoCollectionClient::mFailStartOpen = false;
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);
+ 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
+
+ // 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);
+
+ int count = mTestObject->rowCount();
+ QModelIndexList list;
+ QModelIndex index;
+ for(int i = 0; i < 5; ++i)
+ {
+ index = mTestObject->index(i,0);
+ list.append(index);
+ }
+ QModelIndexList emptyList;
+ VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
+ QVERIFY(mTestObject->deleteItems(emptyList) == 0);
+ QVERIFY(mTestObject->deleteItems(list) == 0);
+ QVERIFY(mStubModel->mLastDeletedIndexRow == 0);
+ QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 2);
+}
+
+// ---------------------------------------------------------------------------
+// testDeleteItemsModelNull
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testDeleteItemsModelNull()
+{
+ mStubModel->appendData("Test");
+ QVERIFY(mTestObject->initialize(NULL) == -1);
+
+ QModelIndex index = mStubModel->index(0, 0);
+ QModelIndexList list;
+ list.append(index);
+
+ QVERIFY(mTestObject->deleteItems(list) == -1);
+
+}
+
+// ---------------------------------------------------------------------------
+// testDeleteItemsRemoveRowsFail
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testDeleteItemsRemoveRowsFail()
+{
+ VideoListDataModel::mRemoveRowsFails = true;
+ VideoCollectionClient::mFailStartOpen = false;
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);
+
+ mStubModel->appendData("Test");
+
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+
+ QModelIndex index = mTestObject->index(0, 0);
+ QModelIndexList list;
+ list.append(index);
+
+ QVERIFY(mTestObject->deleteItems(list) == -1);
+}
+
+// ---------------------------------------------------------------------------
+// testOpenItemInvalidId
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testOpenItemInvalidId()
+{
+ VideoListDataModel::mGetMediaIdAtIndexFails = true;
+ VideoCollectionClient::mFailStartOpen = false;
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);
+
+ mStubModel->appendData("Test");
+
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QModelIndex index = mTestObject->index(0, 0);
+ TMPXItemId itemId = TMPXItemId::InvalidId();
+
+ QVERIFY(mTestObject->openItem(itemId) == -1);
+}
+
+// ---------------------------------------------------------------------------
+// testOpenItemCollectionNull
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testOpenItemCollectionNull()
+{
+ mStubModel->appendData("Test");
+
+ TMPXItemId itemId(1,0);
+
+ QVERIFY(mTestObject->openItem(itemId) == -1);
+}
+
+// ---------------------------------------------------------------------------
+// testOpenItemOpenVideoFails
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testOpenItemOpenVideoFails()
+{
+ VideoCollectionClient::mFailMediaPlayback = true;
+
+ mStubModel->appendData("Test");
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ TMPXItemId itemId(1,0);
+
+ QVERIFY(mTestObject->openItem(itemId) == -1);
+
+ VideoCollectionClient::mFailMediaPlayback = false;
+}
+
+// ---------------------------------------------------------------------------
+// testOpenItem
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testOpenItem()
+{
+ mStubModel->appendData("Test");
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ TMPXItemId itemId(1,0);
+
+ // open video
+ QVERIFY(mTestObject->openItem(itemId) == 0);
+
+ // open category or album
+ itemId = TMPXItemId(1,2);
+ QVERIFY(mTestObject->openItem(itemId) == 0);
+
+}
+
+// ---------------------------------------------------------------------------
+// testBack
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testBack()
+{
+
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+
+ QVERIFY(mTestObject->back() == 0);
+
+ mTestObject->open(VideoCollectionCommon::ELevelAlbum);
+ QVERIFY(mTestObject->back() == 0);
+
+}
+
+// ---------------------------------------------------------------------------
+// testBack
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testBackClientNull()
+{
+
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ VideoCollectionClient *tmpCollectionClient = mTestObject->getClient();
+ mTestObject->setClient(0);
+
+ QVERIFY(mTestObject->back() == -1);
+
+ mTestObject->setClient(tmpCollectionClient);
+}
+
+// ---------------------------------------------------------------------------
+// testFetchItemDetails
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testFetchItemDetails()
+{
+ VideoCollectionClient::mFailStartOpen = false;
+ mStubModel->appendData("Test");
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ mTestObject->open(3);
+ QSignalSpy fetchSpy(mTestObject, SIGNAL(shortDetailsReady(TMPXItemId)));
+
+ QModelIndex index = mTestObject->index(0, 0);
+
+ QList<QVariant> arguments;
+ QVERIFY(mTestObject->fetchItemDetails(index) == 0);
+
+ QVERIFY(fetchSpy.count() == 1);
+ arguments = fetchSpy.takeFirst();
+ QVERIFY(arguments.at(0).toInt() == 0);
+ arguments.clear();
+ fetchSpy.clear();
+}
+
+// ---------------------------------------------------------------------------
+// testFetchItemDetails
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testFetchItemDetailsGetMediaIdFail()
+{
+ VideoListDataModel::mGetMediaIdAtIndexFails = true;
+
+ mStubModel->appendData("Test");
+
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+
+ QSignalSpy fetchSpy(mTestObject, SIGNAL(shortDetailsReady(TMPXItemId)));
+
+ QModelIndex index = mTestObject->index(0, 0);
+
+ QVERIFY(mTestObject->fetchItemDetails(index) == -1);
+
+ QVERIFY(fetchSpy.count() == 0);
+}
+
+// ---------------------------------------------------------------------------
+// testFetchItemDetails
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testFetchItemDetailsGetVideoDetailsFails()
+{
+ VideoCollectionClient::mFailMediaDetails = true;
+
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ mTestObject->open(3);
+ mStubModel->appendData("Test");
+
+ QSignalSpy fetchSpy(mTestObject, SIGNAL(shortDetailsReady(TMPXItemId)));
+ QModelIndex index = mTestObject->index(0, 0);
+
+ QVERIFY(mTestObject->fetchItemDetails(index) == -1);
+
+ QVERIFY(fetchSpy.count() == 0);
+}
+
+// ---------------------------------------------------------------------------
+// testLessThanProxyModelNotInitialized
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testLessThanNoModel()
+{
+ // "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
+
+ mTestObject->setSortRole(Qt::DisplayRole);
+
+ QModelIndex left = mStubModel->index(0,0);
+ QModelIndex right = mStubModel->index(1,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+}
+// ---------------------------------------------------------------------------
+// testLessThanName
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testLessThanName()
+{
+ VideoCollectionClient::mFailStartOpen = false;
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 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
+
+ mTestObject->setSortRole(Qt::DisplayRole);
+
+ QModelIndex left = mStubModel->index(0,0);
+ QModelIndex right = mStubModel->index(1,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(1,0);
+ right = mStubModel->index(2,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(2,0);
+ right = mStubModel->index(3,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(3,0);
+ right = mStubModel->index(4,0);
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(4,0);
+ right = mStubModel->index(0,0);
+
+ QVERIFY(mTestObject->callLessThan(left, right));
+
+ // reset model
+ mStubModel->removeAll();;
+
+ // case sensitive check
+ name1 = "cc";
+ name2 = "CC";
+ name3 = "cC";
+ name4 = "aa";
+ name5 = "Aa";
+ QString name6 = "2Aa";
+ QString name7 = "1Aa";
+ QString name8 = "1cc";
+ mStubModel->removeAll();
+ mStubModel->appendData(name1); // to index 0, position can be 5, 6 or 7
+ mStubModel->appendData(name2); // to index 1, position can be 5, 6 or 7
+ mStubModel->appendData(name3); // to index 2, position can be 5, 6 or 7
+ mStubModel->appendData(name4); // to index 3, position can be 3 or 4
+ mStubModel->appendData(name5); // to index 4, position can be 3 or 4
+ mStubModel->appendData(name6); // to index 5, position is 2
+ mStubModel->appendData(name7); // to index 6, position is 0
+ mStubModel->appendData(name8); // to index 7, position is 1
+
+
+ mTestObject->setSortRole(Qt::DisplayRole);
+
+
+ left = mStubModel->index(0,0); // "cc"
+ right = mStubModel->index(1,0); // "CC"
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(1,0); // "CC"
+ right = mStubModel->index(2,0); // "cC"
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(2,0); // "cC"
+ right = mStubModel->index(3,0); // "aa"
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(3,0); // "aa"
+ right = mStubModel->index(2,0); // "cC"
+
+ QVERIFY(mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(3,0); // "aa"
+ right = mStubModel->index(4,0); // "Aa"
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(4,0); // "Aa"
+ right = mStubModel->index(5,0); // "2Aa"
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(5,0); // "2Aa"
+ right = mStubModel->index(6,0); // "1Aa"
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(6,0); // "1Aa"
+ right = mStubModel->index(7,0); // "1cc"
+ QVERIFY(mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(5,0); // "2Aa"
+ right = mStubModel->index(7,0); // "1cc"
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(7,0); // "1cc"
+ right = mStubModel->index(0,0); // "cc"
+ QVERIFY(mTestObject->callLessThan(left, right));
+}
+
+// ---------------------------------------------------------------------------
+// testLessThanSize
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testLessThanSize()
+{
+ VideoCollectionClient::mFailStartOpen = false;
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);
+
+ quint32 size1 = 300;
+ quint32 size2 = 200;
+ quint32 size3 = 100;
+ quint32 size4 = 99;
+ quint32 size5 = 99;
+
+ mStubModel->appendData(size1); // to index 0
+ mStubModel->appendData(size2); // to index 1
+ mStubModel->appendData(size3); // to index 2
+ mStubModel->appendData(size4); // to index 3
+ mStubModel->appendData(size5); // to index 4
+
+ mTestObject->setSortRole(VideoCollectionCommon::KeySizeValue);
+
+ QModelIndex left = mStubModel->index(0,0);
+ QModelIndex right = mStubModel->index(1,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(1,0);
+ right = mStubModel->index(2,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(2,0);
+ right = mStubModel->index(3,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(3,0);
+ right = mStubModel->index(4,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(4,0);
+ right = mStubModel->index(0,0);
+
+ QVERIFY(mTestObject->callLessThan(left, right));
+}
+
+// ---------------------------------------------------------------------------
+// testLessThanDate
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testLessThanDateTime()
+{
+ VideoCollectionClient::mFailStartOpen = false;
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);
+
+ QDateTime date1(QDate(2010, 11, 5), QTime(0,0));
+ QDateTime date2(QDate(2009, 9, 5), QTime(0,0));
+ QDateTime date3(QDate(2009, 9, 4), QTime(0,0));
+ QDateTime date4(QDate(2008, 9, 6), QTime(0,0));
+ QDateTime date5(QDate(2008, 9, 6), QTime(0,0));
+
+ mStubModel->appendData(date1); // to index 0
+ mStubModel->appendData(date2); // to index 1
+ mStubModel->appendData(date3); // to index 2
+ mStubModel->appendData(date4); // to index 3
+ mStubModel->appendData(date5); // to index 4
+
+ mTestObject->setSortRole(VideoCollectionCommon::KeyDateTime);
+
+ QModelIndex left = mStubModel->index(0,0);
+ QModelIndex right = mStubModel->index(1,0);
+
+ QVERIFY(mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(1,0);
+ right = mStubModel->index(2,0);
+
+ QVERIFY(mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(2,0);
+ right = mStubModel->index(3,0);
+
+ QVERIFY(mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(3,0);
+ right = mStubModel->index(4,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ left = mStubModel->index(4,0);
+ right = mStubModel->index(0,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+}
+
+// ---------------------------------------------------------------------------
+// testLessThanInvalid
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testLessThanInvalid()
+{
+ VideoCollectionClient::mFailStartOpen = false;
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);
+
+ // invalid role
+ mTestObject->setSortRole(10000);
+
+ QModelIndex left = mStubModel->index(0,0);
+ QModelIndex right = mStubModel->index(0,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ // invalid role but valid data.
+
+ QString name1 = "cc";
+ QString name2 = "bb";
+ QString name3 = "aa";
+
+
+ mStubModel->appendData(name1); // to index 0, position 4
+ mStubModel->appendData(name2); // to index 1, position 3
+ mStubModel->appendData(name3); // to index 2, position 2
+
+ mTestObject->setSortRole(INVALID_ROLE_FOR_SORTING);
+
+ left = mStubModel->index(0,0);
+ right = mStubModel->index(1,0);
+
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ // reset model
+ mStubModel->removeAll();
+
+ // invalid left index
+ mTestObject->setSortRole(Qt::DisplayRole);
+
+ left = QModelIndex();
+ right = mStubModel->index(0,0);
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ // invalid right index
+ mTestObject->setSortRole(Qt::DisplayRole);
+ User::Heap().__DbgMarkStart();
+ left = mStubModel->index(0,0);
+ right = QModelIndex();
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ // both invalid
+ mTestObject->setSortRole(Qt::DisplayRole);
+ User::Heap().__DbgMarkStart();
+ left = QModelIndex();
+ right = QModelIndex();
+
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+ // both same index, use size
+ quint32 size1 = 99;
+
+ mStubModel->appendData(size1); // to index 0
+
+ mTestObject->setSortRole(VideoCollectionCommon::KeySizeValue);
+ mTestObject->setSortRole(Qt::DisplayRole);
+
+
+ left = mStubModel->index(0,0);
+ right = mStubModel->index(0,0);
+ QVERIFY(!mTestObject->callLessThan(left, right));
+
+}
+
+// ---------------------------------------------------------------------------
+// testDoSorting
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testDoSorting()
+{
+ VideoCollectionClient::mFailStartOpen = false;
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);
+
+ // these signals are emitted during sorting procedure from the fw
+ QSignalSpy spyAboutToChange(mTestObject, SIGNAL(layoutAboutToBeChanged()));
+ QSignalSpy spyChanged(mTestObject, SIGNAL(layoutChanged()));
+
+ QString name1 = "cc";
+ QString name2 = "bb";
+ QString name3 = "aa";
+ QString name4 = "11";
+ QString name5 = "11";
+ QDateTime date1(QDate(2010, 11, 5), QTime(0,0));
+ QDateTime date2(QDate(2009, 9, 5), QTime(0,0));
+ QDateTime date3(QDate(2009, 9, 4), QTime(0,0));
+ QDateTime date4(QDate(2008, 9, 6), QTime(0,0));
+ QDateTime date5(QDate(2008, 9, 6), QTime(0,0));
+ quint32 size1 = 300;
+ quint32 size2 = 200;
+ quint32 size3 = 100;
+ quint32 size4 = 99;
+ quint32 size5 = 99;
+
+ 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->appendData(date1); // to index 0
+ mStubModel->appendData(date2); // to index 1
+ mStubModel->appendData(date3); // to index 2
+ mStubModel->appendData(date4); // to index 3
+ mStubModel->appendData(date5); // to index 4
+
+ mStubModel->appendData(size1); // to index 0
+ mStubModel->appendData(size2); // to index 1
+ mStubModel->appendData(size3); // to index 2
+ mStubModel->appendData(size4); // to index 3
+ mStubModel->appendData(size5); // to index 4
+
+ int sortingRole;
+ Qt::SortOrder sortingOrder;
+
+ // first sort call, includes timer creation and setup
+ VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
+ mTestObject->doSorting(Qt::DisplayRole, Qt::AscendingOrder);
+ // need to wait for awhile to make sure zero-counter gets
+ // processing time.
+ QTest::qWait(500);
+ QCOMPARE(spyAboutToChange.count(), 1);
+ QCOMPARE(spyChanged.count(), 1);
+ QCOMPARE(mTestObject->sortRole(), (int)Qt::DisplayRole);
+ QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
+ QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
+ mTestObject->getSorting(sortingRole, sortingOrder);
+ QCOMPARE(sortingRole, (int)Qt::DisplayRole);
+ QCOMPARE(sortingOrder, Qt::AscendingOrder);
+
+ // reset spys
+ spyAboutToChange.clear();
+ spyChanged.clear();
+
+ // second sort call, should use same timer appropriately
+ VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
+ mTestObject->doSorting(Qt::DisplayRole, Qt::DescendingOrder);
+ QTest::qWait(500);
+ QCOMPARE(spyAboutToChange.count(), 1);
+ QCOMPARE(spyChanged.count(), 1);
+ QCOMPARE(mTestObject->sortRole(), (int)Qt::DisplayRole);
+ QCOMPARE(mTestObject->sortOrder(), Qt::DescendingOrder);
+ QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
+ mTestObject->getSorting(sortingRole, sortingOrder);
+ QCOMPARE(sortingRole, (int)Qt::DisplayRole);
+ QCOMPARE(sortingOrder, Qt::DescendingOrder);
+
+ // reset spys
+ spyAboutToChange.clear();
+ spyChanged.clear();
+
+ // double call without first letting timer to timeout
+ VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
+ mTestObject->doSorting(Qt::DisplayRole, Qt::DescendingOrder);
+ mTestObject->doSorting(Qt::DisplayRole, Qt::AscendingOrder);
+ QTest::qWait(500);
+ QCOMPARE(spyAboutToChange.count(), 1);
+ QCOMPARE(spyChanged.count(), 1);
+ QCOMPARE(mTestObject->sortRole(), (int)Qt::DisplayRole);
+ QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
+ QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
+ mTestObject->getSorting(sortingRole, sortingOrder);
+ QCOMPARE(sortingRole, (int)Qt::DisplayRole);
+ QCOMPARE(sortingOrder, Qt::AscendingOrder);
+
+ spyAboutToChange.clear();
+ spyChanged.clear();
+
+ // syncronous call checks
+ VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
+ mTestObject->doSorting(Qt::DisplayRole, Qt::DescendingOrder, false);
+ QCOMPARE(spyAboutToChange.count(), 1);
+ QCOMPARE(spyChanged.count(), 1);
+ QCOMPARE(mTestObject->sortRole(), (int)Qt::DisplayRole);
+ QCOMPARE(mTestObject->sortOrder(), Qt::DescendingOrder);
+ QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
+ mTestObject->getSorting(sortingRole, sortingOrder);
+ QCOMPARE(sortingRole, (int)Qt::DisplayRole);
+ QCOMPARE(sortingOrder, Qt::DescendingOrder);
+
+ spyAboutToChange.clear();
+ spyChanged.clear();
+
+ VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
+ mTestObject->doSorting(Qt::DisplayRole, Qt::AscendingOrder, false);
+ QCOMPARE(spyAboutToChange.count(), 1);
+ QCOMPARE(spyChanged.count(), 1);
+ QCOMPARE(mTestObject->sortRole(), (int)Qt::DisplayRole);
+ QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
+ QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
+ mTestObject->getSorting(sortingRole, sortingOrder);
+ QCOMPARE(sortingRole, (int)Qt::DisplayRole);
+ QCOMPARE(sortingOrder, Qt::AscendingOrder);
+
+ spyAboutToChange.clear();
+ spyChanged.clear();
+
+ // check that layout signals are not send if the sorting values don't change.
+ VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
+ mTestObject->doSorting(Qt::DisplayRole, Qt::AscendingOrder);
+ QCOMPARE(spyAboutToChange.count(), 0);
+ QCOMPARE(spyChanged.count(), 0);
+ QCOMPARE(mTestObject->sortRole(), (int)Qt::DisplayRole);
+ QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
+ QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 0);
+ mTestObject->getSorting(sortingRole, sortingOrder);
+ QCOMPARE(sortingRole, (int)Qt::DisplayRole);
+ QCOMPARE(sortingOrder, Qt::AscendingOrder);
+
+ spyAboutToChange.clear();
+ spyChanged.clear();
+
+ // date role check
+ VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
+ mTestObject->doSorting(VideoCollectionCommon::KeyDateTime, Qt::AscendingOrder);
+ QTest::qWait(500);
+ int count = spyAboutToChange.count();
+ QCOMPARE(spyAboutToChange.count(), 1);
+ QCOMPARE(spyChanged.count(), 1);
+ QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyDateTime);
+ QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
+ mTestObject->getSorting(sortingRole, sortingOrder);
+ QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyDateTime);
+ QCOMPARE(sortingOrder, Qt::AscendingOrder);
+
+ spyAboutToChange.clear();
+ spyChanged.clear();
+
+ // size role check
+ VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
+ mTestObject->doSorting(VideoCollectionCommon::KeySizeValue, Qt::AscendingOrder);
+ QTest::qWait(500);
+ QCOMPARE(spyAboutToChange.count(), 1);
+ QCOMPARE(spyChanged.count(), 1);
+ QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeySizeValue);
+ QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
+ mTestObject->getSorting(sortingRole, sortingOrder);
+ QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeySizeValue);
+ QCOMPARE(sortingOrder, Qt::AscendingOrder);
+
+
+ spyAboutToChange.clear();
+ spyChanged.clear();
+
+ // invalid role call, sorting should be set to date
+ VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
+ mTestObject->doSorting(Qt::DisplayRole - 100, Qt::AscendingOrder);
+ QTest::qWait(500);
+ QCOMPARE(spyAboutToChange.count(), 1);
+ QCOMPARE(spyChanged.count(), 1);
+ QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyDateTime);
+ spyAboutToChange.clear();
+ spyChanged.clear();
+ QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
+}
+
+// ---------------------------------------------------------------------------
+// testFilterAcceptsRow
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testFilterAcceptsRow()
+{
+ QWARN("tests for different model types are still missing");
+
+ QModelIndex index = QModelIndex(); // index can be anything, test model doesn't use it.
+
+ // Not initialized: no rouce model
+ QVERIFY(mTestObject->callFilterAcceptsRow(0, index) == false);
+
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ mTestObject->open(3);
+
+ // Test invalid row: below 0
+ QVERIFY(mTestObject->callFilterAcceptsRow(-1, index) == false);
+
+ // invalid row: larger than count
+ mStubModel->appendData("test");
+ QVERIFY(mTestObject->callFilterAcceptsRow(2, index) == false);
+
+ // correct row
+ QVERIFY(mTestObject->callFilterAcceptsRow(0, index) == true);
+
+}
+
+// ---------------------------------------------------------------------------
+// testGetMediaFilePathForId
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testGetMediaFilePathForId()
+{
+ // Not initialized.
+ VideoListDataModel::mMediaFilePathReturnValue = "testfile";
+ QVERIFY(mTestObject->getMediaFilePathForId(TMPXItemId(0,0)) == "");
+
+ // Ok case.
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ VideoListDataModel::mMediaFilePathReturnValue = "testfile";
+ QVERIFY(mTestObject->getMediaFilePathForId(TMPXItemId(0,0)) == "testfile");
+}
+
+// ---------------------------------------------------------------------------
+// testAddNewCollectionNoCollectionClient
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testAddNewCollectionNoCollectionClient()
+{
+ QString name("testname");
+ VideoCollectionClient::mNewAlbumId = TMPXItemId(1,1);
+ QVERIFY(mTestObject->addNewAlbum(name) == TMPXItemId::InvalidId());
+ QVERIFY(VideoCollectionClient::mAddNewCollectionName != name);
+}
+
+// ---------------------------------------------------------------------------
+// testAddNewCollectionSucceed
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testAddNewCollectionSucceed()
+{
+ QString name("testname");
+
+ mTestObject->initialize(mStubModel);
+ VideoCollectionClient::mNewAlbumId = TMPXItemId(1,1);
+ QVERIFY(mTestObject->addNewAlbum(name) == TMPXItemId(1,1));
+ QCOMPARE(VideoCollectionClient::mAddNewCollectionName, name);
+}
+
+// ---------------------------------------------------------------------------
+// testResolveAlbumName
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testResolveAlbumName()
+{
+ QString name("test");
+ QString resolved("");
+ // no model, same name can be used
+ resolved = mTestObject->resolveAlbumName(name);
+ QVERIFY(resolved.length());
+ QVERIFY(resolved == name);
+
+ mTestObject->initialize(mStubModel);
+
+ // no collections proxy model, same name
+ resolved = mTestObject->resolveAlbumName(name);
+ QVERIFY(resolved.length());
+ QVERIFY(resolved == name);
+
+
+ mCollectionModel->initialize(mStubModel);
+ mCollectionModel->open(2);
+ VideoCollectionWrapper::instance().mProxyModel = mCollectionModel;
+
+ mStubModel->appendData(TMPXItemId(1,2));
+ mStubModel->appendData(name);
+
+ int count = mCollectionModel->rowCount();
+
+ // invalid data from model, same name can be used
+ VideoListDataModel::mReturnInvalid = true;
+ resolved = mTestObject->resolveAlbumName(name);
+ QVERIFY(resolved.length());
+ QVERIFY(resolved == name);
+ VideoListDataModel::mReturnInvalid = false;
+
+ // same name, name to be different
+ resolved = mTestObject->resolveAlbumName(name);
+ QVERIFY(resolved.length());
+ QVERIFY(resolved != name);
+ QVERIFY(resolved.contains("1"));
+
+ mStubModel->appendData(TMPXItemId(2,2));
+ mStubModel->appendData(resolved);
+
+ resolved = mTestObject->resolveAlbumName(name);
+ QVERIFY(resolved.length());
+ QVERIFY(resolved != name);
+ QVERIFY(resolved.contains("2"));
+
+ // different name, no changes
+ name = "Another";
+ resolved = mTestObject->resolveAlbumName(name);
+ QVERIFY(resolved == name);
+
+}
+
+// ---------------------------------------------------------------------------
+// testResolveAlbumName
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testAddItemsInAlbum()
+{
+ TMPXItemId albumId(1,2);
+ QList<TMPXItemId> items;
+ items.append(TMPXItemId(1,0));
+ // no collection client
+ QVERIFY(mTestObject->addItemsInAlbum(albumId, items) == -1);
+
+ mTestObject->initialize(mStubModel);
+
+ QVERIFY(mTestObject->addItemsInAlbum(albumId, items) == 0);
+}
+
+// ---------------------------------------------------------------------------
+// testRemoveItemsFromAlbum
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testRemoveItemsFromAlbum()
+{
+ VideoListDataModel::mRemoveFrAlbumReturn = 1;
+ TMPXItemId albumId(1,2);
+ QList<TMPXItemId> items;
+ items.append(TMPXItemId(1,0));
+
+ // no model
+ QVERIFY(mTestObject->removeItemsFromAlbum(albumId, items) == -1);
+ mTestObject->initialize(mStubModel);
+
+ // model returns < 0
+ VideoListDataModel::mRemoveFrAlbumReturn = -1;
+ QVERIFY(mTestObject->removeItemsFromAlbum(albumId, items) == -1);
+
+ VideoListDataModel::mRemoveFrAlbumReturn = 11;
+ // "succeed"
+ QVERIFY(mTestObject->removeItemsFromAlbum(albumId, items) == 0);
+}
+
+// ---------------------------------------------------------------------------
+// testGetOpenItem
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testGetOpenItem()
+{
+ // no collection client
+ QVERIFY(mTestObject->getOpenItem() == TMPXItemId::InvalidId());
+
+ mTestObject->initialize(mStubModel);
+
+ // type neither EAllVideos or ECollectionContent
+ QVERIFY(mTestObject->getOpenItem() == TMPXItemId::InvalidId());
+
+ TMPXItemId id;
+ // type EAllVideos
+ delete mTestObject;
+ mTestObject = new FilterProxyTester(VideoCollectionWrapper::EAllVideos);
+ mTestObject->initialize(mStubModel);
+ id = mTestObject->getOpenItem();
+ QVERIFY(id != TMPXItemId::InvalidId());
+ QVERIFY(id.iId1 == KVcxMvcCategoryIdAll);
+ QVERIFY(id.iId2 == KVcxMvcMediaTypeCategory);
+
+ // type ECollectionContent
+ delete mTestObject;
+ mTestObject = new FilterProxyTester(VideoCollectionWrapper::ECollectionContent);
+ mTestObject->initialize(mStubModel);
+ id.iId1 = 1;
+ id.iId2 = KVcxMvcMediaTypeAlbum;
+ mTestObject->openItem(id);
+ id = TMPXItemId::InvalidId();
+ id = mTestObject->getOpenItem();
+ QVERIFY(id != TMPXItemId::InvalidId());
+ QVERIFY(id.iId1 == 1);
+ QVERIFY(id.iId2 == KVcxMvcMediaTypeAlbum);
+
+}
+
+// ---------------------------------------------------------------------------
+// testRemoveAlbums
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testRemoveAlbums()
+{
+ QModelIndexList indexList;
+ // no collection
+ QVERIFY(mTestObject->removeAlbums(indexList) == -1);
+
+ mTestObject->initialize(mStubModel);
+ QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);
+
+ // empty list provided
+ QVERIFY(mTestObject->removeAlbums(indexList) == -1);
+
+ mStubModel->appendData(TMPXItemId(1,0));
+ mStubModel->appendData(TMPXItemId(2,0));
+ mStubModel->appendData(TMPXItemId(3,0));
+
+ indexList.append(mTestObject->index(0,0));
+ indexList.append(mTestObject->index(1,0));
+ indexList.append(mTestObject->index(2,0));
+
+ // no albums in model
+ QVERIFY(mTestObject->removeAlbums(indexList) == -1);
+
+ mStubModel->removeAll();
+ delete mTestObject;
+ mTestObject = new FilterProxyTester(VideoCollectionWrapper::ECollections);
+ QVERIFY(mTestObject);
+ QVERIFY(mTestObject->initialize(mStubModel) == 0);
+ QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelCategory) == 0);
+ mStubModel->appendData(TMPXItemId(1,2));
+ mStubModel->appendData(TMPXItemId(2,2));
+ mStubModel->appendData(TMPXItemId(3,2));
+ indexList.append(mTestObject->index(0,2));
+ indexList.append(mTestObject->index(1,2));
+ indexList.append(mTestObject->index(2,2));
+
+ // succeed
+ QVERIFY(mTestObject->removeAlbums(indexList) == 0);
+}
+
+// ---------------------------------------------------------------------------
+// testAlbumChangedSlot
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testAlbumChangedSlot()
+{
+ connect(this, SIGNAL(testSignal()), mTestObject, SLOT(albumChangedSlot()));
+ // cannot test anything here, just for the coverage
+ // level incorrect
+ mTestObject->initialize(mStubModel);
+ emit testSignal();
+ delete mTestObject;
+ mTestObject = 0;
+ mTestObject = new FilterProxyTester(VideoCollectionWrapper::ECollectionContent);
+ connect(this, SIGNAL(testSignal()), mTestObject, SLOT(albumChangedSlot()));
+ QVERIFY(mTestObject);
+ mTestObject->initialize(mStubModel);
+ emit testSignal();
+ disconnect(this, SIGNAL(testSignal()), mTestObject, SLOT(albumChangedSlot()));
+}
+
+// ---------------------------------------------------------------------------
+// testIndexOfId
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testIndexOfId()
+{
+ QModelIndex index;
+ // no model
+ TMPXItemId id(1,0);
+ index = mTestObject->indexOfId(id);
+ QVERIFY(!index.isValid());
+
+ mTestObject->initialize(mStubModel);
+ mTestObject->open(VideoCollectionCommon::ELevelVideos);
+
+ // fetching invalid
+ id = TMPXItemId::InvalidId();
+ index = mTestObject->indexOfId(id);
+ QVERIFY(!index.isValid());
+
+ mStubModel->appendData(TMPXItemId(1,0));
+ mStubModel->appendData(TMPXItemId(2,0));
+ mStubModel->appendData(TMPXItemId(3,0));
+
+ id = TMPXItemId(2,0);
+ index = mTestObject->indexOfId(id);
+ QVERIFY(index.isValid());
+ QVERIFY(index.row() == 1);
+}
+
+// ---------------------------------------------------------------------------
+// testSetGenericIdFilter
+// ---------------------------------------------------------------------------
+//
+void TestVideoSortFilterProxyModel::testSetGenericIdFilter()
+{
+ // type VideoCollectionWrapper::EGeneric
+ mTestObject->initialize(mStubModel);
+ mTestObject->open(VideoCollectionCommon::ELevelVideos);
+ mTestObject->setGenericIdFilter(TMPXItemId(0,1), true);
+
+ mStubModel->appendData(TMPXItemId(1,0));
+ mStubModel->appendData(TMPXItemId(2,0));
+ mStubModel->appendData(TMPXItemId(3,0));
+ mTestObject->invalidate();
+ QModelIndex index;
+ index = mTestObject->indexOfId(TMPXItemId(1,0));
+ QVERIFY(index.isValid());
+ QVERIFY(index.row() == 0);
+
+ // other type
+ delete mTestObject;
+ mTestObject = new FilterProxyTester(VideoCollectionWrapper::EAllVideos);
+ mTestObject->initialize(mStubModel);
+ mTestObject->open(VideoCollectionCommon::ELevelVideos);
+
+ mTestObject->setGenericIdFilter(TMPXItemId(1,1), true);
+ mTestObject->invalidate();
+ index = mTestObject->indexOfId(TMPXItemId(1,0));
+ QVERIFY(index.isValid());
+ QVERIFY(index.row() == 0);
+
+}
+
+
+// End of file