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