Mercurial Mercurial > oss > FCL > sf > app > videoplayer / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
videocollection/videocollectionwrapper/tsrc/testvideothumbnailfetcher/src/testvideothumbnailfetcher.cpp
changeset 20 b9e04db066d4
parent 15 cf5481c2bc0b
equal deleted inserted replaced
17:69946d1824c4 20:b9e04db066d4 
    31 #undef private
 
    31 #undef private
 
    32 #undef protected
 
    32 #undef protected
 
    33 
    33 
    34 #include "videothumbnailfetcher.h"
 
    34 #include "videothumbnailfetcher.h"
 
    35 
    35 
       
    36 /**
 
       
    37  * global qHash function required fo creating hash values for TMPXItemId -keys
 
       
    38  */
 
       
    39 inline uint qHash(TMPXItemId key) 
       
    40 { 
       
    41     QPair<uint, uint> keyPair(key.iId1, key.iId2); 
       
    42 
       
    43     return qHash(keyPair);
 
       
    44 }
 
       
    45 
    36 // ---------------------------------------------------------------------------
 
    46 // ---------------------------------------------------------------------------
 
    37 // main
 
    47 // main
 
    38 // ---------------------------------------------------------------------------
 
    48 // ---------------------------------------------------------------------------
 
    39 //
 
    49 //
 
    40 int main(int argc, char *argv[])
 
    50 int main(int argc, char *argv[])
 
    69 {
 
    79 {
 
    70     mTestObject = new VideoThumbnailFetcherTester();
 
    80     mTestObject = new VideoThumbnailFetcherTester();
 
    71     
    81     
    72     ThumbnailManager::mGetThumbFails = false;
 
    82     ThumbnailManager::mGetThumbFails = false;
 
    73     ThumbnailManager::mThumbnailReadyError = 0;
 
    83     ThumbnailManager::mThumbnailReadyError = 0;
 
       
    84     ThumbnailManager::mCancelRequestCount = 0;
 
    74 }
 
    85 }
 
    75 
    86 
    76 // ---------------------------------------------------------------------------
 
    87 // ---------------------------------------------------------------------------
 
    77 // cleanup
 
    88 // cleanup
 
    78 // ---------------------------------------------------------------------------
 
    89 // ---------------------------------------------------------------------------
 
   103 //
 
   114 //
 
   104 void TestVideoThumbnailFetcher::testAddFetch()
 
   115 void TestVideoThumbnailFetcher::testAddFetch()
 
   105 {
 
   116 {
 
   106     init();
 
   117     init();
 
   107     
   118     
   108     mTestObject->addFetch(QString(), 0, 0);
 
   119     TMPXItemId mediaId(0, 0);
 
       
   120     
       
   121     mTestObject->addFetch(QString(), mediaId, 0);
 
   109     QCOMPARE(mTestObject->mFetchList.count(), 1);
 
   122     QCOMPARE(mTestObject->mFetchList.count(), 1);
 
   110     
   123     
   111     mTestObject->addFetch("test", 0, 0);
 
       
   112     QCOMPARE(mTestObject->mFetchList.count(), 2);
 
       
   113     
       
   114     int *internal = new int;
 
       
   115     mTestObject->addFetch("test", internal, 0);
 
       
   116     QCOMPARE(mTestObject->mFetchList.count(), 3);
 
       
   117     
       
   118     cleanup();
 
   124     cleanup();
 
   119 }
 
   125 }
 
   120 
   126 
   121 // ---------------------------------------------------------------------------
 
   127 // ---------------------------------------------------------------------------
 
   122 // testCancelFetches
 
   128 // testCancelFetches
 
   123 // ---------------------------------------------------------------------------
 
   129 // ---------------------------------------------------------------------------
 
   124 //
 
   130 //
 
   125 void TestVideoThumbnailFetcher::testCancelFetches()
 
   131 void TestVideoThumbnailFetcher::testCancelFetches()
 
   126 {
 
   132 {
 
   127     init();
 
   133     init();
 
       
   134     
       
   135     TMPXItemId mediaId(0, 0);
 
   128     
   136     
   129     mTestObject->addFetch(QString(), 0, 0);
 
   137     mTestObject->addFetch(QString(), 0, 0);
 
   130     mTestObject->cancelFetches();
 
   138     mTestObject->cancelFetches();
 
   131     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   139     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   132     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);
 
   140     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);
 
   136     mTestObject->cancelFetches();
 
   144     mTestObject->cancelFetches();
 
   137     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   145     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   138     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);
 
   146     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);
 
   139     QCOMPARE(mTestObject->mCreationList.count(), 0);
 
   147     QCOMPARE(mTestObject->mCreationList.count(), 0);
 
   140     
   148     
   141     int *internal = new int;
 
   149     mTestObject->addFetch("test", mediaId, 0);
 
   142     mTestObject->addFetch("test", internal, 0);
 
       
   143     mTestObject->cancelFetches();
 
   150     mTestObject->cancelFetches();
 
   144     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   151     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   145     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);
 
   152     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);
 
   146     QCOMPARE(mTestObject->mCreationList.count(), 0);
 
   153     QCOMPARE(mTestObject->mCreationList.count(), 0);
 
   147     
   154     
   173 //
 
   180 //
 
   174 void TestVideoThumbnailFetcher::testFetchCount()
 
   181 void TestVideoThumbnailFetcher::testFetchCount()
 
   175 {
 
   182 {
 
   176     init();
 
   183     init();
 
   177 
   184 
   178     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());
 
   185     mTestObject->mFetchList.insert(TMPXItemId(0, 0), new VideoThumbnailFetcher::ThumbnailFetchData());
 
   179     QCOMPARE(mTestObject->fetchCount(), 1);
 
   186     QCOMPARE(mTestObject->fetchCount(), 1);
 
   180     
   187     
   181     mTestObject->mStartedFetchList.insert(0, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   188     mTestObject->mStartedFetchList.insert(0, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   182     QCOMPARE(mTestObject->fetchCount(), 2);
 
   189     QCOMPARE(mTestObject->fetchCount(), 2);
 
   183     
   190     
   207 // ---------------------------------------------------------------------------
 
   214 // ---------------------------------------------------------------------------
 
   208 //
 
   215 //
 
   209 void TestVideoThumbnailFetcher::testContinueFetching()
 
   216 void TestVideoThumbnailFetcher::testContinueFetching()
 
   210 {
 
   217 {
 
   211     init();
 
   218     init();
 
   212     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());
 
   219     mTestObject->mFetchList.insert(TMPXItemId(0, 0), new VideoThumbnailFetcher::ThumbnailFetchData());
 
   213     mTestObject->continueFetching();
 
   220     mTestObject->continueFetching(false);
 
   214     QCOMPARE(mTestObject->fetchCount(), 1);
 
   221     QCOMPARE(mTestObject->fetchCount(), 1);
 
   215     cleanup();
 
   222     cleanup();
 
   216     
   223     
   217     init();
 
   224     init();
 
   218     mTestObject->mCreationList.insert(0, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   225     mTestObject->mCreationList.insert(0, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   219     mTestObject->continueFetching();
 
   226     mTestObject->continueFetching(false);
 
   220     QCOMPARE(mTestObject->fetchCount(), 0);
 
   227     QCOMPARE(mTestObject->fetchCount(), 0);
 
   221     cleanup();
 
   228     cleanup();
 
   222     
   229     
   223     // Test when there's nothing to fetch 
   230     // Test when there's nothing to fetch 
   224     init();
 
   231     init();
 
   225     QSignalSpy* spy = new QSignalSpy(mTestObject, SIGNAL(allThumbnailsFetched()));
 
   232     QSignalSpy* spy = new QSignalSpy(mTestObject, SIGNAL(allThumbnailsFetched()));
 
   226     mTestObject->continueFetching();
 
   233     mTestObject->continueFetching(false);
 
   227     QCOMPARE(spy->count(), 1);
 
   234     QCOMPARE(spy->count(), 1);
 
   228     delete spy;
 
   235     delete spy;
 
   229     
   236     
   230     cleanup();
 
   237     cleanup();
 
   231 }
 
   238 }
 
   253 //
 
   260 //
 
   254 void TestVideoThumbnailFetcher::testStartThumbnailFetches()
 
   261 void TestVideoThumbnailFetcher::testStartThumbnailFetches()
 
   255 {
 
   262 {
 
   256     // Test when thumbnail manager is null.
 
   263     // Test when thumbnail manager is null.
 
   257     init();
 
   264     init();
 
   258     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());    
   265     mTestObject->mFetchList.insert(TMPXItemId(0, 0), new VideoThumbnailFetcher::ThumbnailFetchData());    
   259     delete mTestObject->mThumbnailManager;
 
   266     delete mTestObject->mThumbnailManager;
 
   260     mTestObject->mThumbnailManager = 0;
 
   267     mTestObject->mThumbnailManager = 0;
 
   261     mTestObject->startThumbnailFetches();
 
   268     mTestObject->startThumbnailFetches(false);
 
   262     QCOMPARE(mTestObject->mFetchList.count(), 1);
 
   269     QCOMPARE(mTestObject->mFetchList.count(), 1);
 
   263     cleanup();
 
   270     cleanup();
 
   264 
   271 
   265     // Test when nothing to fetch.
 
   272     // Test when nothing to fetch.
 
   266     init();
 
   273     init();
 
   267     mTestObject->startThumbnailFetches();
 
   274     mTestObject->startThumbnailFetches(false);
 
   268     QVERIFY(mTestObject->mThumbnailManager->mode() == ThumbnailManager::DoNotCreate);
 
   275     QVERIFY(mTestObject->mThumbnailManager->mode() == ThumbnailManager::DoNotCreate);
 
   269     QCOMPARE(mTestObject->fetchCount(), 0);
 
   276     QCOMPARE(mTestObject->fetchCount(), 0);
 
   270     cleanup();
 
   277     cleanup();
 
   271     
   278     
   272     // Test when there's something to fetch.
 
   279     // Test when there's something to fetch.
 
   273     init();
 
   280     init();
 
   274     for(int i = 0; i < 10; i++)
 
   281     for(int i = 0; i < 10; i++)
 
   275     {
 
   282     {
 
   276         int *internal = new int(i);
 
   283         TMPXItemId mediaId = TMPXItemId(i, i);
 
   277         mTestObject->addFetch("test", internal, i);
 
   284         mTestObject->addFetch("test", mediaId, i);
 
   278     }
 
   285     }
 
   279     QCOMPARE(mTestObject->mFetchList.count(), 10);
 
   286     QCOMPARE(mTestObject->mFetchList.count(), 10);
 
   280     mTestObject->startThumbnailFetches();
 
   287     mTestObject->startThumbnailFetches(false);
 
   281     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   288     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   282     QCOMPARE(mTestObject->mStartedFetchList.count(), 10);
 
   289     QCOMPARE(mTestObject->mStartedFetchList.count(), 10);
 
   283     QCOMPARE(mTestObject->mThumbnailManager->mRequests.count(), 10);
 
   290     QCOMPARE(mTestObject->mThumbnailManager->mRequests.count(), 10);
 
   284     cleanup();
 
   291     cleanup();
 
   285     
   292     
   286     // Test when request to thumbnail manager fails.
 
   293     // Test when request to thumbnail manager fails.
 
   287     init();
 
   294     init();
 
   288     ThumbnailManager::mGetThumbFails = true;
 
   295     ThumbnailManager::mGetThumbFails = true;
 
   289     int *internal = new int(0);
 
   296     TMPXItemId mediaId = TMPXItemId(0, 0);
 
   290     mTestObject->addFetch("test", internal, 0);
 
   297     mTestObject->addFetch("test", mediaId, 0);
 
   291     QCOMPARE(mTestObject->mFetchList.count(), 1);
 
   298     QCOMPARE(mTestObject->mFetchList.count(), 1);
 
   292     mTestObject->startThumbnailFetches();
 
   299     mTestObject->startThumbnailFetches(false);
 
   293     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   300     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   294     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);
 
   301     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);
 
   295     QCOMPARE(mTestObject->mThumbnailManager->mRequests.count(), 0);
 
   302     QCOMPARE(mTestObject->mThumbnailManager->mRequests.count(), 0);
 
   296     cleanup();        
   303     cleanup();
 
       
   304     
       
   305     // Test canceling fetches that are not on the new started list.
 
       
   306     init();
 
       
   307     for(int i = 0; i < 10; i++)
 
       
   308     {
 
       
   309         mediaId = TMPXItemId(i, i);
 
       
   310         mTestObject->addFetch("test", mediaId, i);
 
       
   311     }
 
       
   312 
       
   313     // 5 overlapping, they won't be canceled.
 
       
   314     for(int i = 5; i < 15; i++)
 
       
   315     {
 
       
   316         mediaId = TMPXItemId(i, i); // found from the list.
 
       
   317         VideoThumbnailFetcher::ThumbnailFetchData *data = new VideoThumbnailFetcher::ThumbnailFetchData();
 
       
   318         data->mFileName = "";
 
       
   319         data->mPriority = 0;
 
       
   320         data->mRequestId = -1;
 
       
   321         data->mMediaId = mediaId;
 
       
   322         mTestObject->mStartedFetchList.insert(mediaId, data);
 
       
   323     }
 
       
   324     
       
   325     QCOMPARE(mTestObject->mFetchList.count(), 10);
 
       
   326     mTestObject->startThumbnailFetches(true);
 
       
   327     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
       
   328     QCOMPARE(mTestObject->mThumbnailManager->mRequests.count(), 5);
 
       
   329     QCOMPARE(mTestObject->mStartedFetchList.count(), 10);
 
       
   330     QCOMPARE(ThumbnailManager::mCancelRequestCount, 5);
 
       
   331     cleanup();
 
       
   332     
   297 }
 
   333 }
 
   298 
   334 
   299 // ---------------------------------------------------------------------------
 
   335 // ---------------------------------------------------------------------------
 
   300 // testStartThumbnailCreation
 
   336 // testStartThumbnailCreation
 
   301 // ---------------------------------------------------------------------------
 
   337 // ---------------------------------------------------------------------------
 
   332     init();
 
   368     init();
 
   333     for(int i = 0; i < 10; i++)
 
   369     for(int i = 0; i < 10; i++)
 
   334     {
 
   370     {
 
   335         VideoThumbnailFetcher::ThumbnailFetchData *fetch = new VideoThumbnailFetcher::ThumbnailFetchData();
 
   371         VideoThumbnailFetcher::ThumbnailFetchData *fetch = new VideoThumbnailFetcher::ThumbnailFetchData();
 
   336         fetch->mFileName = "test";
 
   372         fetch->mFileName = "test";
 
   337         fetch->mInternal = 0;
 
       
   338         mTestObject->mCreationList.insert(0, fetch);
 
   373         mTestObject->mCreationList.insert(0, fetch);
 
   339     }
 
   374     }
 
   340     QCOMPARE(mTestObject->mCreationList.count(), 10);
 
   375     QCOMPARE(mTestObject->mCreationList.count(), 10);
 
   341     mTestObject->startThumbnailCreation();
 
   376     mTestObject->startThumbnailCreation();
 
   342     QCOMPARE(mTestObject->mCreationList.count(), 9);
 
   377     QCOMPARE(mTestObject->mCreationList.count(), 9);
 
   370     int error = 0;
 
   405     int error = 0;
 
   371     QSignalSpy* spy = 0;
 
   406     QSignalSpy* spy = 0;
 
   372 
   407 
   373     // Internal parameter is null, started fetches do not contain the fetch.
 
   408     // Internal parameter is null, started fetches do not contain the fetch.
 
   374     init();
 
   409     init();
 
   375     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, void*, int) ));
 
   410     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, const TMPXItemId &, int) ));
 
   376     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   411     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   377     QCOMPARE(spy->count(), 1);
 
   412     QCOMPARE(spy->count(), 1);
 
   378     delete spy; spy = 0;
 
   413     delete spy; spy = 0;
 
   379     cleanup();
 
   414     cleanup();
 
   380 
   415 
   381     // Internal parameter is null, started fetches contains the fetch.
 
   416     // Internal parameter is null, started fetches contains the fetch.
 
   382     init();
 
   417     init();
 
   383     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, void*, int) ));
 
   418     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, const TMPXItemId &, int) ));
 
   384     mTestObject->mStartedFetchList.insert(requestId, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   419     mTestObject->mStartedFetchList.insert(requestId, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   385     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   420     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   386     QCOMPARE(spy->count(), 1);
 
   421     QCOMPARE(spy->count(), 1);
 
   387     delete spy; spy = 0;
 
   422     delete spy; spy = 0;
 
   388     cleanup();
 
   423     cleanup();
 
   389     
   424     
   390     // Test error handling.  
   425     // Test error handling.  
   391     init();
 
   426     init();
 
   392     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, void*, int) ));
 
   427     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, const TMPXItemId &, int) ));
 
   393     error = -5;
 
   428     error = -5;
 
   394     mTestObject->mStartedFetchList.insert(requestId, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   429     mTestObject->mStartedFetchList.insert(requestId, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   395     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   430     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   396     QCOMPARE(spy->count(), 1);
 
   431     QCOMPARE(spy->count(), 1);
 
   397     delete spy; spy = 0;
 
   432     delete spy; spy = 0;
 
   398     cleanup();
 
   433     cleanup();
 
   399     
   434     /* TODO FIX
 
   400     // Fetch fails because thumbnail was not created yet, fetch list contains the request.
 
   435     // Fetch fails because thumbnail was not created yet, fetch list contains the request.
 
   401     init();
 
   436     init();
 
   402     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, void*, int) ));
 
   437     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, const TMPXItemId &, int) ));
 
   403     error = -1;
 
   438     error = -1;
 
   404     requestId = 5;
 
   439     requestId = 5;
 
   405     internal = new int(5);
 
   440     internal = new int(5);
 
   406     mTestObject->mStartedFetchList.insert(requestId, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   441     mTestObject->mStartedFetchList.insert(requestId, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   407     mTestObject->mStartedFetchList.insert(requestId+1, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   442     mTestObject->mStartedFetchList.insert(requestId+1, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   410     QCOMPARE(mTestObject->mStartedFetchList.count(), 1);
 
   445     QCOMPARE(mTestObject->mStartedFetchList.count(), 1);
 
   411     QCOMPARE(mTestObject->mCreationList.count(), 1);
 
   446     QCOMPARE(mTestObject->mCreationList.count(), 1);
 
   412     delete spy; spy = 0;
 
   447     delete spy; spy = 0;
 
   413     delete internal; internal = 0;
 
   448     delete internal; internal = 0;
 
   414     cleanup();
 
   449     cleanup();
 
   415     
   450 */    
   416     // Fetch fails because thumbnail was not created yet, fetch list does not contain the request.
 
   451     // Fetch fails because thumbnail was not created yet, fetch list does not contain the request.
 
   417     init();
 
   452     init();
 
   418     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, void*, int) ));
 
   453     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, const TMPXItemId &, int) ));
 
   419     error = -1;
 
   454     error = -1;
 
   420     requestId = 5;
 
   455     requestId = 5;
 
   421     internal = new int(5);
 
   456     internal = new int(5);
 
   422     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   457     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   423     QCOMPARE(spy->count(), 0);
 
   458     QCOMPARE(spy->count(), 0);
 
   431     init();
 
   466     init();
 
   432     internal = 0;
 
   467     internal = 0;
 
   433     requestId = 5;
 
   468     requestId = 5;
 
   434     mTestObject->mPaused = false;
 
   469     mTestObject->mPaused = false;
 
   435     mTestObject->mStartedFetchList.insert(requestId+10, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   470     mTestObject->mStartedFetchList.insert(requestId+10, new VideoThumbnailFetcher::ThumbnailFetchData());
 
   436     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());
 
   471     mTestObject->mFetchList.insert(TMPXItemId(0, 0), new VideoThumbnailFetcher::ThumbnailFetchData());
 
   437     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   472     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   438     QCOMPARE(mTestObject->mStartedFetchList.count(), 1);
 
   473     QCOMPARE(mTestObject->mStartedFetchList.count(), 1);
 
   439     QCOMPARE(mTestObject->mFetchList.count(), 1);
 
   474     QCOMPARE(mTestObject->mFetchList.count(), 1);
 
   440     cleanup();
 
   475     cleanup();
 
   441     
   476     
   442     // Fetching is not paused, mStartedFetchList is empty.
 
   477     // Fetching is not paused, mStartedFetchList is empty.
 
   443     init();
 
   478     init();
 
   444     internal = 0;
 
   479     internal = 0;
 
   445     requestId = 5;
 
   480     requestId = 5;
 
   446     mTestObject->mPaused = false;
 
   481     mTestObject->mPaused = false;
 
   447     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());
 
   482     mTestObject->mFetchList.insert(TMPXItemId(0, 0), new VideoThumbnailFetcher::ThumbnailFetchData());
 
   448     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   483     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   449     QCOMPARE(mTestObject->mStartedFetchList.count(), 1);
 
   484     QCOMPARE(mTestObject->mStartedFetchList.count(), 1);
 
   450     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   485     QCOMPARE(mTestObject->mFetchList.count(), 0);
 
   451     cleanup();
 
   486     cleanup();
 
   452     
   487     
   453     // Fetch set to paused, mStartedFetchList is empty.
 
   488     // Fetch set to paused, mStartedFetchList is empty.
 
   454     init();
 
   489     init();
 
   455     internal = 0;
 
   490     internal = 0;
 
   456     requestId = 5;
 
   491     requestId = 5;
 
   457     mTestObject->mPaused = true;
 
   492     mTestObject->mPaused = true;
 
   458     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());
 
   493     mTestObject->mFetchList.insert(TMPXItemId(0, 0), new VideoThumbnailFetcher::ThumbnailFetchData());
 
   459     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   494     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);
 
   460     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);
 
   495     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);
 
   461     QCOMPARE(mTestObject->mFetchList.count(), 1);
 
   496     QCOMPARE(mTestObject->mFetchList.count(), 1);
 
   462     cleanup();
 
   497     cleanup();
 
   463 }
 
   498 }
FCL/sf/app/videoplayer