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