activityfw/storage/client/t_afstorageclient/src/t_activityclient.cpp
changeset 117 c63ee96dbe5f
equal deleted inserted replaced
115:3ab5c078b490 117:c63ee96dbe5f
       
     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:  Main test class for hsutils library.
       
    15 *
       
    16 */
       
    17 
       
    18 #include "t_activityclient.h"
       
    19 
       
    20 #include <s32mem.h>
       
    21 #include <fbs.h>
       
    22 
       
    23 #include <QPainter>
       
    24 #include <QScopedPointer>
       
    25 
       
    26 #include <XQConversions>
       
    27 
       
    28 #include <afstorageglobals.h>
       
    29 #include <afentry.h>
       
    30 
       
    31 #include "afasyncrequest_p.h"
       
    32 #include "afthumbnailrequest_p.h"
       
    33 #include "afstorageclient.h"
       
    34 
       
    35 _LIT(KActivityName, "ActivityName");
       
    36 
       
    37 // ---------------------------------------------------------------------------
       
    38 // ---------------------------------------------------------------------------
       
    39 //
       
    40 T_ActivityClient::T_ActivityClient() : mBitmap(0), mData(0), mRunningTask(0), mScreenshot(0), mUserData(0)
       
    41 {       
       
    42 }
       
    43 
       
    44 // ---------------------------------------------------------------------------
       
    45 // ---------------------------------------------------------------------------
       
    46 //
       
    47 T_ActivityClient::~T_ActivityClient()
       
    48 {
       
    49     delete mData;
       
    50 }
       
    51 
       
    52 // ---------------------------------------------------------------------------
       
    53 // ---------------------------------------------------------------------------
       
    54 //
       
    55 void T_ActivityClient::initTestCase()
       
    56 {
       
    57     QPixmap screenshot(20, 20);    
       
    58     {
       
    59         QPainter painter(&screenshot);
       
    60         painter.setBrush(Qt::black);
       
    61         painter.drawRect(screenshot.rect());
       
    62         painter.setBrush(QColor::fromHsv(255, 255, 255));
       
    63         painter.drawEllipse(screenshot.rect());
       
    64     }
       
    65     
       
    66     QScopedPointer<CFbsBitmap> bitmap(screenshot.toSymbianCFbsBitmap());
       
    67 
       
    68     mBitmap = new CFbsBitmap();
       
    69     QCOMPARE(mBitmap->Duplicate(bitmap->Handle()), KErrNone);    
       
    70 }
       
    71 
       
    72 // ---------------------------------------------------------------------------
       
    73 // ---------------------------------------------------------------------------
       
    74 //
       
    75 void T_ActivityClient::cleanupTestCase()
       
    76 {
       
    77     delete mBitmap;
       
    78 }
       
    79 
       
    80 // ---------------------------------------------------------------------------
       
    81 // ---------------------------------------------------------------------------
       
    82 //
       
    83 void T_ActivityClient::waitActivityRequestCompleted(int result,
       
    84                                 const TDesC8 &data)
       
    85 {
       
    86     if (mData) {
       
    87         delete mData;
       
    88     }
       
    89     RBuf converter;
       
    90     converter.CreateMaxL(data.Length());
       
    91     converter.Copy(data);
       
    92     mData = converter.Alloc();
       
    93     converter.Close();
       
    94     
       
    95     mRealResponse = result;
       
    96     
       
    97     if(mLoop.isRunning()) {
       
    98         mLoop.exit();
       
    99     }
       
   100 }
       
   101 // ---------------------------------------------------------------------------
       
   102 // ---------------------------------------------------------------------------
       
   103 //
       
   104 void T_ActivityClient::getThumbnailRequestCompleted(int result,
       
   105                             int bitmapHandle, 
       
   106                             void* userData)
       
   107 {
       
   108     mScreenshotHandle = bitmapHandle;    
       
   109     mScreenshot = new CFbsBitmap();
       
   110     mScreenshot->Duplicate(mScreenshotHandle);    
       
   111     mUserData = userData;
       
   112 
       
   113     mRealResponse = result;
       
   114     if(mLoop.isRunning()) {
       
   115         mLoop.exit();
       
   116     }    
       
   117 }
       
   118 
       
   119 // ---------------------------------------------------------------------------
       
   120 // ---------------------------------------------------------------------------
       
   121 //
       
   122 void T_ActivityClient::dataChangeNotificationCompleted(int result)
       
   123 {
       
   124     mRealResponse = result;
       
   125     if(mLoop.isRunning()) {
       
   126         mLoop.exit();
       
   127     }
       
   128 }
       
   129 // ---------------------------------------------------------------------------
       
   130 // ---------------------------------------------------------------------------
       
   131 //
       
   132 void T_ActivityClient::PushL(CBase* asyncTask)
       
   133 {
       
   134     mRunningTask = asyncTask; 
       
   135 }
       
   136 
       
   137 // ---------------------------------------------------------------------------
       
   138 // ---------------------------------------------------------------------------
       
   139 //
       
   140 void T_ActivityClient::Pop(CBase* asyncTask)
       
   141 {
       
   142     Q_UNUSED(asyncTask);
       
   143     mRunningTask = 0;
       
   144 }
       
   145 
       
   146 // ---------------------------------------------------------------------------
       
   147 // ---------------------------------------------------------------------------
       
   148 //
       
   149 void T_ActivityClient::executeL(int function)
       
   150 {
       
   151     Q_UNUSED(function);
       
   152 }
       
   153 
       
   154 // ---------------------------------------------------------------------------
       
   155 // ---------------------------------------------------------------------------
       
   156 //
       
   157 void T_ActivityClient::sendAsync(int function, const TIpcArgs &args, TRequestStatus& status)
       
   158 {
       
   159     Q_UNUSED(function);
       
   160     Q_UNUSED(args);
       
   161     TRequestStatus *requestStatus(&status);
       
   162     User::RequestComplete(requestStatus, mExpectedResponse);
       
   163 }
       
   164 
       
   165 // ---------------------------------------------------------------------------
       
   166 // ---------------------------------------------------------------------------
       
   167 //
       
   168 void T_ActivityClient::getDataL(int id, TDes8& buffer)
       
   169 {
       
   170     Q_UNUSED(id);
       
   171     Q_UNUSED(buffer);
       
   172 }
       
   173 
       
   174 // ---------------------------------------------------------------------------
       
   175 // ---------------------------------------------------------------------------
       
   176 //
       
   177 void T_ActivityClient::testEntry()
       
   178 {
       
   179     const TInt KActivityFlags(qHash("Some activity flags"));
       
   180     const TInt KApplicationId(qHash("Some application id"));
       
   181     _LIT(KActivityId, "Some activity id");
       
   182     _LIT(KActivityThumnail, "s:\\ome\\activity\\img.png");
       
   183     _LIT8(KPrivateData, "Some private data");
       
   184     _LIT8(KPublicData, "Some public data");
       
   185     
       
   186     struct TestDataSet{
       
   187     TInt mFlags;
       
   188     TInt mAppId;
       
   189     const TDesC& mActId;
       
   190     const TDesC& mImgPath;
       
   191     const TDesC8& mPriv;
       
   192     const TDesC8& mPub;
       
   193     } testData [] = {{KActivityFlags, KApplicationId, KActivityId(), KActivityThumnail(), KPrivateData(), KPublicData()},
       
   194                      {KActivityFlags, KApplicationId, KNullDesC, KActivityThumnail(), KPrivateData(), KPublicData()}, 
       
   195                      {KActivityFlags, KApplicationId, KActivityId(), KNullDesC, KPrivateData(), KPublicData()}, 
       
   196                      {KActivityFlags, KApplicationId, KActivityId(), KActivityThumnail(), KNullDesC8, KPublicData()},
       
   197                      {KActivityFlags, KApplicationId, KActivityId(), KActivityThumnail(), KPrivateData(), KNullDesC8()}};
       
   198     const int count(sizeof(testData) / sizeof(TestDataSet));
       
   199     CAfEntry * entry(0);
       
   200     RBuf8 serializedEntry;
       
   201     CleanupClosePushL(serializedEntry);
       
   202     for (int i(0); i < count; ++i) {
       
   203         entry = CAfEntry::NewL(testData[i].mFlags, 
       
   204                                 testData[i].mAppId,
       
   205                                 testData[i].mActId,
       
   206                                 testData[i].mImgPath,
       
   207                                 testData[i].mPriv,
       
   208                                 testData[i].mPub);
       
   209         CleanupStack::PushL(entry);
       
   210         
       
   211         QVERIFY(entry->Flags() == testData[i].mFlags);
       
   212         QVERIFY(entry->ApplicationId() == testData[i].mAppId);
       
   213         QVERIFY(0 == entry->ActivityId().Compare(testData[i].mActId));
       
   214         QVERIFY(0 == entry->ImageSrc().Compare(testData[i].mImgPath));
       
   215         QVERIFY(0 == entry->Data(CAfEntry::Private).Compare(testData[i].mPriv));
       
   216         QVERIFY(0 == entry->Data(CAfEntry::Public).Compare(testData[i].mPub));
       
   217         
       
   218         if(serializedEntry.MaxLength() < entry->Size()) {
       
   219             serializedEntry.ReAllocL(entry->Size());
       
   220         }
       
   221         RDesWriteStream writer(serializedEntry);
       
   222         CleanupClosePushL(writer);
       
   223         writer << (*entry);
       
   224         CleanupStack::PopAndDestroy(&writer);
       
   225         CleanupStack::PopAndDestroy(entry);
       
   226         
       
   227         entry = CAfEntry::NewL();
       
   228         CleanupStack::PushL(entry);
       
   229         
       
   230         RDesReadStream reader(serializedEntry);
       
   231         CleanupClosePushL(reader);
       
   232         reader >> (*entry);
       
   233         CleanupStack::PopAndDestroy(&reader);
       
   234         
       
   235         QVERIFY(entry->Flags() == testData[i].mFlags);
       
   236         QVERIFY(entry->ApplicationId() == testData[i].mAppId);
       
   237         QVERIFY(0 == entry->ActivityId().Compare(testData[i].mActId));
       
   238         QVERIFY(0 == entry->ImageSrc().Compare(testData[i].mImgPath));
       
   239         QVERIFY(0 == entry->Data(CAfEntry::Private).Compare(testData[i].mPriv));
       
   240         QVERIFY(0 == entry->Data(CAfEntry::Public).Compare(testData[i].mPub));
       
   241         
       
   242         CleanupStack::PopAndDestroy(entry);        
       
   243     }
       
   244     CleanupStack::PopAndDestroy(&serializedEntry);
       
   245 }
       
   246 // ---------------------------------------------------------------------------
       
   247 // ---------------------------------------------------------------------------
       
   248 //
       
   249 void T_ActivityClient::testAsyncRequest()
       
   250 {
       
   251     mExpectedResponse = KErrNone;
       
   252     CAfAsyncRequestPrivate::NewLD(*this, *this, WaitActivity);
       
   253     mLoop.exec();
       
   254     QVERIFY(mExpectedResponse == mRealResponse);
       
   255     QVERIFY(0 == mRunningTask);
       
   256     
       
   257     mExpectedResponse = KErrGeneral;
       
   258     CAfAsyncRequestPrivate::NewLD(*this, *this, WaitActivity);
       
   259     mLoop.exec();
       
   260     QVERIFY(mExpectedResponse == mRealResponse);
       
   261     QVERIFY(0 == mRunningTask);
       
   262     
       
   263     mExpectedResponse = KErrNone;
       
   264     CAfAsyncRequestPrivate::NewLD(*this, *this, NotifyChange);
       
   265     mLoop.exec();
       
   266     QVERIFY(mExpectedResponse == mRealResponse);
       
   267     QVERIFY(0 == mRunningTask);
       
   268     
       
   269     mExpectedResponse = KErrGeneral;
       
   270     CAfAsyncRequestPrivate::NewLD(*this, *this, NotifyChange);
       
   271     mLoop.exec();
       
   272     QVERIFY(mExpectedResponse == mRealResponse);
       
   273     QVERIFY(0 == mRunningTask);
       
   274     
       
   275     
       
   276     mExpectedResponse = KErrGeneral;
       
   277     CAfThumbnailRequestPrivate::NewLD(*this, *this, TSize(), _L("f://ake//path.mif"), 0);
       
   278     mLoop.exec();
       
   279     QVERIFY(mExpectedResponse == mRealResponse);
       
   280     QVERIFY(0 == mRunningTask);
       
   281     
       
   282     mExpectedResponse = KErrNone;
       
   283     CAfThumbnailRequestPrivate::NewLD(*this, *this, TSize(), _L("f://ake//path.mif"), 0);
       
   284     mLoop.exec();
       
   285     QVERIFY(mExpectedResponse == mRealResponse);
       
   286     QVERIFY(0 == mRunningTask);
       
   287 
       
   288 }
       
   289 // ---------------------------------------------------------------------------
       
   290 // ---------------------------------------------------------------------------
       
   291 //
       
   292 void T_ActivityClient::testCreateClient()
       
   293 {
       
   294     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   295 }
       
   296 
       
   297 // ---------------------------------------------------------------------------
       
   298 // ---------------------------------------------------------------------------
       
   299 //
       
   300 void T_ActivityClient::testAddActivity()
       
   301 {
       
   302     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   303     QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));
       
   304     
       
   305     client->removeActivity(*entry.data());
       
   306     
       
   307     QVERIFY(KErrNone == client->addActivity(*entry.data(), mBitmap->Handle()));
       
   308     QVERIFY(KErrNone != client->addActivity(*entry.data(), mBitmap->Handle()));
       
   309 }
       
   310 
       
   311 // ---------------------------------------------------------------------------
       
   312 // ---------------------------------------------------------------------------
       
   313 //
       
   314 void T_ActivityClient::testUpdateActivity()
       
   315 {
       
   316     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   317     QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));
       
   318     
       
   319     client->removeActivity(*entry.data());
       
   320     client->addActivity(*entry.data(), mBitmap->Handle());
       
   321     
       
   322     QVERIFY(KErrNone == client->updateActivity(*entry.data(), mBitmap->Handle()));
       
   323 }
       
   324 
       
   325 // ---------------------------------------------------------------------------
       
   326 // ---------------------------------------------------------------------------
       
   327 //
       
   328 void T_ActivityClient::testSaveActivity()
       
   329 {
       
   330     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   331     QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));
       
   332 
       
   333     client->removeActivity(*entry.data());
       
   334     QVERIFY(KErrNone == client->saveActivity(*entry.data(), mBitmap->Handle()));
       
   335     QVERIFY(KErrNone == client->saveActivity(*entry.data(), mBitmap->Handle()));
       
   336 }
       
   337 
       
   338 // ---------------------------------------------------------------------------
       
   339 // ---------------------------------------------------------------------------
       
   340 //
       
   341 void T_ActivityClient::testRemoveActivity()
       
   342 {
       
   343     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   344     QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));
       
   345 
       
   346     client->removeActivity(*entry.data());
       
   347     client->addActivity(*entry.data(), mBitmap->Handle());
       
   348 
       
   349     QVERIFY(KErrNone == client->removeActivity(*entry.data()));
       
   350 }
       
   351 
       
   352 // ---------------------------------------------------------------------------
       
   353 // ---------------------------------------------------------------------------
       
   354 //
       
   355 void T_ActivityClient::testRemoveApplicationActivities()
       
   356 {
       
   357     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   358     QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));
       
   359 
       
   360     client->removeActivity(*entry.data());
       
   361     client->addActivity(*entry.data(), mBitmap->Handle());
       
   362     
       
   363     QVERIFY(KErrNone == client->removeApplicationActivities(*entry.data()));
       
   364 }
       
   365 
       
   366 // ---------------------------------------------------------------------------
       
   367 // ---------------------------------------------------------------------------
       
   368 //
       
   369 void T_ActivityClient::testActivities()
       
   370 {
       
   371     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   372     QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));
       
   373 
       
   374     client->removeActivity(*entry.data());
       
   375     
       
   376     int activityCountBeforeAdding, activityCountAfterAdding;
       
   377     {
       
   378         RPointerArray<CAfEntry> results;
       
   379         int callResult = client->activities(results);
       
   380         activityCountBeforeAdding = results.Count();
       
   381         results.ResetAndDestroy();
       
   382         
       
   383         QVERIFY(KErrNone == callResult);
       
   384     }
       
   385         
       
   386     QVERIFY(KErrNone == client->addActivity(*entry.data(), mBitmap->Handle()));
       
   387     
       
   388     {
       
   389         RPointerArray<CAfEntry> results;
       
   390         int callResult = client->activities(results);
       
   391         activityCountAfterAdding = results.Count();
       
   392         results.ResetAndDestroy();
       
   393         
       
   394         QVERIFY(KErrNone == callResult);
       
   395     }    
       
   396     
       
   397     QCOMPARE(activityCountAfterAdding, activityCountBeforeAdding + 1);
       
   398     
       
   399     client->removeActivity(*entry.data());
       
   400 }
       
   401 
       
   402 // ---------------------------------------------------------------------------
       
   403 // ---------------------------------------------------------------------------
       
   404 //
       
   405 void T_ActivityClient::testApplicationActivities()
       
   406 {
       
   407     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   408 
       
   409     QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));
       
   410     QVERIFY(KErrNone == client->removeApplicationActivities(*entry.data()));    
       
   411     
       
   412     const QString expectedActivityName("ActivityName%1");
       
   413     const int activityCount(20);
       
   414     
       
   415     {
       
   416         RPointerArray<CAfEntry> results;
       
   417         int callResult = client->applicationActivities(results, *entry.data());
       
   418         int resultCount = results.Count();
       
   419         results.ResetAndDestroy();
       
   420         
       
   421         QVERIFY(KErrNone == callResult);
       
   422         QCOMPARE(resultCount, 0);
       
   423     }
       
   424     
       
   425     for (int i=0; i < activityCount; ++i) {
       
   426         QScopedPointer<HBufC> activityName(XQConversions::qStringToS60Desc(QString(expectedActivityName).arg(i)));
       
   427         QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, *activityName.data(), KNullDesC(), KNullDesC8(), KNullDesC8()));
       
   428         client->addActivity(*entry.data(), mBitmap->Handle());
       
   429     }
       
   430     
       
   431     {
       
   432         RPointerArray<CAfEntry> results;
       
   433         int callResult = client->applicationActivities(results, *entry.data());
       
   434         int resultCount = results.Count();
       
   435         results.ResetAndDestroy();
       
   436         
       
   437         QVERIFY(KErrNone == callResult);
       
   438         QCOMPARE(resultCount, activityCount);
       
   439     }
       
   440     
       
   441     QVERIFY(KErrNone == client->removeApplicationActivities(*entry.data()));
       
   442 }
       
   443 
       
   444 // ---------------------------------------------------------------------------
       
   445 // ---------------------------------------------------------------------------
       
   446 //
       
   447 void T_ActivityClient::testGetData()
       
   448 {
       
   449     _LIT8(KPrivateData, "My private data");
       
   450     _LIT8(KPublicData, "My public data");
       
   451     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   452     QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, 1, KActivityName(), KNullDesC(), KPrivateData(), KPublicData()));
       
   453     
       
   454     client->removeActivity(*entry.data());
       
   455     QVERIFY(KErrNone == client->addActivity(*entry.data(), mBitmap->Handle()));
       
   456     
       
   457     CAfEntry *result(0);
       
   458     QVERIFY(0 == client->activityData(result, *entry.data()));
       
   459     
       
   460     QScopedPointer<CAfEntry> guardedResult(result);
       
   461     QVERIFY(0 == guardedResult->Data(CAfEntry::Private).Compare(KPrivateData()));
       
   462     QVERIFY(0 == guardedResult->Data(CAfEntry::Public).Compare(KPublicData()));
       
   463 }
       
   464 
       
   465 // ---------------------------------------------------------------------------
       
   466 // ---------------------------------------------------------------------------
       
   467 //
       
   468 void T_ActivityClient::testWaitLaunchActivity()
       
   469 {
       
   470     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   471     QScopedPointer<CAfStorageClient> launcher(CAfStorageClient::NewL(*this));
       
   472     
       
   473     QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, RProcess().SecureId().iId, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));
       
   474     
       
   475     QVERIFY(KErrNone == client->waitActivity());
       
   476     QVERIFY(KErrNone == launcher->launchActivity(*entry.data()));
       
   477     mLoop.exec();
       
   478     
       
   479     QVERIFY(mData);
       
   480     QVERIFY(0 == mData->Compare(KActivityName()));
       
   481 }
       
   482 
       
   483 // ---------------------------------------------------------------------------
       
   484 // ---------------------------------------------------------------------------
       
   485 //
       
   486 void T_ActivityClient::testGetThumbnail()
       
   487 {
       
   488     QScopedPointer<CAfStorageClient> client(CAfStorageClient::NewL(*this));
       
   489     QScopedPointer<CAfEntry> entry(CAfEntry::NewL(0, RProcess().SecureId().iId, KActivityName(), KNullDesC(), KNullDesC8(), KNullDesC8()));
       
   490 
       
   491     client->removeActivity(*entry.data());
       
   492     QVERIFY(KErrNone == client->addActivity(*entry.data(), mBitmap->Handle()));
       
   493     
       
   494     RPointerArray<CAfEntry> results;    
       
   495     QVERIFY(KErrNone == client->activities(results));
       
   496     
       
   497     QTimer timeout;
       
   498     timeout.setSingleShot(true);
       
   499     timeout.setInterval(5000);
       
   500     mLoop.connect(&timeout, SIGNAL(timeout()), SLOT(quit()));
       
   501     
       
   502     for (int iter=0; iter < results.Count(); ++iter) {
       
   503         //valid thumbnail
       
   504         QVERIFY(KErrNone == client->getThumbnail(TSize(50, 10), results[iter]->ImageSrc(), this));
       
   505         timeout.start();
       
   506         mLoop.exec();
       
   507         QVERIFY(timeout.isActive());
       
   508         timeout.stop();        
       
   509         
       
   510         QVERIFY(mScreenshotHandle >= 0);
       
   511         {
       
   512             QScopedPointer<CFbsBitmap> bitmap(new CFbsBitmap());
       
   513             QCOMPARE(bitmap->Duplicate(mScreenshotHandle), KErrNone);    
       
   514             TSize bitmapSize = bitmap->SizeInPixels();
       
   515             QVERIFY(50 >= bitmapSize.iWidth);
       
   516             QVERIFY(10 >= bitmapSize.iHeight);
       
   517             delete mScreenshot;
       
   518             mScreenshot = 0;
       
   519         }
       
   520         QVERIFY(this == mUserData);
       
   521         
       
   522         //invalid width
       
   523         QVERIFY(KErrNone == client->getThumbnail(TSize(0, 10), results[iter]->ImageSrc(), this));
       
   524         timeout.start();
       
   525         mLoop.exec();
       
   526         QVERIFY(timeout.isActive());
       
   527         timeout.stop();
       
   528         QVERIFY(mScreenshotHandle < 0);
       
   529         QVERIFY(this == mUserData);
       
   530         
       
   531         //invalid height
       
   532         QVERIFY(KErrNone == client->getThumbnail(TSize(50, 0), results[iter]->ImageSrc(), this));
       
   533         timeout.start();
       
   534         mLoop.exec();
       
   535         QVERIFY(timeout.isActive());
       
   536         timeout.stop();
       
   537         QVERIFY(mScreenshotHandle < 0);
       
   538         QVERIFY(this == mUserData);
       
   539         
       
   540         //invalid thumbnail
       
   541         QVERIFY(KErrNone == client->getThumbnail(TSize(50, 10), _L("s:/ome/fake/path.mbm"), this));
       
   542         timeout.start();
       
   543         mLoop.exec();
       
   544         QVERIFY(timeout.isActive());
       
   545         timeout.stop();
       
   546         QVERIFY(mScreenshotHandle < 0);
       
   547         QVERIFY(this == mUserData);
       
   548     }
       
   549     results.ResetAndDestroy();
       
   550 }
       
   551 
       
   552 QTEST_MAIN(T_ActivityClient)