diff -r 000000000000 -r 5d03bc08d59c fbs/fontandbitmapserver/tfbs/TFBSDefect.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fbs/fontandbitmapserver/tfbs/TFBSDefect.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,475 @@ +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include "../sfbs/UTILS.H" +#include "TFBSDefect.h" +#include "fbsmessage.h" + +CTFbsDefect::CTFbsDefect(CTestStep* aStep) : + CTGraphicsBase(aStep) + { + + } + +/** + @SYMTestCaseID + GRAPHICS-FBSERV-0574 + + @SYMTestCaseDesc + Checks for leaking thread handles during + creation of bitmaps + + @SYMDEF INC041784 + + @SYMTestActions + Retrieves the process handle count and the + thread handle count. Creates a bitmap with + the specified size and display mode. The bitmap + is created on the font and bitmap server's shared + heap. The thread handle count is retrieved again + and compared against the first thread handle count + and they should match. + + @SYMTestExpectedResults + Test should pass +*/ +void CTFbsDefect::CreateBitmapTestL() + { + INFO_PRINTF1(_L("CreateBitmapTestL (INC041784)")); + + // and leaking thread handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + TInt endProcessHandleCount; + TInt endThreadHandleCount; + + RThread thisThread; + thisThread.HandleCount(startProcessHandleCount, startThreadHandleCount); + + // Test Starts... + // + + const TSize size(100, 100); + + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + + TEST (bitmap->Create(size, ERgb) == KErrArgument); + TEST (bitmap->Create(size, ENone) == KErrArgument); + TEST (bitmap->Create(size, EColor16) == KErrNone); + + CleanupStack::PopAndDestroy(bitmap); + + // + // Test Ends... + + // Check for open handles + thisThread.HandleCount(endProcessHandleCount, endThreadHandleCount); + + TEST(startThreadHandleCount == endThreadHandleCount); + } + +/** + @SYMTestCaseID + GRAPHICS-FBSERV-0575 + + @SYMDEF DEF042528 + + @SYMTestCaseDesc + Tests replacing initial display with all the + possible higher display mode and tests replacing + initial display with all the possible lower display mode. + + @SYMTestActions + Creates a bitmap. Creates an array containing display modes. + For each display mode it sets the display mode to a higher + display mode and checks for errors. Then for each display mode + it sets the display mode to a lower display mode and checks + for errors. + + @SYMTestExpectedResults + Test should pass +*/ +void CTFbsDefect::TestDisplayModeL() + { + INFO_PRINTF1(_L("TestDisplayModeL (DEF042528)")); + + const TSize size(10,10); + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + //TDisplayMode value= { 1 , 2 , 3 , 4 , 5 6 10 7 8 11 12 13 + TDisplayMode mode[] = {EGray2,EGray4,EGray16,EGray256,EColor16,EColor256,EColor4K,EColor64K,EColor16M,EColor16MU,EColor16MA,EColor16MAP}; + + TInt arraysize=sizeof(mode)/sizeof(mode[0]); + INFO_PRINTF2(_L("Array size=%d\n"),arraysize); + TInt ret; + + //Test for replacing initial display with all the possible higher display mode + //This should not work and all the values returned by SetDisplayMode()==KErrArgument + for (TInt i=0;iCreate(size,mode[i]); + INFO_PRINTF2(_L("Initial mode: %d\n"),mode[i]); + TEST(ret==KErrNone); + for (TInt j=i+1;jSetDisplayMode(mode[j]); + INFO_PRINTF3(_L("Changing to display mode=%d with ret value=%d\n "),mode[j],ret); + TEST(ret==KErrNone); + } + else + { + ret=bitmap->SetDisplayMode(mode[j]); + INFO_PRINTF3(_L("Changing to display mode %d with ret value %d \n"),mode[j],ret); + TEST(ret==KErrArgument); + } + } + INFO_PRINTF1(_L("End of mode \n")); + } + + //Test for replacing initial display with all the possible lower display mode + //This should work fine and all the values returned by SetDisplayMode()==KErrNone + INFO_PRINTF1(_L("\n\n")); + for (TInt k=arraysize-1;k>=0;k--) + { + ret=bitmap->Create(size,mode[k]); + INFO_PRINTF2(_L("Initial mode=%d\n"),mode[k]); + TEST(ret==KErrNone); + for (TInt l=k-1;l>=0;l--) + { + + if (mode[k]==EColor16 && mode[l]==EGray256) + { + //special case where we cannot change from EColor16 to EGray256 + ret=bitmap->SetDisplayMode(mode[l]); + INFO_PRINTF3(_L("Changing to display mode=%d with ret value=%d\n "),mode[l],ret); + TEST(ret==KErrArgument); + } + + else + { + ret=bitmap->SetDisplayMode(mode[l]); + INFO_PRINTF3(_L("Changing to display mode=%d with ret value=%d\n "),mode[l],ret); + TEST(ret==KErrNone); + } + } + + } + + bitmap->Reset(); + delete bitmap; + } + +/* Creates and destroys large bitmaps */ +TInt BitmapCreate(TAny* /* aAny */) + { + RFbsSession fbs; + TInt err = fbs.Connect(); + User::LeaveIfError(err); + RFbsSession* fbs2 = RFbsSession::GetSession(); + + FOREVER + { + CFbsBitmap bitmap; + bitmap.Create(TSize(300,200), EColor16MU); + bitmap.Reset(); + fbs2->SendCommand(EFbsCompress, 0); + User::After(1); + } + } + +void CleanupFbsConnection(TAny* aPtr) + { + RFbsSession* fbs = static_cast(aPtr); + fbs->Disconnect(); + } + +void CleanupLoadedBitmap(TAny* aPtr) + { + RPointerArray* ptrArray = (static_cast*>(aPtr)); + ptrArray->ResetAndDestroy(); + ptrArray->Close(); + } + +void FillBitmapArray(RPointerArray& aArray) + { + for(TInt count=100; count>=0; --count) + { + CFbsBitmap* bitmap = new CFbsBitmap; + if (!bitmap) + return; + + TInt err = bitmap->Create(TSize(100,100), EColor16MU); + + if (err == KErrNone) + { + err = aArray.Append(bitmap); + } + + if (err != KErrNone) + { + delete bitmap; + return; + } + } + } + +void DoBitmapUseL() + { + RFbsSession fbs; + TInt err = fbs.Connect(); + User::LeaveIfError(err); + TCleanupItem fbsConnectionCleanup(CleanupFbsConnection, &fbs); + CleanupStack::PushL(fbsConnectionCleanup); + + RPointerArray stressBitmaps; + TCleanupItem loadedBitmapCleanup(CleanupLoadedBitmap, &stressBitmaps); + CleanupStack::PushL(loadedBitmapCleanup); + FillBitmapArray(stressBitmaps); + + CFbsBitmap* outputBitmap=new(ELeave) CFbsBitmap; + CleanupStack::PushL(outputBitmap); + User::LeaveIfError(outputBitmap->Create(TSize(200,200),EColor16MU)); + CFbsBitmapDevice *bgDevice=CFbsBitmapDevice::NewL(outputBitmap); + CleanupStack::PushL(bgDevice); + CFbsBitGc* bgGc=NULL; + User::LeaveIfError(bgDevice->CreateContext(bgGc)); + CleanupStack::PushL(bgGc); + + CFbsBitmap* bitmap=new(ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + User::LeaveIfError(bitmap->Create(TSize(100,100),EColor16MU)); + for (TInt count = 1000; count > 0; count--) + { + if ((count % 31)==1) + { + bitmap->Reset(); + User::After(1); + User::LeaveIfError(bitmap->Create(TSize(100,100),EColor16MU)); + } + if ((count % 11)==1) + { + stressBitmaps.ResetAndDestroy(); + } + if ((count % 11)==5) + { + stressBitmaps.ResetAndDestroy(); + FillBitmapArray(stressBitmaps); + } + bgGc->DrawBitmap(TPoint(10,10),bitmap); + User::After(1); + } + + CleanupStack::PopAndDestroy(bitmap); + CleanupStack::PopAndDestroy(bgGc); + CleanupStack::PopAndDestroy(bgDevice); + CleanupStack::PopAndDestroy(outputBitmap); + CleanupStack::PopAndDestroy(/*&loadedBitmapCleanup*/); + CleanupStack::PopAndDestroy(/*&fbsConnectionCleanup*/); + } + +void TestBitmapUseL(CTFbsDefect* aFbsDefect) + { + TRAPD(err,DoBitmapUseL()); + aFbsDefect->TEST(err==KErrNone || err==KErrNoMemory); // Out-of-memory doesn't constitute a test failure + } + +/* Draws bitmaps */ +TInt BitmapUse(TAny* aAny) + { + CTrapCleanup* CleanUpStack=CTrapCleanup::New(); + CTFbsDefect* theTest = static_cast (aAny); + __UHEAP_MARK; + + TRAP_IGNORE(TestBitmapUseL(theTest)); + + __UHEAP_MARKEND; + delete CleanUpStack; + return KErrNone; + } + +/** + @SYMTestCaseID + GRAPHICS-FBSERV-0576 + + @SYMTestCaseDesc + Verifies defect DEF079124. + + @SYMDEF DEF079124 + + @SYMTestActions + Creates two threads. One threads keeps creating + and destroying large bitmaps. The second thread + draws bitmaps. The exit reason of the threads + are checked. The thread handles are closed. + + @SYMTestExpectedResults + Test should pass +*/ +void CTFbsDefect::TestFbservChunkLockingL() + { + INFO_PRINTF1(_L("TestDisplayModeL (DEF079124)")); + + __UHEAP_MARK; + TRequestStatus stat; + RThread bitmapCreate; + RThread bitmapUse; + bitmapCreate.Create(_L("BitmapCreate"),BitmapCreate,KDefaultStackSize,0x2200,0x2200,this); + bitmapUse.Create(_L("BitmapUse"),BitmapUse,KDefaultStackSize,0x2200,0x2200,this); + + bitmapUse.Logon(stat); + bitmapCreate.Resume(); + bitmapUse.Resume(); + User::WaitForRequest(stat); + + INFO_PRINTF2(_L("bitmapCreate ExitReason: %d"),bitmapCreate.ExitReason()); + INFO_PRINTF2(_L("bitmapUse ExitReason: %d"),bitmapUse.ExitReason()); + TEST(bitmapCreate.ExitReason() == KErrNone); + TEST(bitmapUse.ExitReason() == KErrNone); + bitmapCreate.Close(); + bitmapUse.Close(); + __UHEAP_MARKEND; + } + +/** + * @SYMTestCaseID GRAPHICS-FBSERV-0621 + * + * @SYMDEF INC112542, PDEF113158 + * + * @SYMTestCaseDesc A test to check KErrEof is returned when a bitmap index greater than the + * number of bitmaps present in the .mbm is requested from a ROM bitamp + * + * @SYMTestPriority Normal + * + * @SYMTestStatus Implemented + * + * @SYMTestActions Loads a bitmap from rom where the index is greater than the numer of bitmaps actually in the mbm + * Checks that KErrEof is returned when this happens. + * +*/ +void CTFbsDefect::TestKErrEof() + { + INFO_PRINTF1(_L("TestKErrEof - testing error code returned from CFbsBitmap::Load()")); + _LIT(KTestBitmapOnZZ,"z:\\system\\data\\tfbs.rbm"); // this contains 2 bitmaps + + + TUint32* romAddress = NULL; + if(!CFbsBitmap::IsFileInRom(KTestBitmapOnZZ, romAddress)) + { + INFO_PRINTF2(_L("Skipping test of ROM bitmaps since file \"%S\" is reported to not be a ROM bitmap."), + &KTestBitmapOnZZ); + INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported.")); + return; + } + + CFbsBitmap rom; + TInt bitmapIndex = 2; // this bmp index is one greater than the bitmap contains + TInt errCode = rom.Load(KTestBitmapOnZZ,bitmapIndex,EFalse); + + if(errCode!=KErrEof) + { + TEST(EFalse); + INFO_PRINTF2(_L("TestKErrEof - Accessing ROM bitmap index greater than # contained returned %d instead of KErrEof"),errCode); + } + } + +/* Creates bitmaps under OOM conditions (PDEF129780)*/ +void CTFbsDefect::CreateBitmapOOMTestL() + { + INFO_PRINTF1(_L("CreateBitmapOOMTestL (PDEF129780) - Creating Bitmap under OOM conditions")); + + RFbsSession* fbs = RFbsSession::GetSession(); + + RPointerArray bitmaps; + TCleanupItem bitmapsCleanupItem (CleanupLoadedBitmap, &bitmaps); + CleanupStack::PushL(bitmapsCleanupItem); + + // Loop here is to fill CFbTop::iBitmapObjectIndex and force it reallocate memory inside CBitmapObject::ConstructL + // The upper bound of the loop depends on how CFbTop::iBitmapObjectIndex is expended and how many pointers are in it by the start of this subtest + // The upper bound may require to be increased if previous subtests are changed + for(TInt i=0; i<500; i++) + { + TSize size(2,2); + + // Rate starts from 2 to allow allocate memory at least for new CBitmapObject and leave during next attempt to allocate memory + // The Loop is to make sure that the situation won't be missed if something in code is changed + // and it is more memory allocations before ConstructL. Currently it is enough 2. + for(TInt leaveRate = 2; leaveRate<10; leaveRate++) + { + CFbsBitmap* testBitmap = new(ELeave) CFbsBitmap; + + fbs->SendCommand(EFbsMessSetHeapFail, RFbsSession::EHeapFailTypeServerMemory, leaveRate); + + //Try to create bitmap + testBitmap->Create(size, EColor16MAP); + delete testBitmap; + } + + fbs->SendCommand(EFbsMessSetHeapReset, RFbsSession::EHeapFailTypeServerMemory, 0); + + // Create bitmap to fill FbTop::iBitmapObjectIndex + CFbsBitmap* bitmap = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + User::LeaveIfError(bitmaps.Append(bitmap)); + CleanupStack::Pop(bitmap); + User::LeaveIfError(bitmap->Create(size, EColor16MAP)); + } + INFO_PRINTF2(_L("Created %d bitmaps."), bitmaps.Count()); + CleanupStack::PopAndDestroy(&bitmaps); + // If it was no Panic in fbserv and we have got here test pass + } + + +void CTFbsDefect::RunTestCaseL(TInt aCurTestCase) + { + ((CTFbsDefectStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(aCurTestCase) + { + case 1: + ((CTFbsDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0574")); + CreateBitmapTestL(); + break; + case 2: + ((CTFbsDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0575")); + TestDisplayModeL(); + break; + case 3: + ((CTFbsDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0576")); + TestFbservChunkLockingL(); + break; + case 4: + ((CTFbsDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0621")); + TestKErrEof(); + break; + case 5: +/** + @SYMTestCaseID GRAPHICS-FBSERV-0620 +*/ + ((CTFbsDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0620")); + CreateBitmapOOMTestL(); + break; + case 6: + ((CTFbsDefectStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTFbsDefectStep*)iStep)->CloseTMSGraphicsStep(); + TestComplete(); + break; + } + ((CTFbsDefectStep*)iStep)->RecordTestResultL(); + } + +//-------------- +__CONSTRUCT_STEP__(FbsDefect)