1 /**

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Unit test for methods in VideoThumbnailDataPrivate

    15 *

    16 */

    17 

    18 // INCLUDES

    19 #include <hbapplication.h>

    20 #include <hbinstance.h>

    21 #include <qicon.h>

    22 #include <qpair.h>

    23 #include <qpointer.h>

    24 #include <qlist.h>

    25 #include <qvariant.h>

    26 #include "qmetatype.h"

    27 #include <vcxmyvideosdefs.h>

    28 

    29 #include "testvideothumbnaildata_p.h"

    30 #include "videothumbnailfetcher.h"

    31 #include "videosortfilterproxymodel.h"

    32 #include "videocollectionwrapper.h"

    33 

    34 #include "e32std.h"

    35 

    36 #define private public

    37 #define protected public

    38 #include "videothumbnaildatatester.h"

    39 #undef private

    40 #undef protected

    41 

    42 #include "videothumbnaildata_p.h"

    43 

    44 const int TB_PRIORITY = 1000;

    45 

    46 // following constants are copied from videothumbnaildata.cpp

    47 // Maximum thumbnails kept in memory.

    48 const int THUMBNAIL_CACHE_SIZE = 60;

    49 // Maximum of thumbnail fetches done at one background fetch round.

    50 const int THUMBNAIL_BACKGROUND_FETCH_AMOUNT = 20;

    51 // Milliseconds for the background fetch timer.

    52 const int THUMBNAIL_BACKGROUND_TIMEOUT = 100;

    53 // Milliseconds while thumbnail ready events are gathered before they 

    54 // are signaled.

    55 const int THUMBNAIL_READY_SIGNAL_TIMEOUT = 50;

    56 // Priority for background thumbnail fetches.

    57 const int BACKGROUND_FETCH_PRIORITY = 3000;

    58 

    59 Q_DECLARE_METATYPE(QList<TMPXItemId>)

    60 

    61 /**

    62  * global qHash function required fo creating hash values for TMPXItemId -keys

    63  */

    64 inline uint qHash(TMPXItemId key) 

    65 { 

    66     QPair<uint, uint> keyPair(key.iId1, key.iId2); 

    67 

    68     return qHash(keyPair);

    69 }

    70 

    71 // ---------------------------------------------------------------------------

    72 // main

    73 // ---------------------------------------------------------------------------

    74 //

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

    76 {

    77     HbApplication app(argc, argv);

    78     HbMainWindow window;

    79 

    80     TestVideoThumbnailData_p tv;

    81 

    82     int res;

    83     if(argc > 1)

    84     {   

    85         res = QTest::qExec(&tv, argc, argv);

    86     }

    87     else

    88     {

    89         char *pass[3];

    90         pass[0] = argv[0];

    91         pass[1] = "-o";

    92         pass[2] = "c:\\data\\TestVideoThumbnailData_p.txt";

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

    94     }

    95 

    96     return res;

    97 }

    98 

    99 // ---------------------------------------------------------------------------

   100 // init

   101 // ---------------------------------------------------------------------------

   102 //

   103 void TestVideoThumbnailData_p::init()

   104 {

   105     VideoCollectionWrapper::mReferenceCount = 0;

   106 

   107     VideoThumbnailFetcher::mConstructorCallCount = 0;

   108     VideoThumbnailFetcher::mDestructorCallCount = 0;

   109     VideoThumbnailFetcher::mAddFetchCallCount = 0;

   110     VideoThumbnailFetcher::mCancelFetchesCallCount = 0;

   111     VideoThumbnailFetcher::mFetchCountCallCount = 0;

   112     VideoThumbnailFetcher::mPauseFetchingCallCount = 0;

   113     VideoThumbnailFetcher::mContinueFetchingCallCount = 0;

   114     VideoThumbnailFetcher::mEnableThumbnailCreationCallCount = 0;

   115     VideoThumbnailFetcher::mAddFetchFails = false;

   116     VideoThumbnailFetcher::mThumbnailReadyError = 0;

   117     

   118     mModel = new VideoSortFilterProxyModel();

   119     VideoCollectionWrapper::instance().setModel(mModel);

   120     mTestObject = new VideoThumbnailDataTester();

   121     mTestObject->initialize();

   122     mTestObject->mCurrentModel = mModel;

   123     

   124     VideoSortFilterProxyModel::mReturnInvalidIndexes = false;

   125     VideoSortFilterProxyModel::mRowCountCallCount = 0;

   126     qRegisterMetaType<QList<TMPXItemId> >("QList<TMPXItemId>");

   127 }

   128 

   129 // ---------------------------------------------------------------------------

   130 // cleanup

   131 // ---------------------------------------------------------------------------

   132 //

   133 void TestVideoThumbnailData_p::cleanup()

   134 {

   135     delete mTestObject; mTestObject = 0;

   136 }

   137 

   138 // ---------------------------------------------------------------------------

   139 // checkThumbnailReadyCount

   140 // ---------------------------------------------------------------------------

   141 //

   142 bool TestVideoThumbnailData_p::checkThumbnailReadyCount(QSignalSpy *spy, int count)

   143 {

   144     if(!mTestObject || !spy) 

   145         {

   146         qWarning("TestVideoThumbnailData_p::checkThumbnailReadyCount: error, mTestObject = %d, spy = %d", mTestObject, spy); 

   147         return false;

   148         }

   149     mTestObject->emitReportThumbnailsReady();

   150     if(spy->count() != 1)

   151     {

   152         qWarning("TestVideoThumbnailData_p::checkThumbnailReadyCount: error, spy->count() is %d, 1 was expected.", spy->count());

   153         return false;

   154     }

   155     QList<TMPXItemId> mediaIds = qvariant_cast<QList<TMPXItemId> >(spy->at(0).at(0));

   156     return mediaIds.count() == count;

   157 }

   158 

   159 // ---------------------------------------------------------------------------

   160 // testDestructor

   161 // ---------------------------------------------------------------------------

   162 //

   163 void TestVideoThumbnailData_p::testDestructor()

   164 {

   165     mWrapper = 0;

   166     

   167     mTestObject = new VideoThumbnailDataTester();

   168     delete mTestObject; mTestObject = 0;

   169     

   170     //TODO

   171 }

   172 

   173 // ---------------------------------------------------------------------------

   174 // testInitialize

   175 // ---------------------------------------------------------------------------

   176 //

   177 void TestVideoThumbnailData_p::testInitialize()

   178 {

   179     VideoCollectionWrapper::instance().setModel(0);

   180 

   181     mTestObject = new VideoThumbnailDataTester();

   182     QVERIFY(mTestObject->mThumbnailFetcher == 0);

   183     QVERIFY(mTestObject->mCurrentModel == 0);

   184     QVERIFY(mTestObject->mBgFetchTimer == 0);

   185     cleanup();

   186 

   187     mTestObject = new VideoThumbnailDataTester();

   188     mTestObject->disconnectSignals();

   189     delete mTestObject->mBgFetchTimer;

   190     mTestObject->mBgFetchTimer = 0;

   191     delete mTestObject->mThumbnailFetcher;

   192     mTestObject->mThumbnailFetcher = 0;

   193     mTestObject->mCurrentModel = 0;

   194 

   195     mTestObject->initialize();

   196     QVERIFY(mTestObject->mThumbnailFetcher == 0);

   197     QVERIFY(mTestObject->mCurrentModel == 0);

   198     QVERIFY(mTestObject->mBgFetchTimer == 0);

   199     cleanup();

   200 

   201     init();

   202     mTestObject->initialize();

   203     mTestObject->initialize();

   204     QVERIFY(mTestObject->mThumbnailFetcher != 0);

   205     QVERIFY(mTestObject->mCurrentModel != 0);

   206     QVERIFY(mTestObject->mBgFetchTimer != 0);

   207     QCOMPARE( mTestObject->mThumbnailFetcher->mConstructorCallCount, 1);

   208     cleanup();

   209 }

   210 

   211 // ---------------------------------------------------------------------------

   212 // testGetThumbnail

   213 // ---------------------------------------------------------------------------

   214 //

   215 void TestVideoThumbnailData_p::testGetThumbnail()

   216 {

   217 

   218     int mediaid(50);

   219     QPixmap pixmap(100,100);

   220     pixmap.fill(Qt::blue);

   221 

   222     init();

   223 

   224     mTestObject->mThumbnailData.insert(TMPXItemId(mediaid, 0), new QIcon(pixmap));

   225     QCOMPARE( *(mTestObject->getThumbnail(TMPXItemId(mediaid, 0))), *(mTestObject->mThumbnailData[TMPXItemId(mediaid, 0)]) );

   226     QVERIFY( mTestObject->getThumbnail(TMPXItemId(mediaid+100, 0)) != 0);

   227 

   228     cleanup();

   229 }

   230 

   231 // ---------------------------------------------------------------------------

   232 // testStartFetchingThumbnail

   233 // ---------------------------------------------------------------------------

   234 //

   235 void TestVideoThumbnailData_p::testStartFetchingThumbnail()

   236 {

   237     QSignalSpy* spy = 0;

   238     

   239     // Tests when mModel is null.

   240     init();

   241     VideoSortFilterProxyModel* backupProxyModel = mTestObject->mCurrentModel;

   242     mTestObject->mCurrentModel = NULL;

   243     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   244     QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), -1);

   245     QVERIFY(checkThumbnailReadyCount(spy, 0));

   246     delete spy;

   247     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   248     mTestObject->mCurrentModel = backupProxyModel;

   249     cleanup();

   250 

   251     // Tests when thumbnail fetcher is null.

   252     init();

   253     VideoThumbnailFetcher* backup = mTestObject->mThumbnailFetcher;

   254     mTestObject->mThumbnailFetcher = NULL;

   255     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   256     QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), -1);

   257     QVERIFY(checkThumbnailReadyCount(spy, 0));

   258     delete spy;

   259     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   260     mTestObject->mThumbnailFetcher = backup;

   261     cleanup();

   262 

   263     // Thumbnail has been already fetched.

   264     init();

   265     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   266     mTestObject->mThumbnailData.insert(TMPXItemId(10, 0), 0);

   267     QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(10, 0), TB_PRIORITY), 0);

   268     QVERIFY(checkThumbnailReadyCount(spy, 0));

   269     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   270     delete spy;

   271     cleanup();

   272 

   273     // Thumbnail fetch request to tn fetcher fails.

   274     init();

   275     VideoThumbnailFetcher::mAddFetchFails = true;

   276     mTestObject->mCurrentModel->appendData("testfile");

   277     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   278     QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), 0);

   279     QVERIFY(checkThumbnailReadyCount(spy, 0));

   280     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   281     delete spy;

   282     cleanup();

   283 

   284     // Filename is empty.

   285     init();

   286     mTestObject->mCurrentModel->appendData("");

   287     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   288     QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), 0);

   289     QVERIFY(checkThumbnailReadyCount(spy, 0));

   290     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   291     delete spy;

   292     cleanup();

   293 

   294     // Filename is null.

   295     init();

   296     mTestObject->mCurrentModel->appendData(QString());

   297     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   298     QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), 0);

   299     QVERIFY(checkThumbnailReadyCount(spy, 0));

   300     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   301     delete spy;

   302     cleanup();

   303 

   304     VideoThumbnailFetcher::TnRequest req;

   305     

   306     // Good case.

   307     init();

   308     QString fileName("video.mp4");

   309     mTestObject->mCurrentModel->appendData(fileName);

   310     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   311     QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), 0);

   312     QVERIFY(checkThumbnailReadyCount(spy, 0));

   313     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 1);

   314     req = VideoThumbnailFetcher::mRequests[0];

   315     QVERIFY(req.name == fileName);

   316     QCOMPARE(req.priority, TB_PRIORITY);

   317     delete spy;

   318     cleanup();

   319 

   320     // Already fetching same thumbnail.

   321     init();

   322     mTestObject->mCurrentModel->appendData(fileName);

   323     VideoThumbnailFetcher::mRequests.insert(1, VideoThumbnailFetcher::TnRequest("test1", 0, -1, false));

   324     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   325     QCOMPARE(mTestObject->startFetchingThumbnail(TMPXItemId(0, 0), TB_PRIORITY), 0);

   326     QVERIFY(checkThumbnailReadyCount(spy, 0));

   327     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 1);

   328     req = VideoThumbnailFetcher::mRequests[1];

   329     QVERIFY(req.name == fileName);

   330     QCOMPARE(req.priority, TB_PRIORITY);

   331     delete spy;

   332     cleanup();

   333 }

   334 

   335 // ---------------------------------------------------------------------------

   336 // testStartFetchingThumbnails

   337 // ---------------------------------------------------------------------------

   338 //

   339 void TestVideoThumbnailData_p::testStartFetchingThumbnails()

   340 {

   341     VideoThumbnailFetcher::TnRequest req;

   342     QList<QModelIndex> indexes;

   343     QSignalSpy* spy = 0;

   344     

   345     // Tests when mModel is null.

   346     init();

   347     indexes.clear();

   348     indexes.append(mTestObject->mCurrentModel->index(0, 0, QModelIndex()));

   349     indexes.append(mTestObject->mCurrentModel->index(10, 0, QModelIndex()));

   350     indexes.append(mTestObject->mCurrentModel->index(20, 0, QModelIndex()));

   351     VideoSortFilterProxyModel* backupProxyModel = mTestObject->mCurrentModel;

   352     mTestObject->mCurrentModel = NULL;

   353     

   354     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   355     QCOMPARE(mTestObject->startFetchingThumbnails(indexes,

   356             BACKGROUND_FETCH_PRIORITY), -1);

   357     QVERIFY(checkThumbnailReadyCount(spy, 0));

   358     delete spy;

   359     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   360     mTestObject->mCurrentModel = backupProxyModel;

   361     QVERIFY(mTestObject->mCurrentFetchIndex == 0);

   362     cleanup();

   363 

   364     // Tests when mThumbnailFetcher is null.

   365     init();

   366     indexes.clear();

   367     VideoThumbnailFetcher* backup = mTestObject->mThumbnailFetcher;

   368     mTestObject->mThumbnailFetcher = NULL;

   369     indexes.append(mTestObject->mCurrentModel->index(0, 0, QModelIndex()));

   370     indexes.append(mTestObject->mCurrentModel->index(10, 0, QModelIndex()));

   371     indexes.append(mTestObject->mCurrentModel->index(20, 0, QModelIndex()));

   372     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   373     QCOMPARE(mTestObject->startFetchingThumbnails(indexes,

   374             BACKGROUND_FETCH_PRIORITY), -1);

   375     QVERIFY(checkThumbnailReadyCount(spy, 0));

   376     delete spy;

   377     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   378     mTestObject->mThumbnailFetcher = backup;

   379     QVERIFY(mTestObject->mCurrentFetchIndex == 0);

   380     cleanup();

   381 

   382     // Tests when parameter array indexes is empty.

   383     init();

   384     indexes.clear();

   385     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   386     QCOMPARE(mTestObject->startFetchingThumbnails(indexes,

   387             BACKGROUND_FETCH_PRIORITY), 0);

   388     QVERIFY(checkThumbnailReadyCount(spy, 0));

   389     delete spy;

   390     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   391     QVERIFY(mTestObject->mCurrentFetchIndex == 0);

   392     cleanup();

   393 

   394     // Already fetching some thumbnails.

   395     init();

   396     QString fileName("video.mp4");

   397     mTestObject->mCurrentModel->appendData(fileName);

   398     indexes.clear();

   399     VideoThumbnailFetcher::mRequests[50] = VideoThumbnailFetcher::TnRequest("test1", 0, -1, false);

   400     VideoThumbnailFetcher::mRequests[40] = VideoThumbnailFetcher::TnRequest("test2", 0, -1, false);

   401     VideoThumbnailFetcher::mRequests[30] = VideoThumbnailFetcher::TnRequest("test3", 0, -1, false);

   402     indexes.append(mTestObject->mCurrentModel->index(0, 0, QModelIndex()));

   403     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   404     QCOMPARE(mTestObject->startFetchingThumbnails(indexes,

   405             BACKGROUND_FETCH_PRIORITY), 1);

   406     QVERIFY(checkThumbnailReadyCount(spy, 0));

   407     delete spy;

   408     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 4);

   409     

   410     req = VideoThumbnailFetcher::mRequests[50];

   411     QVERIFY(req.name == "test1");

   412     QCOMPARE(req.priority, -1);

   413     

   414     req = VideoThumbnailFetcher::mRequests[40];

   415     QVERIFY(req.name == "test2");

   416     QCOMPARE(req.priority, -1);

   417     

   418     req = VideoThumbnailFetcher::mRequests[30];

   419     QVERIFY(req.name == "test3");

   420     QCOMPARE(req.priority, -1);

   421     

   422     req = VideoThumbnailFetcher::mRequests[3];

   423     QVERIFY(req.name == fileName);

   424     QCOMPARE(req.priority, static_cast<int>(BACKGROUND_FETCH_PRIORITY));

   425     

   426     VideoThumbnailFetcher::mRequests.clear();

   427     QVERIFY(mTestObject->mCurrentFetchIndex == 0);

   428     cleanup();

   429 

   430     // Ok case

   431     init();

   432     mTestObject->mCurrentModel->appendData("file1");

   433     mTestObject->mCurrentModel->appendData("file2");

   434     mTestObject->mCurrentModel->appendData("file3");

   435     mTestObject->mCurrentModel->appendData("file4");

   436     mTestObject->mCurrentModel->appendData("file5");

   437     mTestObject->mCurrentModel->appendData("file6");

   438     indexes.clear();

   439     indexes.append(mTestObject->mCurrentModel->index(2, 0, QModelIndex()));

   440     indexes.append(mTestObject->mCurrentModel->index(3, 0, QModelIndex()));

   441     indexes.append(mTestObject->mCurrentModel->index(4, 0, QModelIndex()));

   442     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   443     QCOMPARE(mTestObject->startFetchingThumbnails(indexes,

   444             BACKGROUND_FETCH_PRIORITY), 3);

   445     QVERIFY(checkThumbnailReadyCount(spy, 0));

   446     delete spy;

   447     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 3);

   448 

   449     req = VideoThumbnailFetcher::mRequests[0];

   450     QVERIFY(req.name == "file3");

   451     QCOMPARE(req.priority, static_cast<int>(BACKGROUND_FETCH_PRIORITY));

   452     

   453     req = VideoThumbnailFetcher::mRequests[1];

   454     QVERIFY(req.name == "file4");

   455     QCOMPARE(req.priority, static_cast<int>(BACKGROUND_FETCH_PRIORITY) - 1);

   456     

   457     req = VideoThumbnailFetcher::mRequests[2];

   458     QVERIFY(req.name == "file5");

   459     QCOMPARE(req.priority, static_cast<int>(BACKGROUND_FETCH_PRIORITY) - 2);

   460     cleanup();

   461 }

   462 

   463 // ---------------------------------------------------------------------------

   464 // testDoBackgroundFetching

   465 // ---------------------------------------------------------------------------

   466 //

   467 void TestVideoThumbnailData_p::testDoBackgroundFetching()

   468 {

   469     VideoThumbnailFetcher::TnRequest req;

   470     QSignalSpy* spy = 0;

   471     

   472     // Tests when mModel is null.

   473     init();

   474     VideoSortFilterProxyModel* backupProxyModel = mTestObject->mCurrentModel;

   475     mTestObject->mCurrentModel = NULL;

   476     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   477     mTestObject->emitDoBackgroundFetching();

   478     QVERIFY(checkThumbnailReadyCount(spy, 0));

   479     delete spy;

   480     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   481     mTestObject->mCurrentModel = backupProxyModel;

   482     QVERIFY(mTestObject->mCurrentFetchIndex == 0);

   483     QCOMPARE(VideoSortFilterProxyModel::mRowCountCallCount, 0);

   484     cleanup();

   485 

   486     // Tests when mThumbnailFetcher is null.

   487     init();

   488     VideoThumbnailFetcher* backup = mTestObject->mThumbnailFetcher;

   489     mTestObject->mThumbnailFetcher = NULL;

   490     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   491     mTestObject->emitDoBackgroundFetching();

   492     QVERIFY(checkThumbnailReadyCount(spy, 0));

   493     delete spy;

   494     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   495     mTestObject->mThumbnailFetcher = backup;

   496     QVERIFY(mTestObject->mCurrentFetchIndex == 0);

   497     cleanup();

   498 

   499     // THUMBNAIL_BACKGROUND_FETCH_AMOUNT items in model and fetch index at 0

   500     init();

   501     for(int i = 0; i < THUMBNAIL_BACKGROUND_FETCH_AMOUNT; i++)

   502     {

   503         mTestObject->mCurrentModel->appendData(QString("file") + QString::number(i));

   504     }

   505     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   506     mTestObject->emitDoBackgroundFetching();

   507     QVERIFY(checkThumbnailReadyCount(spy, 0));

   508     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2);

   509     int previousPriority = -1;

   510     for(int i = 0; i < THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2; i++)

   511     {

   512         req = VideoThumbnailFetcher::mRequests[i];

   513         QVERIFY(req.name == "file" + QString::number(i));

   514         if(previousPriority != -1)

   515         {

   516             QVERIFY(previousPriority > req.priority);    

   517         }

   518         previousPriority = req.priority;

   519         QVERIFY(previousPriority != -1);

   520     }

   521     QVERIFY(mTestObject->mCurrentFetchIndex == 0);

   522     QVERIFY(mTestObject->mCurrentBackgroundFetchCount == THUMBNAIL_BACKGROUND_FETCH_AMOUNT);

   523     QVERIFY(mTestObject->mBgFetchTimer->isActive() == false);

   524 

   525     // Continue fetching.

   526     spy->clear();

   527     mTestObject->emitDoBackgroundFetching();

   528     QVERIFY(checkThumbnailReadyCount(spy, 0));

   529     // Now all thumbnails are being fetched.

   530     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), THUMBNAIL_BACKGROUND_FETCH_AMOUNT);

   531     for(int i = 0; i < THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2; i++)

   532     {

   533         req = VideoThumbnailFetcher::mRequests[i];

   534         QVERIFY(req.name == "file" + QString::number(i));

   535 

   536         req = VideoThumbnailFetcher::mRequests[i+5];

   537         QVERIFY(req.name == "file" + QString::number(i+5));

   538     }

   539 

   540     QVERIFY(mTestObject->mCurrentFetchIndex == 0);

   541     QVERIFY(mTestObject->mCurrentBackgroundFetchCount == THUMBNAIL_BACKGROUND_FETCH_AMOUNT * 2);

   542     QVERIFY(mTestObject->mBgFetchTimer->isActive() == false);

   543 

   544     delete spy;

   545     cleanup();

   546 

   547     // THUMBNAIL_BACKGROUND_FETCH_AMOUNT items in model and fetch index negative

   548     init();

   549     for(int i = 0; i < THUMBNAIL_BACKGROUND_FETCH_AMOUNT; i++)

   550     {

   551         mTestObject->mCurrentModel->appendData(QString("file") + QString::number(i));

   552     }

   553     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   554     mTestObject->mCurrentFetchIndex = THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2*-1;

   555     mTestObject->emitDoBackgroundFetching();

   556     QVERIFY(checkThumbnailReadyCount(spy, 0));

   557     delete spy;

   558     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   559     QVERIFY(mTestObject->mCurrentFetchIndex == THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2*-1);

   560     QVERIFY(mTestObject->mBgFetchTimer->isActive() == true);

   561     cleanup();

   562 

   563     // THUMBNAIL_BACKGROUND_FETCH_AMOUNT*2 items in model and fetch index at end

   564     init();

   565     for(int i = 0; i < THUMBNAIL_BACKGROUND_FETCH_AMOUNT*2; i++)

   566     {

   567         mTestObject->mCurrentModel->appendData(QString("file") + QString::number(i));

   568     }

   569     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   570     mTestObject->mCurrentFetchIndex = THUMBNAIL_BACKGROUND_FETCH_AMOUNT*2;

   571     mTestObject->emitDoBackgroundFetching();

   572     QVERIFY(checkThumbnailReadyCount(spy, 0));

   573     delete spy;

   574     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2);

   575     QVERIFY(mTestObject->mCurrentFetchIndex == THUMBNAIL_BACKGROUND_FETCH_AMOUNT*2);

   576     QVERIFY(mTestObject->mBgFetchTimer->isActive() == false);

   577     cleanup();

   578 

   579     // THUMBNAIL_BACKGROUND_FETCH_AMOUNT items in model and fetch index over the end

   580     init();

   581     for(int i = 0; i < THUMBNAIL_BACKGROUND_FETCH_AMOUNT; i++)

   582     {

   583         mTestObject->mCurrentModel->appendData(QString("file") + QString::number(i));

   584     }

   585     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   586     mTestObject->mCurrentFetchIndex = THUMBNAIL_BACKGROUND_FETCH_AMOUNT + THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2;

   587     mTestObject->emitDoBackgroundFetching();

   588     QVERIFY(checkThumbnailReadyCount(spy, 0));

   589     delete spy;

   590     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   591     QVERIFY(mTestObject->mCurrentFetchIndex == THUMBNAIL_BACKGROUND_FETCH_AMOUNT + THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2);

   592     QVERIFY(mTestObject->mBgFetchTimer->isActive() == true);

   593     cleanup();

   594 

   595     // no items and fetch index -5

   596     init();

   597     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   598     mTestObject->mCurrentFetchIndex = -5;

   599     mTestObject->emitDoBackgroundFetching();

   600     QVERIFY(checkThumbnailReadyCount(spy, 0));

   601     delete spy;

   602     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   603     QVERIFY(mTestObject->mCurrentFetchIndex == -5);

   604     QVERIFY(mTestObject->mBgFetchTimer->isActive() == false);

   605     cleanup();

   606 

   607     // Model returns invalid indexes.

   608     init();

   609     for(int i = 0; i < THUMBNAIL_BACKGROUND_FETCH_AMOUNT; i++)

   610     {

   611         mTestObject->mCurrentModel->appendData(QString("file") + QString::number(i));

   612     }

   613     spy = new QSignalSpy(mTestObject, SIGNAL(thumbnailsFetched(QList<TMPXItemId>)));

   614     VideoSortFilterProxyModel::mReturnInvalidIndexes = true;

   615     mTestObject->mCurrentFetchIndex = THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2;

   616     mTestObject->emitDoBackgroundFetching();

   617     QVERIFY(checkThumbnailReadyCount(spy, 0));

   618     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   619     QVERIFY(mTestObject->mCurrentFetchIndex == THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2);

   620     QVERIFY(mTestObject->mCurrentBackgroundFetchCount == THUMBNAIL_BACKGROUND_FETCH_AMOUNT);

   621     QVERIFY(mTestObject->mBgFetchTimer->isActive() == true);

   622 }

   623 

   624 // ---------------------------------------------------------------------------

   625 // testThumbnailReadySlot

   626 // ---------------------------------------------------------------------------

   627 //

   628 void TestVideoThumbnailData_p::testThumbnailReadySlot()

   629 {

   630     init();

   631     

   632     int error = 0;

   633     void *internal = 0;

   634     QPixmap nullpmap;

   635     QIcon icon(":/icons/default_thumbnail.svg");

   636     QPixmap pmap = icon.pixmap(500, 500);

   637     

   638     // Internal is null and error.

   639     mTestObject->mThumbnailFetcher->emitThumbnailReady(pmap, internal, error);

   640     QCOMPARE(mTestObject->mThumbnailData.count(), 0);

   641     QCOMPARE(mTestObject->mReadyThumbnailMediaIds.count(), 0);

   642     QVERIFY(!mTestObject->mTbnReportTimer->isActive());

   643     

   644     // Internal is not null but there's error.

   645     internal = (void *)new TMPXItemId(5, 5);

   646     error = -5;

   647     mTestObject->mThumbnailFetcher->emitThumbnailReady(pmap, internal, error);

   648     QCOMPARE(mTestObject->mThumbnailData.count(), 0);

   649     QCOMPARE(mTestObject->mReadyThumbnailMediaIds.count(), 0);

   650     QVERIFY(!mTestObject->mTbnReportTimer->isActive());

   651     

   652     // Pixmap is null.

   653     internal = (void *)new TMPXItemId(5, 5);

   654     error = 0;

   655     mTestObject->mThumbnailFetcher->emitThumbnailReady(nullpmap, internal, error);

   656     QCOMPARE(mTestObject->mThumbnailData.count(), 0);

   657     QCOMPARE(mTestObject->mReadyThumbnailMediaIds.count(), 0);

   658     QVERIFY(!mTestObject->mTbnReportTimer->isActive());

   659     cleanup();

   660     

   661     // Good case.

   662     init();

   663     internal = (void *)new TMPXItemId(5, 5);

   664     error = 0;

   665     mTestObject->mThumbnailFetcher->emitThumbnailReady(pmap, internal, error);

   666     QCOMPARE(mTestObject->mThumbnailData.count(), 1);

   667     QCOMPARE(mTestObject->mReadyThumbnailMediaIds.count(), 1);

   668     QVERIFY(mTestObject->mTbnReportTimer->isActive());

   669     cleanup();

   670     

   671     // Good case, thumbnail report timer already running.

   672     init();

   673     internal = (void *)new TMPXItemId(5, 5);

   674     error = 0;

   675     mTestObject->mTbnReportTimer->start(1000000);

   676     mTestObject->mThumbnailFetcher->emitThumbnailReady(pmap, internal, error);

   677     QCOMPARE(mTestObject->mThumbnailData.count(), 1);

   678     QCOMPARE(mTestObject->mReadyThumbnailMediaIds.count(), 1);

   679     QVERIFY(mTestObject->mTbnReportTimer->isActive());

   680     cleanup();

   681     

   682     // Thumbnail report timer is null.

   683     init();

   684     internal = (void *)new TMPXItemId(5, 5);

   685     error = 0;

   686     QTimer *backup = mTestObject->mTbnReportTimer;

   687     mTestObject->mTbnReportTimer = 0;

   688     mTestObject->mThumbnailFetcher->emitThumbnailReady(pmap, internal, error);

   689     QCOMPARE(mTestObject->mThumbnailData.count(), 1);

   690     QCOMPARE(mTestObject->mReadyThumbnailMediaIds.count(), 1);

   691     mTestObject->mTbnReportTimer = backup;

   692     cleanup();

   693 }

   694 

   695 // ---------------------------------------------------------------------------

   696 // testDefaultThumbnail

   697 // ---------------------------------------------------------------------------

   698 //

   699 void TestVideoThumbnailData_p::testDefaultThumbnail()

   700 {

   701     init();

   702 

   703     QVERIFY(mTestObject->mDefaultThumbnails.count() == 0);

   704     

   705     // Tn for video

   706     const QIcon* tn = mTestObject->defaultThumbnail(TMPXItemId(1, KVcxMvcMediaTypeVideo));

   707     QVERIFY( tn != 0 );

   708     QVERIFY( tn->isNull() == false );    

   709     // Second call when tn has been loaded already.

   710     QVERIFY(tn == mTestObject->defaultThumbnail(TMPXItemId(1, KVcxMvcMediaTypeVideo)));

   711     QVERIFY(mTestObject->mDefaultThumbnails.count() == 1);

   712 

   713     // Default tn for album

   714     tn = mTestObject->defaultThumbnail(TMPXItemId(0, KVcxMvcMediaTypeAlbum));

   715     QVERIFY( tn != 0 );

   716     QVERIFY( tn->isNull() == false );

   717     // Second call when tn has been loaded already.

   718     QVERIFY(tn == mTestObject->defaultThumbnail(TMPXItemId(0, KVcxMvcMediaTypeAlbum)));

   719     QVERIFY(mTestObject->mDefaultThumbnails.count() == 2);

   720     

   721     // Default tn for unknown category

   722     tn = mTestObject->defaultThumbnail(TMPXItemId(555, KVcxMvcMediaTypeCategory));

   723     QVERIFY( tn != 0 );

   724     QVERIFY( tn->isNull() == false );

   725     // Second call when tn has been loaded already.

   726     QVERIFY(tn == mTestObject->defaultThumbnail(TMPXItemId(0, KVcxMvcMediaTypeCategory))); 

   727     // Still two because icon is same as default album 

   728     QVERIFY(mTestObject->mDefaultThumbnails.count() == 2);

   729 

   730     // Default tn for downloads category

   731     tn = mTestObject->defaultThumbnail(TMPXItemId(KVcxMvcCategoryIdDownloads, KVcxMvcMediaTypeCategory));

   732     QVERIFY( tn != 0 );

   733     QVERIFY( tn->isNull() == false );

   734     // Second call when tn has been loaded already.

   735     QVERIFY(tn == mTestObject->defaultThumbnail(TMPXItemId(KVcxMvcCategoryIdDownloads, KVcxMvcMediaTypeCategory))); 

   736     QVERIFY(mTestObject->mDefaultThumbnails.count() == 3);

   737 

   738     // Default tn for captured category

   739     tn = mTestObject->defaultThumbnail(TMPXItemId(KVcxMvcCategoryIdCaptured, KVcxMvcMediaTypeCategory));

   740     QVERIFY( tn != 0 );

   741     QVERIFY( tn->isNull() == false );

   742     // Second call when tn has been loaded already.

   743     QVERIFY(tn == mTestObject->defaultThumbnail(TMPXItemId(KVcxMvcCategoryIdCaptured, KVcxMvcMediaTypeCategory))); 

   744     QVERIFY(mTestObject->mDefaultThumbnails.count() == 4);    

   745     

   746     cleanup();

   747     

   748 

   749     init();

   750 

   751     QVERIFY(mTestObject->mDefaultThumbnails.count() == 0);

   752 

   753     // Default tn for unknown category, tn not loaded

   754     tn = mTestObject->defaultThumbnail(TMPXItemId(555, KVcxMvcMediaTypeCategory));

   755     QVERIFY( tn != 0 );

   756     QVERIFY( tn->isNull() == false );

   757     // Second call when tn has been loaded already.

   758     QVERIFY(tn == mTestObject->defaultThumbnail(TMPXItemId(0, KVcxMvcMediaTypeCategory))); 

   759     // Still two because icon is same as default album 

   760     QVERIFY(mTestObject->mDefaultThumbnails.count() == 1);

   761     

   762     cleanup();

   763 }

   764 

   765 // ---------------------------------------------------------------------------

   766 // testRemoveThumbnail

   767 // ---------------------------------------------------------------------------

   768 //

   769 void TestVideoThumbnailData_p::testRemoveThumbnail()

   770 {

   771     init();

   772 

   773     TMPXItemId id1(1, 0);

   774     TMPXItemId id2(2, 0);

   775     TMPXItemId id3(3, 0);

   776     TMPXItemId id4(4, 0);

   777     

   778     mTestObject->mThumbnailData.insert(id2, new QIcon());

   779     mTestObject->mThumbnailData.insert(id3, new QIcon());

   780 

   781     QCOMPARE( mTestObject->removeThumbnail(id1), 0 );

   782     QCOMPARE( mTestObject->removeThumbnail(id2), 1 );

   783     QCOMPARE( mTestObject->removeThumbnail(id3), 1 );

   784     QCOMPARE( mTestObject->removeThumbnail(id4), 0 );

   785 

   786     QVERIFY( mTestObject->mThumbnailData.contains(id2) == false );

   787     QVERIFY( mTestObject->mThumbnailData.contains(id3) == false );

   788 

   789     cleanup();

   790 }

   791 

   792 // ---------------------------------------------------------------------------

   793 // testModelChangedSlot

   794 // ---------------------------------------------------------------------------

   795 //

   796 void TestVideoThumbnailData_p::testModelChangedSlot()

   797 {

   798     // Empty list.

   799     init();

   800     mTestObject->emitModelChanged();

   801     QVERIFY(mTestObject->mCurrentFetchIndex == 0);

   802     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   803     QVERIFY(mTestObject->mCurrentBackgroundFetchCount == 0);

   804     QVERIFY(mTestObject->mBgFetchTimer->isActive() == false);

   805     cleanup();

   806 

   807     // THUMBNAIL_BACKGROUND_FETCH_AMOUNT items in model and fetch index at 0

   808     init();

   809     for(int i = 0; i < THUMBNAIL_BACKGROUND_FETCH_AMOUNT; i++)

   810     {

   811         mTestObject->mCurrentModel->appendData(QString("file") + QString::number(i));

   812     }

   813     mTestObject->emitModelChanged();

   814     QVERIFY(mTestObject->mCurrentFetchIndex == 0);

   815     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), THUMBNAIL_BACKGROUND_FETCH_AMOUNT/2);

   816     QVERIFY(mTestObject->mCurrentBackgroundFetchCount == THUMBNAIL_BACKGROUND_FETCH_AMOUNT);

   817     QVERIFY(mTestObject->mBgFetchTimer->isActive() == false);

   818     cleanup();

   819 }

   820 

   821 // ---------------------------------------------------------------------------

   822 // testStartBackgroundFetching

   823 // ---------------------------------------------------------------------------

   824 //

   825 void TestVideoThumbnailData_p::testStartBackgroundFetching()

   826 {

   827     init();

   828 

   829     // Bg fetch enabled

   830     mTestObject->mBackgroundFetchingEnabled = true;

   831     mTestObject->mCurrentFetchIndex = -5;

   832     mTestObject->startBackgroundFetching(0, 10);

   833     QVERIFY(mTestObject->mCurrentFetchIndex == 10);

   834 

   835     // Bg fetch disabled

   836     mTestObject->mBackgroundFetchingEnabled = false;

   837     mTestObject->mCurrentFetchIndex = -5;

   838     mTestObject->startBackgroundFetching(0, 10);

   839     QVERIFY(mTestObject->mCurrentFetchIndex == -5);

   840     

   841     // Set new model.

   842     mTestObject->mBackgroundFetchingEnabled = true;

   843     VideoSortFilterProxyModel *model = mTestObject->mCurrentModel; 

   844     mTestObject->mCurrentModel = 0;

   845     mTestObject->mCurrentFetchIndex = -5;

   846     mTestObject->startBackgroundFetching(model, 10);

   847     QVERIFY(mTestObject->mCurrentFetchIndex == 10);    

   848     QVERIFY(mTestObject->mCurrentModel != 0);

   849     

   850     cleanup();

   851 }

   852 

   853 // ---------------------------------------------------------------------------

   854 // testEnableBackgroundFetching

   855 // ---------------------------------------------------------------------------

   856 //

   857 void TestVideoThumbnailData_p::testEnableBackgroundFetching()

   858 {

   859     init();

   860 

   861     // Default

   862     QVERIFY(mTestObject->mBackgroundFetchingEnabled == true);

   863     

   864     // Disable

   865     mTestObject->mCurrentFetchIndex = -1;

   866     mTestObject->enableBackgroundFetching(false);

   867     QVERIFY(mTestObject->mBackgroundFetchingEnabled == false);

   868     QCOMPARE(mTestObject->mCurrentFetchIndex, -1);

   869     

   870     mTestObject->mBgFetchTimer->setSingleShot(false);

   871     mTestObject->continueBackgroundFetch();

   872     QVERIFY(mTestObject->mBgFetchTimer->isSingleShot() == false);

   873     

   874     // Enabled

   875     mTestObject->mCurrentFetchIndex = -1;

   876 

   877     mTestObject->enableBackgroundFetching(true);

   878     QVERIFY(mTestObject->mBackgroundFetchingEnabled == true);    

   879     QCOMPARE(mTestObject->mCurrentFetchIndex, 0);

   880     

   881     mTestObject->mBgFetchTimer->setSingleShot(false);

   882     mTestObject->continueBackgroundFetch();

   883     QVERIFY(mTestObject->mBgFetchTimer->isSingleShot() == true);

   884     

   885     cleanup();

   886 }

   887 

   888 // ---------------------------------------------------------------------------

   889 // testFreeThumbnailData

   890 // ---------------------------------------------------------------------------

   891 //

   892 void TestVideoThumbnailData_p::testFreeThumbnailData()

   893 {

   894     init();

   895 

   896     mTestObject->getThumbnail(TMPXItemId(1, 0));

   897     mTestObject->getThumbnail(TMPXItemId(0, 1));

   898     QVERIFY(mTestObject->mDefaultThumbnails.count() > 0);

   899     

   900     mTestObject->freeThumbnailData();

   901     

   902     QVERIFY(!mTestObject->mBgFetchTimer->isActive());

   903     QVERIFY(!mTestObject->mTbnReportTimer->isActive());

   904     QCOMPARE(VideoThumbnailFetcher::mRequests.count(), 0);

   905     QCOMPARE(mTestObject->mReadyThumbnailMediaIds.count(), 0);

   906     QCOMPARE(mTestObject->mThumbnailData.count(), 0);

   907     

   908     QVERIFY(mTestObject->mDefaultThumbnails.count() == 0);

   909 

   910     // Call again.

   911     mTestObject->freeThumbnailData();

   912 

   913     cleanup();

   914 }

   915 

   916 // ---------------------------------------------------------------------------

   917 // testAllThumbnailsFetchedSlot

   918 // ---------------------------------------------------------------------------

   919 //

   920 void TestVideoThumbnailData_p::testAllThumbnailsFetchedSlot()

   921 {

   922     init();

   923  

   924     QVERIFY(!mTestObject->mBgFetchTimer->isActive());

   925     mTestObject->mThumbnailFetcher->emitAllThumbnailsFetched();

   926     QVERIFY(mTestObject->mBgFetchTimer->isActive());

   927     

   928     cleanup();

   929 }

   930 

   931 // ---------------------------------------------------------------------------

   932 // testEnableThumbnailCreation

   933 // ---------------------------------------------------------------------------

   934 //

   935 void TestVideoThumbnailData_p::testEnableThumbnailCreation()

   936 {

   937     init();

   938  

   939     QCOMPARE(VideoThumbnailFetcher::mEnableThumbnailCreationCallCount, 0);

   940     mTestObject->enableThumbnailCreation(false);

   941     QCOMPARE(VideoThumbnailFetcher::mEnableThumbnailCreationCallCount, 1);

   942     mTestObject->enableThumbnailCreation(true);

   943     QCOMPARE(VideoThumbnailFetcher::mEnableThumbnailCreationCallCount, 2);

   944     

   945     cleanup();

   946 }

   947 

   948 // ---------------------------------------------------------------------------

   949 // testAboutToQuitSlot

   950 // ---------------------------------------------------------------------------

   951 //

   952 void TestVideoThumbnailData_p::testAboutToQuitSlot()

   953 {

   954     init();

   955  

   956     QVERIFY(mTestObject->mThumbnailFetcher != 0);

   957     QVERIFY(mTestObject->mTbnReportTimer != 0);

   958     QVERIFY(mTestObject->mBgFetchTimer != 0);

   959     mTestObject->mReadyThumbnailMediaIds.append(TMPXItemId(0, 0));

   960     mTestObject->mThumbnailData.insert(TMPXItemId(0, 0), 0);

   961     

   962     mTestObject->emitAboutToQuit();

   963     

   964     QVERIFY(mTestObject->mThumbnailFetcher == 0);

   965     QVERIFY(mTestObject->mTbnReportTimer == 0);

   966     QVERIFY(mTestObject->mBgFetchTimer == 0);

   967     QVERIFY(mTestObject->mReadyThumbnailMediaIds.count() == 0);

   968     QVERIFY(mTestObject->mThumbnailData.count() == 0);

   969     

   970     cleanup();

   971 }

   972 // End of file