Update contrib.
1 // Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).
2 // All rights reserved.
3 // This component and the accompanying materials are made available
4 // under the terms of "Eclipse Public License v1.0"
5 // which accompanies this distribution, and is available
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
8 // Initial Contributors:
9 // Nokia Corporation - initial contribution.
17 #include <graphics/bitmapuid.h>
18 #include "../sfbs/UTILS.H"
21 #include "../sfbs/fbsbitmapasyncstreamer.h"
22 #include "fbsmessage.h"
25 const TSize KLargeSize(4096 + 100, 1);
26 const TSize KLargeSizeAlt(4096 + 200, 2);
27 const TSize KSmallSize(10, 10);
28 const TSize KSmallSizeAlt(20, 20);
30 CTAlloc::CTAlloc(CTestStep* aStep):
31 CTGraphicsBase(aStep),
37 INFO_PRINTF1(_L("Font/Bitmap Server Alloc Failure Recovery Testing"));
44 iFbs->SendCommand(EFbsMessShutdown);
51 void CTAlloc::ConstructL()
53 iStore = CFbsTypefaceStore::NewL(NULL);
55 if(RFbsSession::Connect()==KErrNone)
57 RFbsSession::Disconnect();
58 iShutdownFbs = EFalse;
67 void CTAlloc::RunTestCaseL(TInt aCurTestCase)
69 ((CTAllocStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
73 ((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0511"));
79 @SYMTestCaseID GRAPHICS-FBSERV-0611
81 ((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0611"));
82 TInt ret = RFbsSession::Connect();
84 iFbs = RFbsSession::GetSession();
89 ((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0512"));
93 ((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0514"));
97 ((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0513"));
101 ((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0515"));
105 ((CTAllocStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
106 ((CTAllocStep*)iStep)->CloseTMSGraphicsStep();
110 ((CTAllocStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
113 ((CTAllocStep*)iStep)->RecordTestResultL();
121 Allocated sessions with the FbsServer and simulates memory allocation errors
126 @SYMTestExpectedResults
129 void CTAlloc::Session()
131 INFO_PRINTF1(_L("RFbsSession::Connect()\r\n"));
133 for (TInt count = 1; ; count++)
135 __UHEAP_FAILNEXT(count);
138 TInt ret = RFbsSession::Connect();
140 if (ret == KErrNoMemory)
144 else if (ret == KErrNone)
146 RFbsSession::Disconnect();
153 TEST2(ret, KErrNone);
165 Creates bitmaps in different ways and checks if memory allocation succeeded
168 Creates normal size bitmaps, large bitmaps, loads bitmaps, loads shared bitmaps,
169 duplicated bitmaps, resizes bitmaps, compresses bitmaps, externalized bitmaps to write store,
170 internalizes bitmaps back again from write store. All ways of creating bitmaps are tested
171 against Out Of Memory error conditions
173 @SYMTestExpectedResults
176 void CTAlloc::BitmapsL()
178 TInt heapMarkCheckFlag;
179 if( !iStep->GetIntFromConfig(KDefaultSectionName, KFbsHeapMarkCheckFlag, heapMarkCheckFlag) )
181 INFO_PRINTF1(_L("Error reading ini file"));
182 User::Leave(KErrNotFound);
188 iTestBitmapName = KTestBitmapOnZ;
189 TInt ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL);
190 TEST2(ret, KErrNone);
192 ret = iBitmap.Create(KLargeSize,EColor256); // Expand server caches
193 TEST2(ret, KErrNone);
199 INFO_PRINTF1(_L("CFbsBitmap::Create()\r\n"));
200 for (count = 1; ; count++)
202 iFbs->SendCommand(EFbsMessDefaultAllocFail,count);
203 if(heapMarkCheckFlag)
205 iFbs->SendCommand(EFbsMessDefaultMark);
206 iFbs->SendCommand(EFbsMessUserMark);
208 ret = iBitmap.Create(KSmallSize,EColor256);
210 if (ret == KErrNoMemory)
212 if(heapMarkCheckFlag)
214 iFbs->SendCommand(EFbsMessDefaultMark);
215 iFbs->SendCommand(EFbsMessUserMark);
218 else if (ret == KErrNone)
221 if(heapMarkCheckFlag)
223 iFbs->SendCommand(EFbsMessDefaultMark);
224 iFbs->SendCommand(EFbsMessUserMark);
229 TEST2(ret, KErrNone);
232 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
233 iFbs->SendCommand(EFbsMessUserAllocFail,0);
234 TEST(iFbs->ResourceCount()==0);
236 for (count = 1; ; count++)
238 iFbs->SendCommand(EFbsMessUserAllocFail,count);
239 if(heapMarkCheckFlag)
241 iFbs->SendCommand(EFbsMessDefaultMark);
242 iFbs->SendCommand(EFbsMessUserMark);
245 ret=iBitmap.Create(KSmallSize,EGray2);
247 if (ret == KErrNoMemory)
249 if(heapMarkCheckFlag)
251 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
252 iFbs->SendCommand(EFbsMessUserMarkEnd);
255 else if (ret == KErrNone)
258 if(heapMarkCheckFlag)
260 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
261 iFbs->SendCommand(EFbsMessUserMarkEnd);
266 TEST2(ret, KErrNone);
269 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
270 iFbs->SendCommand(EFbsMessUserAllocFail,0);
271 TEST(iFbs->ResourceCount()==0);
274 for (count = 1; ; count++)
276 iFbs->SendCommand(EFbsMessDefaultAllocFail,count);
277 if(heapMarkCheckFlag)
279 iFbs->SendCommand(EFbsMessDefaultMark);
280 iFbs->SendCommand(EFbsMessUserMark);
283 ret = iBitmap.Create(KLargeSize,EColor256);
285 if (ret == KErrNoMemory)
287 if(heapMarkCheckFlag)
289 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
290 iFbs->SendCommand(EFbsMessUserMarkEnd);
293 else if (ret == KErrNone)
296 if(heapMarkCheckFlag)
298 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
299 iFbs->SendCommand(EFbsMessUserMarkEnd);
304 TEST2(ret, KErrNone);
307 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
308 iFbs->SendCommand(EFbsMessUserAllocFail,0);
309 TEST(iFbs->ResourceCount()==0);
311 for (count = 1; ; count++)
313 iFbs->SendCommand(EFbsMessUserAllocFail,count);
314 if(heapMarkCheckFlag)
316 iFbs->SendCommand(EFbsMessDefaultMark);
317 iFbs->SendCommand(EFbsMessUserMark);
320 ret = iBitmap.Create(KLargeSize,EColor256);
322 if (ret == KErrNoMemory)
324 if(heapMarkCheckFlag)
326 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
327 iFbs->SendCommand(EFbsMessUserMarkEnd);
330 else if (ret == KErrNone)
333 if(heapMarkCheckFlag)
335 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
336 iFbs->SendCommand(EFbsMessUserMarkEnd);
341 TEST2(ret, KErrNone);
344 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
345 iFbs->SendCommand(EFbsMessUserAllocFail,0);
346 TEST(iFbs->ResourceCount()==0);
349 INFO_PRINTF1(_L("CFbsBitmap::Load()\r\n"));
350 ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL);
351 TEST2(ret, KErrNone);
353 for (count = 1; ; count++)
355 iFbs->SendCommand(EFbsMessDefaultAllocFail,count);
356 if(heapMarkCheckFlag)
358 iFbs->SendCommand(EFbsMessDefaultMark);
359 iFbs->SendCommand(EFbsMessUserMark);
362 ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL);
364 if (ret == KErrNoMemory)
366 if(heapMarkCheckFlag)
368 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
369 iFbs->SendCommand(EFbsMessUserMarkEnd);
372 else if (ret == KErrNone)
375 if(heapMarkCheckFlag)
377 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
378 iFbs->SendCommand(EFbsMessUserMarkEnd);
383 TEST2(ret, KErrNone);
386 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
387 iFbs->SendCommand(EFbsMessUserAllocFail,0);
388 TEST(iFbs->ResourceCount()==0);
390 for (count = 1; ; count++)
392 iFbs->SendCommand(EFbsMessUserAllocFail,count);
393 if(heapMarkCheckFlag)
395 iFbs->SendCommand(EFbsMessDefaultMark);
396 iFbs->SendCommand(EFbsMessUserMark);
399 ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL);
401 if (ret == KErrNoMemory)
403 if(heapMarkCheckFlag)
405 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
406 iFbs->SendCommand(EFbsMessUserMarkEnd);
409 else if (ret == KErrNone)
412 if(heapMarkCheckFlag)
414 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
415 iFbs->SendCommand(EFbsMessUserMarkEnd);
420 TEST2(ret, KErrNone);
423 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
424 iFbs->SendCommand(EFbsMessUserAllocFail,0);
425 TEST(iFbs->ResourceCount()==0);
428 INFO_PRINTF1(_L("CFbsBitmap::Load() - shared \r\n"));
430 // Do an initial load to ensure the StreamId cache does not get updated whilst OOM testing
431 ret = iBitmap.Load(iTestBitmapName,ETfbs,ETrue);
432 TEST2(ret, KErrNone);
435 for (count = 1; ; count++)
437 iFbs->SendCommand(EFbsMessDefaultAllocFail,count);
438 if(heapMarkCheckFlag)
440 iFbs->SendCommand(EFbsMessDefaultMark);
441 iFbs->SendCommand(EFbsMessUserMark);
444 ret = iBitmap.Load(iTestBitmapName,ETfbs,ETrue);
446 if (ret == KErrNoMemory)
448 if(heapMarkCheckFlag)
450 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
451 iFbs->SendCommand(EFbsMessUserMarkEnd);
455 else if (ret != KErrNone)
456 TEST2(ret, KErrNone);
458 ret = iBitmap2.Load(iTestBitmapName,ETfbs,ETrue);
460 if (ret == KErrNoMemory)
463 if(heapMarkCheckFlag)
465 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
466 iFbs->SendCommand(EFbsMessUserMarkEnd);
470 else if (ret == KErrNone)
474 if(heapMarkCheckFlag)
476 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
477 iFbs->SendCommand(EFbsMessUserMarkEnd);
482 TEST2(ret, KErrNone);
485 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
486 iFbs->SendCommand(EFbsMessUserAllocFail,0);
487 TEST(iFbs->ResourceCount()==0);
489 for (count = 1; ; count++)
491 iFbs->SendCommand(EFbsMessUserAllocFail,count);
492 if(heapMarkCheckFlag)
494 iFbs->SendCommand(EFbsMessDefaultMark);
495 iFbs->SendCommand(EFbsMessUserMark);
498 ret = iBitmap.Load(iTestBitmapName,ETfbs,ETrue);
500 if (ret == KErrNoMemory)
502 if(heapMarkCheckFlag)
504 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
505 iFbs->SendCommand(EFbsMessUserMarkEnd);
509 else if (ret != KErrNone)
510 TEST2(ret, KErrNone);
512 ret = iBitmap2.Load(iTestBitmapName,ETfbs,ETrue);
514 if (ret == KErrNoMemory)
517 if(heapMarkCheckFlag)
519 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
520 iFbs->SendCommand(EFbsMessUserMarkEnd);
524 else if (ret == KErrNone)
528 if(heapMarkCheckFlag)
530 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
531 iFbs->SendCommand(EFbsMessUserMarkEnd);
536 TEST2(ret, KErrNone);
539 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
540 iFbs->SendCommand(EFbsMessUserAllocFail,0);
541 TEST(iFbs->ResourceCount()==0);
546 ret = bmpalt.Create(KSmallSize,EColor256);
547 TEST2(ret, KErrNone);
549 INFO_PRINTF1(_L("CFbsBitmap::Duplicate()\r\n"));
550 for (count = 1; ; count++)
552 iFbs->SendCommand(EFbsMessDefaultAllocFail,count);
553 if(heapMarkCheckFlag)
555 iFbs->SendCommand(EFbsMessDefaultMark);
556 iFbs->SendCommand(EFbsMessUserMark);
559 ret = iBitmap.Duplicate(bmpalt.Handle());
561 if (ret == KErrNoMemory)
563 if(heapMarkCheckFlag)
565 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
566 iFbs->SendCommand(EFbsMessUserMarkEnd);
569 else if (ret == KErrNone)
572 if(heapMarkCheckFlag)
574 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
575 iFbs->SendCommand(EFbsMessUserMarkEnd);
580 TEST2(ret, KErrNone);
583 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
584 iFbs->SendCommand(EFbsMessUserAllocFail,0);
585 TEST(iFbs->ResourceCount()==1);
586 ret = bmpalt.Create(KSmallSize,EColor256);
587 TEST2(ret, KErrNone);
589 for (count = 1; ; count++)
591 iFbs->SendCommand(EFbsMessUserAllocFail,count);
592 if(heapMarkCheckFlag)
594 iFbs->SendCommand(EFbsMessDefaultMark);
595 iFbs->SendCommand(EFbsMessUserMark);
598 ret = iBitmap.Duplicate(bmpalt.Handle());
600 if (ret == KErrNoMemory)
602 if(heapMarkCheckFlag)
604 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
605 iFbs->SendCommand(EFbsMessUserMarkEnd);
608 else if (ret == KErrNone)
611 if(heapMarkCheckFlag)
613 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
614 iFbs->SendCommand(EFbsMessUserMarkEnd);
619 TEST2(ret, KErrNone);
622 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
623 iFbs->SendCommand(EFbsMessUserAllocFail,0);
625 TEST(iFbs->ResourceCount()==0);
628 // force fbserv to do a resize. This makes the pile to insert an index in it's array
629 // If the array is empty when the tests below are run then the insert will look like a mem leak
630 ret=iBitmap.Create(KLargeSize,EColor256);
631 iBitmap.Resize(KLargeSizeAlt);
634 ret=iBitmap.Create(KSmallSize,EColor256);
635 TEST2(ret, KErrNone);
637 INFO_PRINTF1(_L("CFbsBitmap::Resize()\r\n"));
638 for (count = 1; ; count++)
640 iFbs->SendCommand(EFbsMessDefaultAllocFail,count);
641 if(heapMarkCheckFlag)
643 iFbs->SendCommand(EFbsMessDefaultMark);
644 iFbs->SendCommand(EFbsMessUserMark);
647 ret = iBitmap.Resize(KSmallSizeAlt);
649 if (ret == KErrNoMemory)
651 if(heapMarkCheckFlag)
653 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
654 iFbs->SendCommand(EFbsMessUserMarkEnd);
657 else if (ret == KErrNone)
660 if(heapMarkCheckFlag)
662 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
663 iFbs->SendCommand(EFbsMessUserMarkEnd);
668 TEST2(ret, KErrNone);
671 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
672 iFbs->SendCommand(EFbsMessUserAllocFail,0);
673 TEST(iFbs->ResourceCount()==0);
676 // force fbserv to do a resize. This makes the pile to insert an index in it's array
677 // If the array is empty when the tests below are run then the insert will look like a mem leak
678 ret=iBitmap.Create(KLargeSize,EColor256);
679 iBitmap.Resize(KLargeSizeAlt);
682 ret=iBitmap.Create(KLargeSize,EColor256);
683 TEST2(ret, KErrNone);
685 for (count = 1; ; count++)
687 iFbs->SendCommand(EFbsMessUserAllocFail,count);
688 if(heapMarkCheckFlag)
690 iFbs->SendCommand(EFbsMessDefaultMark);
691 iFbs->SendCommand(EFbsMessUserMark);
694 ret = iBitmap.Resize(KLargeSizeAlt);
696 if (ret == KErrNoMemory)
698 if(heapMarkCheckFlag)
700 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
701 iFbs->SendCommand(EFbsMessUserMarkEnd);
704 else if (ret == KErrNone)
707 if(heapMarkCheckFlag)
709 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
710 iFbs->SendCommand(EFbsMessUserMarkEnd);
715 TEST2(ret, KErrNone);
718 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
719 iFbs->SendCommand(EFbsMessUserAllocFail,0);
720 TEST(iFbs->ResourceCount()==0);
723 ret=iBitmap.Create(KSmallSize,EColor256);
724 TEST2(ret, KErrNone);
726 INFO_PRINTF1(_L("CFbsBitmap::Compress()\r\n"));
727 for (count = 1; ; count++)
729 iFbs->SendCommand(EFbsMessDefaultAllocFail,count);
730 if(heapMarkCheckFlag)
732 iFbs->SendCommand(EFbsMessDefaultMark);
733 iFbs->SendCommand(EFbsMessUserMark);
736 ret = iBitmap.Compress();
738 if (ret == KErrNoMemory)
740 if(heapMarkCheckFlag)
742 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
743 iFbs->SendCommand(EFbsMessUserMarkEnd);
746 else if (ret == KErrNone)
749 if(heapMarkCheckFlag)
751 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
752 iFbs->SendCommand(EFbsMessUserMarkEnd);
757 TEST2(ret, KErrNone);
760 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
761 iFbs->SendCommand(EFbsMessUserAllocFail,0);
762 TEST(iFbs->ResourceCount()==0);
764 ret=iBitmap.Create(KLargeSize,EColor256);
765 TEST2(ret, KErrNone);
767 INFO_PRINTF1(_L("CFbsBitmap::Compress()\r\n"));
768 for (count = 1; ; count++)
770 iFbs->SendCommand(EFbsMessDefaultAllocFail,count);
771 if(heapMarkCheckFlag)
773 iFbs->SendCommand(EFbsMessDefaultMark);
774 iFbs->SendCommand(EFbsMessUserMark);
777 ret = iBitmap.Compress();
779 if (ret == KErrNoMemory)
781 if(heapMarkCheckFlag)
783 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
784 iFbs->SendCommand(EFbsMessUserMarkEnd);
787 else if (ret == KErrNone)
790 if(heapMarkCheckFlag)
792 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
793 iFbs->SendCommand(EFbsMessUserMarkEnd);
798 TEST2(ret, KErrNone);
801 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
802 iFbs->SendCommand(EFbsMessUserAllocFail,0);
803 TEST(iFbs->ResourceCount()==0);
805 // WriteStore creation
808 TEST2(ret, KErrNone);
809 CDirectFileStore* writestore=NULL;
811 //Construct filename using the thread id to enable concurrent test runs.
812 _LIT(KSbmFileName,"c:\\tall_");
813 TBuf<36> buf(KSbmFileName);
814 TThreadId threadId = RThread().Id();
815 TUint64 id = threadId.Id();
816 TBuf<20> threadIdBuf;
818 buf.Append(threadIdBuf);
819 buf.Append(_L(".sbm"));
821 TRAP(ret,writestore=CDirectFileStore::ReplaceL(fs,buf,EFileStream|EFileWrite));
822 TEST2(ret, KErrNone);
823 TUidType uidtype(KDirectFileStoreLayoutUid,KMultiBitmapFileImageUid);
824 TRAP(ret,writestore->SetTypeL(uidtype));
825 TEST2(ret, KErrNone);
827 RStoreWriteStream writestrm;
828 TStreamId headerid(0);
829 TRAP(ret,headerid=writestrm.CreateL(*writestore));
830 TEST2(ret, KErrNone);
831 TRAP(ret,writestore->SetRootL(headerid));
832 TEST2(ret, KErrNone);
835 ret=iBitmap.Create(KSmallSize,EColor256);
836 TEST2(ret, KErrNone);
838 INFO_PRINTF1(_L("CFbsBitmap::ExternalizeL()\r\n"));
839 for (count = 1; ; count++)
841 __UHEAP_SETFAIL(RHeap::EDeterministic,count);
844 TRAP(ret,iBitmap.ExternalizeL(writestrm));
846 if (ret == KErrNoMemory)
850 else if (ret == KErrNone)
859 TEST2(ret, KErrNone);
864 TEST(iFbs->ResourceCount()==0);
866 // ExternalizeRectangle
867 ret=iBitmap.Create(KSmallSize,EColor256);
868 TEST2(ret, KErrNone);
870 INFO_PRINTF1(_L("CFbsBitmap::ExternalizeRectangleL()\r\n"));
871 for (count = 1; ; count++)
873 __UHEAP_SETFAIL(RHeap::EDeterministic,count);
876 TRAP(ret,iBitmap.ExternalizeRectangleL(writestrm,TRect(3,3,7,7)));
878 if (ret == KErrNoMemory)
882 else if (ret == KErrNone)
890 TEST2(ret, KErrNone);
898 TEST(iFbs->ResourceCount()==0);
901 INFO_PRINTF1(_L("CFbsBitmap::InternalizeL()\r\n"));
902 for (count = 1; ; count++)
904 // ReadStore creation
905 CDirectFileStore* readstore=NULL;
906 TRAP(ret,readstore=CDirectFileStore::OpenL(fs,buf,EFileStream|EFileRead|EFileShareAny));
907 TEST2(ret, KErrNone);
908 RStoreReadStream readstrm;
909 headerid=readstore->Root();
910 TRAP(ret,readstrm.OpenL(*readstore,headerid));
911 TEST2(ret, KErrNone);
913 iFbs->SendCommand(EFbsMessDefaultAllocFail,count);
914 if(heapMarkCheckFlag)
916 iFbs->SendCommand(EFbsMessDefaultMark);
917 iFbs->SendCommand(EFbsMessUserMark);
920 TRAP(ret,iBitmap.InternalizeL(readstrm));
925 if (ret == KErrNoMemory)
927 if(heapMarkCheckFlag)
929 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
930 iFbs->SendCommand(EFbsMessUserMarkEnd);
933 else if (ret == KErrNone)
936 if(heapMarkCheckFlag)
938 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
939 iFbs->SendCommand(EFbsMessUserMarkEnd);
944 TEST2(ret, KErrNone);
947 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
948 iFbs->SendCommand(EFbsMessUserAllocFail,0);
949 TEST(iFbs->ResourceCount()==0);
951 for (count = 1; ; count++)
953 // ReadStore re-creation
954 CDirectFileStore* readstore=NULL;
955 // TRAP(ret,readstore=CDirectFileStore::OpenL(fs,_L("c:\\tall.sbm"),EFileStream|EFileRead|EFileShareAny));
956 TRAP(ret,readstore=CDirectFileStore::OpenL(fs,buf,EFileStream|EFileRead|EFileShareAny));
957 TEST2(ret, KErrNone);
958 headerid=readstore->Root();
959 RStoreReadStream readstrm;
960 TRAP(ret,readstrm.OpenL(*readstore,headerid));
961 TEST2(ret, KErrNone);
963 iFbs->SendCommand(EFbsMessUserAllocFail,count);
964 if(heapMarkCheckFlag)
966 iFbs->SendCommand(EFbsMessDefaultMark);
967 iFbs->SendCommand(EFbsMessUserMark);
970 TRAP(ret,iBitmap.InternalizeL(readstrm));
975 if (ret == KErrNoMemory)
977 if(heapMarkCheckFlag)
979 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
980 iFbs->SendCommand(EFbsMessUserMarkEnd);
983 else if (ret == KErrNone)
986 if(heapMarkCheckFlag)
988 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
989 iFbs->SendCommand(EFbsMessUserMarkEnd);
994 TEST2(ret, KErrNone);
997 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
998 iFbs->SendCommand(EFbsMessUserAllocFail,0);
999 TEST(iFbs->ResourceCount()==0);
1007 GRAPHICS-FBSERV-0513
1010 Checks allocations of CFbsTypeFaceStore Objects OOM conditions
1013 Uses different fonts and allocates CFbsTypeFaceStore objects
1014 and checks them under Out Of Memory conditions
1016 @SYMTestExpectedResults
1019 void CTAlloc::TypefaceStoreL()
1023 CFbsTypefaceStore* tfs = NULL;
1024 INFO_PRINTF1(_L("CFbsTypefaceStore::NewL()\r\n"));
1026 TInt heapMarkCheckFlag;
1027 if( !iStep->GetIntFromConfig(KDefaultSectionName, KFbsHeapMarkCheckFlag, heapMarkCheckFlag) )
1029 INFO_PRINTF1(_L("Error reading ini file"));
1030 User::Leave(KErrNotFound);
1033 // CFbsTypefaceStore::NewL()
1034 for (count = 1; ; count++)
1036 __UHEAP_SETFAIL(RHeap::EDeterministic,count);
1039 TRAP(ret,tfs=CFbsTypefaceStore::NewL(NULL));
1041 if (ret == KErrNoMemory)
1045 else if (ret == KErrNone)
1054 TEST2(ret, KErrNone);
1060 // CFbsTypefaceStore::SetFontNameAliasL()
1061 _LIT(KFontNameAlias,"Fubar");
1062 TRAP(ret,tfs = CFbsTypefaceStore::NewL(NULL));
1063 TEST2(ret, KErrNone);
1064 TRAP(ret, tfs->SetFontNameAliasL(_L("ExpandArray"),_L("DejaVu Serif Condensed")));
1065 TEST2(ret, KErrNone);
1066 TRAP(ret, tfs->SetFontNameAliasL(_L("ExpandArray"),KNullDesC));
1067 TEST2(ret, KErrNone);
1069 for (count = 1; ; count++)
1071 iFbs->SendCommand(EFbsMessDefaultAllocFail,count);
1072 if(heapMarkCheckFlag)
1074 iFbs->SendCommand(EFbsMessDefaultMark);
1077 TRAP(ret, tfs->SetFontNameAliasL(KFontNameAlias,_L("DejaVu Serif Condensed")));
1079 if (ret == KErrNoMemory)
1081 if(heapMarkCheckFlag)
1083 iFbs->SendCommand(EFbsMessDefaultMarkEnd);
1086 else if (ret == KErrNone)
1088 if(heapMarkCheckFlag)
1090 iFbs->SendCommand(EFbsMessDefaultMarkEnd,2);
1095 TEST2(ret, KErrNone);
1098 iFbs->SendCommand(EFbsMessDefaultAllocFail,0);
1100 // GetNearestFontToDesignHeightInTwips()
1101 TFontSpec spec(_L("SwissA"),12);
1103 ret = tfs->GetNearestFontToDesignHeightInTwips(font,spec);
1104 TEST2(ret, KErrNone);
1105 tfs->ReleaseFont(font);
1106 spec.iTypeface.iName = _L("DejaVu Serif Condensed");
1108 for (count = 1; ; count++)
1110 __UHEAP_SETFAIL(RHeap::EDeterministic,count);
1113 ret = tfs->GetNearestFontToDesignHeightInTwips(font,spec);
1115 if (ret == KErrNoMemory)
1120 else if (ret == KErrNone)
1123 tfs->ReleaseFont(font);
1130 TEST2(ret, KErrNone);
1136 // GetNearestFontToDesignHeightInTwips() with alias
1137 spec.iTypeface.iName = KFontNameAlias;
1138 TRAP(ret, tfs->SetFontNameAliasL(KFontNameAlias,_L("DejaVu Serif Condensed")));
1139 TEST2(ret, KErrNone);
1141 for (count = 1; ; count++)
1143 __UHEAP_SETFAIL(RHeap::EDeterministic,count);
1146 ret = tfs->GetNearestFontToDesignHeightInTwips(font,spec);
1148 if (ret == KErrNoMemory)
1153 else if (ret == KErrNone)
1156 tfs->ReleaseFont(font);
1163 TEST2(ret, KErrNone);
1168 TRAP(ret, tfs->SetFontNameAliasL(KFontNameAlias,KNullDesC));
1169 TEST2(ret, KErrNone);
1175 GRAPHICS-FBSERV-0514
1178 Asynchronous loading and saving of bitmaps
1181 Creates a loader for bitmaps and simulates Out Of Memory conditions
1182 and then creates and saver and simulates Out Of Memory conditions
1184 @SYMTestExpectedResults
1187 void CTAlloc::BitmapHandlerL()
1190 CFbsBitmapAsyncStreamer* bmphandler=NULL;
1194 INFO_PRINTF1(_L("CFbsBitmapAsyncStreamer::NewL()\r\n"));
1195 for (count = 1; ; count++)
1197 __UHEAP_SETFAIL(RHeap::EDeterministic,count);
1200 TRAP(ret,bmphandler = CFbsBitmapAsyncStreamer::NewL(CFbsBitmapAsyncStreamer::ELoad));
1202 if (ret == KErrNoMemory)
1206 else if (ret == KErrNone)
1215 TEST2(ret, KErrNone);
1220 TEST(iFbs->ResourceCount()==0);
1223 for (count = 1; ; count++)
1225 __UHEAP_SETFAIL(RHeap::EDeterministic,count);
1228 TRAP(ret,bmphandler=CFbsBitmapAsyncStreamer::NewL(CFbsBitmapAsyncStreamer::ESave));
1230 if (ret == KErrNoMemory)
1234 else if (ret == KErrNone)
1243 TEST2(ret, KErrNone);
1248 TEST(iFbs->ResourceCount()==0);
1253 GRAPHICS-FBSERV-0515
1256 Tests memory allocation of CFontStore object
1259 CFontStore objects is created on the heap
1261 @SYMTestExpectedResults
1264 void CTAlloc::FontStoreL()
1266 INFO_PRINTF1(_L("CFontStore::NewL()\r\n"));
1268 for (TInt count = 1; ; count++)
1270 __UHEAP_SETFAIL(RHeap::EDeterministic,count);
1273 CFontStore* fs = NULL;
1274 TRAPD(ret,fs = CFontStore::NewL(&User::Heap()));
1276 if (ret == KErrNoMemory)
1280 else if (ret == KErrNone)
1284 __UHEAP_SETFAIL(RHeap::ENone,count);
1290 TEST2(ret, KErrNone);
1297 __CONSTRUCT_STEP__(Alloc)