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 VideoThumbnailFetcher

    15 *

    16 */

    17 

    18 // INCLUDES

    19 #include <hbapplication.h>

    20 #include <hbinstance.h>

    21 #include <qlist.h>

    22 #include <qhash.h>

    23 

    24 #include "testvideothumbnailfetcher.h"

    25 

    26 #include "e32std.h"

    27 

    28 #define private public

    29 #define protected public

    30 #include "videothumbnailfetchertester.h"

    31 #undef private

    32 #undef protected

    33 

    34 #include "videothumbnailfetcher.h"

    35 

    36 // ---------------------------------------------------------------------------

    37 // main

    38 // ---------------------------------------------------------------------------

    39 //

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

    41 {

    42     HbApplication app(argc, argv);

    43     HbMainWindow window;

    44 

    45     TestVideoThumbnailFetcher tv;

    46 

    47     int res;

    48     if(argc > 1)

    49     {   

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

    51     }

    52     else

    53     {

    54         char *pass[3];

    55         pass[0] = argv[0];

    56         pass[1] = "-o";

    57         pass[2] = "c:\\data\\TestVideoThumbnailFetcher.txt";

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

    59     }

    60 

    61     return res;

    62 }

    63 

    64 // ---------------------------------------------------------------------------

    65 // init

    66 // ---------------------------------------------------------------------------

    67 //

    68 void TestVideoThumbnailFetcher::init()

    69 {

    70     mTestObject = new VideoThumbnailFetcherTester();

    71     

    72     ThumbnailManager::mGetThumbFails = false;

    73     ThumbnailManager::mThumbnailReadyError = 0;

    74 }

    75 

    76 // ---------------------------------------------------------------------------

    77 // cleanup

    78 // ---------------------------------------------------------------------------

    79 //

    80 void TestVideoThumbnailFetcher::cleanup()

    81 {

    82     delete mTestObject;

    83     mTestObject = 0;

    84     

    85     ThumbnailManager::mRequests.clear();

    86 }

    87 

    88 // ---------------------------------------------------------------------------

    89 // testConstructDestruct

    90 // ---------------------------------------------------------------------------

    91 //

    92 void TestVideoThumbnailFetcher::testConstructDestruct()

    93 {

    94     mTestObject = new VideoThumbnailFetcherTester();

    95     QVERIFY(mTestObject->mThumbnailManager != 0);

    96     delete mTestObject;

    97     mTestObject = 0;

    98 }

    99 

   100 // ---------------------------------------------------------------------------

   101 // testAddFetch

   102 // ---------------------------------------------------------------------------

   103 //

   104 void TestVideoThumbnailFetcher::testAddFetch()

   105 {

   106     init();

   107     

   108     mTestObject->addFetch(QString(), 0, 0);

   109     QCOMPARE(mTestObject->mFetchList.count(), 1);

   110     

   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();

   119 }

   120 

   121 // ---------------------------------------------------------------------------

   122 // testCancelFetches

   123 // ---------------------------------------------------------------------------

   124 //

   125 void TestVideoThumbnailFetcher::testCancelFetches()

   126 {

   127     init();

   128     

   129     mTestObject->addFetch(QString(), 0, 0);

   130     mTestObject->cancelFetches();

   131     QCOMPARE(mTestObject->mFetchList.count(), 0);

   132     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   133     QCOMPARE(mTestObject->mCreationList.count(), 0);

   134     

   135     mTestObject->addFetch("test", 0, 0);

   136     mTestObject->cancelFetches();

   137     QCOMPARE(mTestObject->mFetchList.count(), 0);

   138     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   139     QCOMPARE(mTestObject->mCreationList.count(), 0);

   140     

   141     int *internal = new int;

   142     mTestObject->addFetch("test", internal, 0);

   143     mTestObject->cancelFetches();

   144     QCOMPARE(mTestObject->mFetchList.count(), 0);

   145     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   146     QCOMPARE(mTestObject->mCreationList.count(), 0);

   147     

   148     for(int i = 0; i < 10; i ++)

   149         mTestObject->addFetch(QString(), 0, i);

   150     mTestObject->cancelFetches();

   151     QCOMPARE(mTestObject->mFetchList.count(), 0);    

   152     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   153     QCOMPARE(mTestObject->mCreationList.count(), 0);

   154     

   155     mTestObject->mStartedFetchList.insert(0, new VideoThumbnailFetcher::ThumbnailFetchData());

   156     mTestObject->cancelFetches();

   157     QCOMPARE(mTestObject->mFetchList.count(), 0);    

   158     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   159     QCOMPARE(mTestObject->mCreationList.count(), 0);

   160     

   161     mTestObject->mCreationList.append(new VideoThumbnailFetcher::ThumbnailFetchData());

   162     mTestObject->cancelFetches();

   163     QCOMPARE(mTestObject->mFetchList.count(), 0);

   164     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   165     QCOMPARE(mTestObject->mCreationList.count(), 0);

   166 

   167     cleanup();

   168 }

   169 

   170 // ---------------------------------------------------------------------------

   171 // testFetchCount

   172 // ---------------------------------------------------------------------------

   173 //

   174 void TestVideoThumbnailFetcher::testFetchCount()

   175 {

   176     init();

   177 

   178     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());

   179     QCOMPARE(mTestObject->fetchCount(), 1);

   180     

   181     mTestObject->mStartedFetchList.insert(0, new VideoThumbnailFetcher::ThumbnailFetchData());

   182     QCOMPARE(mTestObject->fetchCount(), 2);

   183     

   184     mTestObject->mCreationList.append(new VideoThumbnailFetcher::ThumbnailFetchData());

   185     QCOMPARE(mTestObject->fetchCount(), 3);

   186     

   187     cleanup();

   188 }

   189 

   190 // ---------------------------------------------------------------------------

   191 // testPauseFetching

   192 // ---------------------------------------------------------------------------

   193 //

   194 void TestVideoThumbnailFetcher::testPauseFetching()

   195 {

   196     init();

   197     

   198     QVERIFY(!mTestObject->mPaused);

   199     mTestObject->pauseFetching();

   200     QVERIFY(mTestObject->mPaused);

   201     

   202     cleanup();

   203 }

   204 

   205 // ---------------------------------------------------------------------------

   206 // testContinueFetching

   207 // ---------------------------------------------------------------------------

   208 //

   209 void TestVideoThumbnailFetcher::testContinueFetching()

   210 {

   211     init();

   212     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());

   213     mTestObject->continueFetching();

   214     QCOMPARE(mTestObject->fetchCount(), 1);

   215     cleanup();

   216     

   217     init();

   218     mTestObject->mCreationList.insert(0, new VideoThumbnailFetcher::ThumbnailFetchData());

   219     mTestObject->continueFetching();

   220     QCOMPARE(mTestObject->fetchCount(), 0);

   221     cleanup();

   222     

   223     // Test when there's nothing to fetch 

   224     init();

   225     QSignalSpy* spy = new QSignalSpy(mTestObject, SIGNAL(allThumbnailsFetched()));

   226     mTestObject->continueFetching();

   227     QCOMPARE(spy->count(), 1);

   228     delete spy;

   229     

   230     cleanup();

   231 }

   232 

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

   234 // testEnableThumbnailCreation

   235 // ---------------------------------------------------------------------------

   236 //

   237 void TestVideoThumbnailFetcher::testEnableThumbnailCreation()

   238 {

   239     init();

   240     

   241     mTestObject->enableThumbnailCreation(false);

   242     QVERIFY(!mTestObject->mTbnCreationEnabled);

   243     

   244     mTestObject->enableThumbnailCreation(true);

   245     QVERIFY(mTestObject->mTbnCreationEnabled);

   246 

   247     cleanup();

   248 }

   249 

   250 // ---------------------------------------------------------------------------

   251 // testStartThumbnailFetches

   252 // ---------------------------------------------------------------------------

   253 //

   254 void TestVideoThumbnailFetcher::testStartThumbnailFetches()

   255 {

   256     // Test when thumbnail manager is null.

   257     init();

   258     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());    

   259     delete mTestObject->mThumbnailManager;

   260     mTestObject->mThumbnailManager = 0;

   261     mTestObject->startThumbnailFetches();

   262     QCOMPARE(mTestObject->mFetchList.count(), 1);

   263     cleanup();

   264 

   265     // Test when nothing to fetch.

   266     init();

   267     mTestObject->startThumbnailFetches();

   268     QVERIFY(mTestObject->mThumbnailManager->mode() == ThumbnailManager::DoNotCreate);

   269     QCOMPARE(mTestObject->fetchCount(), 0);

   270     cleanup();

   271     

   272     // Test when there's something to fetch.

   273     init();

   274     for(int i = 0; i < 10; i++)

   275     {

   276         int *internal = new int(i);

   277         mTestObject->addFetch("test", internal, i);

   278     }

   279     QCOMPARE(mTestObject->mFetchList.count(), 10);

   280     mTestObject->startThumbnailFetches();

   281     QCOMPARE(mTestObject->mFetchList.count(), 0);

   282     QCOMPARE(mTestObject->mStartedFetchList.count(), 10);

   283     QCOMPARE(mTestObject->mThumbnailManager->mRequests.count(), 10);

   284     cleanup();

   285     

   286     // Test when request to thumbnail manager fails.

   287     init();

   288     ThumbnailManager::mGetThumbFails = true;

   289     int *internal = new int(0);

   290     mTestObject->addFetch("test", internal, 0);

   291     QCOMPARE(mTestObject->mFetchList.count(), 1);

   292     mTestObject->startThumbnailFetches();

   293     QCOMPARE(mTestObject->mFetchList.count(), 0);

   294     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   295     QCOMPARE(mTestObject->mThumbnailManager->mRequests.count(), 0);

   296     cleanup();        

   297 }

   298 

   299 // ---------------------------------------------------------------------------

   300 // testStartThumbnailCreation

   301 // ---------------------------------------------------------------------------

   302 //

   303 void TestVideoThumbnailFetcher::testStartThumbnailCreation()

   304 {

   305     init();

   306 

   307     // Test when thumbnail manager is null.

   308     init();

   309     mTestObject->mCreationList.insert(0, new VideoThumbnailFetcher::ThumbnailFetchData());    

   310     delete mTestObject->mThumbnailManager;

   311     mTestObject->mThumbnailManager = 0;

   312     mTestObject->startThumbnailCreation();

   313     QCOMPARE(mTestObject->mCreationList.count(), 1);

   314     cleanup();

   315 

   316     // Test when thumbnail creation is disabled.

   317     init();

   318     mTestObject->mCreationList.insert(0, new VideoThumbnailFetcher::ThumbnailFetchData());    

   319     mTestObject->mTbnCreationEnabled = false;

   320     mTestObject->startThumbnailCreation();

   321     QCOMPARE(mTestObject->mCreationList.count(), 1);

   322     cleanup();

   323 

   324     // Test when nothing to fetch.

   325     init();

   326     mTestObject->startThumbnailCreation();

   327     QVERIFY(mTestObject->mThumbnailManager->mode() == ThumbnailManager::CropToAspectRatio);

   328     QCOMPARE(mTestObject->fetchCount(), 0);

   329     cleanup();

   330     

   331     // Test when there's something to fetch.

   332     init();

   333     for(int i = 0; i < 10; i++)

   334     {

   335         VideoThumbnailFetcher::ThumbnailFetchData *fetch = new VideoThumbnailFetcher::ThumbnailFetchData();

   336         fetch->mFileName = "test";

   337         fetch->mInternal = 0;

   338         mTestObject->mCreationList.insert(0, fetch);

   339     }

   340     QCOMPARE(mTestObject->mCreationList.count(), 10);

   341     mTestObject->startThumbnailCreation();

   342     QCOMPARE(mTestObject->mCreationList.count(), 9);

   343     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   344     QCOMPARE(mTestObject->mThumbnailManager->mRequests.count(), 1);

   345     cleanup();

   346     

   347     // Test when request to thumbnail manager fails.

   348     init();

   349     ThumbnailManager::mGetThumbFails = true;

   350     mTestObject->mCreationList.insert(0, new VideoThumbnailFetcher::ThumbnailFetchData());

   351     mTestObject->startThumbnailCreation();

   352     QCOMPARE(mTestObject->mCreationList.count(), 0);

   353     QCOMPARE(mTestObject->mFetchList.count(), 0);

   354     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   355     QCOMPARE(mTestObject->mThumbnailManager->mRequests.count(), 0);

   356     cleanup();       

   357     

   358     cleanup();

   359 }

   360 

   361 // ---------------------------------------------------------------------------

   362 // testThumbnailReadySlot

   363 // ---------------------------------------------------------------------------

   364 //

   365 void TestVideoThumbnailFetcher::testThumbnailReadySlot()

   366 {

   367     QPixmap pmap;

   368     int requestId = 5;

   369     int *internal = 0;

   370     int error = 0;

   371     QSignalSpy* spy = 0;

   372 

   373     // Internal parameter is null, started fetches do not contain the fetch.

   374     init();

   375     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, void*, int) ));

   376     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);

   377     QCOMPARE(spy->count(), 1);

   378     delete spy; spy = 0;

   379     cleanup();

   380 

   381     // Internal parameter is null, started fetches contains the fetch.

   382     init();

   383     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, void*, int) ));

   384     mTestObject->mStartedFetchList.insert(requestId, new VideoThumbnailFetcher::ThumbnailFetchData());

   385     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);

   386     QCOMPARE(spy->count(), 1);

   387     delete spy; spy = 0;

   388     cleanup();

   389     

   390     // Test error handling.  

   391     init();

   392     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, void*, int) ));

   393     error = -5;

   394     mTestObject->mStartedFetchList.insert(requestId, new VideoThumbnailFetcher::ThumbnailFetchData());

   395     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);

   396     QCOMPARE(spy->count(), 1);

   397     delete spy; spy = 0;

   398     cleanup();

   399     

   400     // Fetch fails because thumbnail was not created yet, fetch list contains the request.

   401     init();

   402     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, void*, int) ));

   403     error = -1;

   404     requestId = 5;

   405     internal = new int(5);

   406     mTestObject->mStartedFetchList.insert(requestId, new VideoThumbnailFetcher::ThumbnailFetchData());

   407     mTestObject->mStartedFetchList.insert(requestId+1, new VideoThumbnailFetcher::ThumbnailFetchData());

   408     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);

   409     QCOMPARE(spy->count(), 0);

   410     QCOMPARE(mTestObject->mStartedFetchList.count(), 1);

   411     QCOMPARE(mTestObject->mCreationList.count(), 1);

   412     delete spy; spy = 0;

   413     delete internal; internal = 0;

   414     cleanup();

   415     

   416     // Fetch fails because thumbnail was not created yet, fetch list does not contain the request.

   417     init();

   418     spy = new QSignalSpy(mTestObject, SIGNAL( thumbnailReady(QPixmap, void*, int) ));

   419     error = -1;

   420     requestId = 5;

   421     internal = new int(5);

   422     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);

   423     QCOMPARE(spy->count(), 0);

   424     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   425     QCOMPARE(mTestObject->mCreationList.count(), 0);

   426     delete spy; spy = 0;

   427     internal = 0; // this was deleted on fetcher side.

   428     cleanup();

   429 

   430     // Fetching is not paused, mStartedFetchList is not empty.

   431     init();

   432     internal = 0;

   433     requestId = 5;

   434     mTestObject->mPaused = false;

   435     mTestObject->mStartedFetchList.insert(requestId+10, new VideoThumbnailFetcher::ThumbnailFetchData());

   436     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());

   437     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);

   438     QCOMPARE(mTestObject->mStartedFetchList.count(), 1);

   439     QCOMPARE(mTestObject->mFetchList.count(), 1);

   440     cleanup();

   441     

   442     // Fetching is not paused, mStartedFetchList is empty.

   443     init();

   444     internal = 0;

   445     requestId = 5;

   446     mTestObject->mPaused = false;

   447     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());

   448     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);

   449     QCOMPARE(mTestObject->mStartedFetchList.count(), 1);

   450     QCOMPARE(mTestObject->mFetchList.count(), 0);

   451     cleanup();

   452     

   453     // Fetch set to paused, mStartedFetchList is empty.

   454     init();

   455     internal = 0;

   456     requestId = 5;

   457     mTestObject->mPaused = true;

   458     mTestObject->mFetchList.append(new VideoThumbnailFetcher::ThumbnailFetchData());

   459     mTestObject->mThumbnailManager->emitThumbnailReady(pmap, internal, requestId, error);

   460     QCOMPARE(mTestObject->mStartedFetchList.count(), 0);

   461     QCOMPARE(mTestObject->mFetchList.count(), 1);

   462     cleanup();

   463 }

   464 

   465 // End of file