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