--- /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;i<arraysize;i++)
+ {
+ ret=bitmap->Create(size,mode[i]);
+ INFO_PRINTF2(_L("Initial mode: %d\n"),mode[i]);
+ TEST(ret==KErrNone);
+ for (TInt j=i+1;j<arraysize;j++)
+ {
+ if ((mode[i]==EColor16MU && (mode[j]==EColor16MA || mode[j]==EColor16MAP)) || (mode[i]==EColor16MA && mode[j]==EColor16MAP))
+ {
+ //special cases where we can change from EColor16MU to either EColor16MA or EColor16MAP and from EColor16MA to EColor16MAP.
+ ret=bitmap->SetDisplayMode(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<RFbsSession*>(aPtr);
+ fbs->Disconnect();
+ }
+
+void CleanupLoadedBitmap(TAny* aPtr)
+ {
+ RPointerArray<CFbsBitmap>* ptrArray = (static_cast<RPointerArray<CFbsBitmap>*>(aPtr));
+ ptrArray->ResetAndDestroy();
+ ptrArray->Close();
+ }
+
+void FillBitmapArray(RPointerArray<CFbsBitmap>& 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<CFbsBitmap> 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 <CTFbsDefect*> (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<CFbsBitmap> 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)