// Copyright (c) 1997-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:

 //

 // Epoc includes

 #include "../inc/FBSMBMC.H"

 #include "../sfbs/UTILS.H"

 #include "TStreamIdCache.h"

 #include "fbsmessage.h"

 #include "fbsdefs.h"

 //Eikon has 78 bitmaps inside the mbm file(id 0-77)

 _LIT(KMbmFileEikon, "z:\\System\\Data\\tfbs_file4.mbm");

 _LIT(KMbmFileEikon2, "z:\\System\\Data\\tfbs_file4a.mbm");

 _LIT(KMbmFileEikon3, "z:\\System\\Data\\tfbs_file4b.mbm");

 _LIT(KMbmFileEikon4, "z:\\System\\Data\\tfbs_file4c.mbm");

 _LIT(KMbmFileEikon5, "z:\\System\\Data\\tfbs_file4d.mbm");

 //Lafcurs has 28 bitmaps inside the mbm file(id 0-27)

 _LIT(KMbmFileLafcurs, "z:\\System\\Data\\tfbs_file2.mbm");

 //Resource file containing mbm file

 _LIT(KMbmFileTFBSRSC, "z:\\System\\Data\\tfbs_rsc.rsc");

 _LIT(KRscFileHeader, "z:\\system\\data\\RscHeader3.bin");

 _LIT(KRscFileData, "z:\\system\\data\\DummyRscFile3.rsc");

 // File with two 1x1 px mbm files: first is black, second is white. white mbm at 72 bytes into file

 #define WHITE_OFFSET 72

 _LIT(KBlackAndWhite, "z:\\system\\data\\blackandwhite.mbm");

 // ============================================================================

 //Default Constructor

 CTStreamIdCache::CTStreamIdCache(CTestStep* aStep):

 	CTGraphicsBase(aStep),

 	iFbs(NULL)

 	{

 	}

 CTStreamIdCache::~CTStreamIdCache()

 	{

 	if(iShutdownFbs)

 		RFbsSession::GetSession()->SendCommand(EFbsMessShutdown);

 	RFbsSession::Disconnect();

 	iFs.Close();

 	}

 void CTStreamIdCache::ConstructL()

 	{

 	if(RFbsSession::Connect()==KErrNone)

 		{

 		iShutdownFbs = EFalse;

 		}

 	else

 		{

 		FbsStartup();

 		RFbsSession::Connect();

 		iShutdownFbs = ETrue;

 		}

 	iFs.Connect();

 	iFbs = RFbsSession::GetSession();

 	iSessionHandle = iFbs->SessionHandle();

 	ExpandCleanupStackL();

 	INFO_PRINTF1(_L("FBS Bitmap StreamId cache testing"));

 	}

 void CTStreamIdCache::RunTestCaseL(TInt aCurTestCase)

 	{

 	((CTStreamIdCacheStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

 	switch(aCurTestCase)

 		{

 	case 1:

 		((CTStreamIdCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0577"));

 		TestStreamIdCacheEntry();

 		break;

 	case 2:

 		((CTStreamIdCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0578"));

 		TestProcessingBitmapStream();

 		break;

 	case 3:

 		((CTStreamIdCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0580"));

 		TestReplacingFile();

 		break;

 	case 4:

 		((CTStreamIdCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0579"));

 		TestComparingStreams();

 		break;

 	case 5:

 		((CTStreamIdCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0581"));

 		TestInvalidArgument();

 		break;

 	case 6:

 		((CTStreamIdCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0582"));

 		TestOOMCondition();

 		break;

 	case 7:

 		((CTStreamIdCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0583"));

 		TestPerformance();

 		break;

 	case 8:

 		((CTStreamIdCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0584"));

 		TestLoadAtOffset();

 		break;

 	case 9:

 		((CTStreamIdCacheStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0509"));

 		TestSessionClose();

 		break;

 	case 10:

 		((CTStreamIdCacheStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

 		((CTStreamIdCacheStep*)iStep)->CloseTMSGraphicsStep();

 		TestComplete();

 		break;

 		}

 	((CTStreamIdCacheStep*)iStep)->RecordTestResultL();

 	}

 //This function is here to measure the offset in the rsc file

 TInt CTStreamIdCache::FileSizeL(const TDesC& aFileName)

 	{

 	RFile file;

 	User::LeaveIfError(file.Open(iFs, aFileName, EFileRead));

 	CleanupClosePushL(file);

 	TInt size = 0;

 	User::LeaveIfError(file.Size(size));

 	CleanupStack::PopAndDestroy(&file);

 	return size;

 	}

 void CTStreamIdCache::ExpandCleanupStackL()

 	{

 	TInt count=0;

 	for(;count<10;count++)

 		CleanupStack::PushL((TUint32*)0x1);

 	CleanupStack::Pop(count);

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0577

 	@SYMTestCaseDesc

 	Tests the API functionality of the class  ensuring 

 	the internal states are correct during the construction 

 	and other operation.

 	@SYMTestActions

 	Tests the API on a defaultly built element object.

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTStreamIdCache::TestStreamIdCacheEntry()

 	{

 	INFO_PRINTF1(_L("Test of CFbTopStreamIdCache API"));

 	// Test the API on a defaultly built element object

 		CFbTopStreamIdCache* mbmcache=new CFbTopStreamIdCache(20,30,1);

 		TEST(mbmcache->iEntries.Count() == 0);

 		TEST(mbmcache->iMaxCacheFilestores == 1);

 		TEST(mbmcache->iBackwardCacheSize ==30);

 		TEST(mbmcache->iForwardCacheSize ==20);

 		delete mbmcache;

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0578

 	@SYMTestCaseDesc

 	Tests the loading of a bitmap from an mbm file using 

 	the cache and the content of the cache after the loading 

 	i.e. how many stream ids are stored, the last bitmap file 

 	name, the last id, the cache forward and backward size.

 	@SYMTestActions

 	Tests the GetStreamIdL method. Loads eikon.mbm with 78

 	bitmap files. Tests loading some rsc file which contains offset.

 	Tests the flushing.

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTStreamIdCache::TestProcessingBitmapStream()

 	{

 	TInt ret;

 	INFO_PRINTF1(_L("Test loading a bitmap file and processing the stream id"));

 	//Testing the GetStreamIdL method

 	CFbTopStreamIdCache* mbmcacheptr = new CFbTopStreamIdCache(30,30,1);

 	CFbTopStreamIdCache& mbmcache = *mbmcacheptr;

 	INFO_PRINTF1(_L("Loading eikon.mbm with 78 bitmap files"));

 	//Loading eikon.mbm with 78 bitmap files

 	RFile file;

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,mbmcache.GetStreamIdL(file,KMbmFileEikon,50,0,iSessionHandle));

 	TEST(ret==KErrNone);

 	//the cache only stores 30 ids before 50 + max of 30 after(including 50)

 	//but in this case the bitmap only has 78 bitmaps so it only stores 28 after

 	TEST(mbmcache.iEntries.Count() == 1);

 	TEST(mbmcache.iEntries[0]->iStreamIdCount==58);

 	TEST(mbmcache.iEntries[0]->iLastId==50);

 	TEST(mbmcache.iForwardCacheSize==30);

 	TEST(mbmcache.iBackwardCacheSize==30);

 	TEST(mbmcache.iEntries[0]->iFilename.CompareF(KMbmFileEikon)==0);

 	TEST(mbmcache.iEntries[0]->iFilestore!=NULL);

 	//Test loading some rsc file which contains offset

 	TInt mbm_offset = FileSizeL(KRscFileHeader) + FileSizeL(KRscFileData);

 	ret=file.Open(iFs,KMbmFileTFBSRSC,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,mbmcache.GetStreamIdL(file,KMbmFileTFBSRSC,0,mbm_offset,iSessionHandle));

 	TEST(ret==KErrNone);

 	TEST(mbmcache.iEntries.Count() == 1);

 	TEST(mbmcache.iEntries[0]->iLastId==0);

 	TEST(mbmcache.iEntries[0]->iStreamIdCount==2);

 	TEST(mbmcache.iEntries[0]->iFilename.CompareF(KMbmFileTFBSRSC)==0);

 	// Test the flushing

 	mbmcache.FlushCache();

 	TEST(mbmcache.iEntries.Count() == 0);

 	TEST(mbmcache.iMaxCacheFilestores == 1);

 	TEST(mbmcache.iBackwardCacheSize == 30);

 	TEST(mbmcache.iForwardCacheSize == 30);

 	delete mbmcacheptr;

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0579

 	@SYMTestCaseDesc

 	Tests the correct functionality of the cache storing the stream ids. 

 	Three different caches are used to load the same mbm file but the 

 	bitmap id to be loaded are different however the bitmap ids are chosen in 

 	such a way that these three caches will store some common bitmap id. 

 	We then accessed the cache content and check that these three caches 

 	will give the same stream id values for that common bitmap id.

 	@SYMTestActions

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTStreamIdCache::TestComparingStreams()

 	{

 	TInt ret;

 	INFO_PRINTF1(_L("Test comparing the stream ids from three different caches"));

 	CFbTopStreamIdCache* cache1=new CFbTopStreamIdCache(30,30,1);

 	CFbTopStreamIdCache* cache2=new CFbTopStreamIdCache(10,30,1);

 	CFbTopStreamIdCache* cache3=new CFbTopStreamIdCache(25,5,1);

 	//CACHE1 Loading this will fill up the streams with ids from 0-55

 	RFile file;

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache1->GetStreamIdL(file,KMbmFileEikon,25,0,iSessionHandle));

 	TEST(ret==KErrNone);

 	TEST(cache1->iEntries.Count() == 1);

 	TEST(cache1->iEntries[0]->iStreamIdCount==55);

 	TEST(cache1->iEntries[0]->iLastId==25);

 	//now storing the actual TStreamId for bitmap id 26 for future comparison

 	//stream id for bitmapid=26 will be @ the 26th position inside the array

 	TStreamId id25_26=cache1->iEntries[0]->iStreamIdCache[26];

 	delete cache1;	

 	//CACHE2 Loading this will fill up the streams with ids from 36-65

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache2->GetStreamIdL(file,KMbmFileEikon,56,0,iSessionHandle));

 	TEST(ret==KErrNone);

 	TEST(cache2->iEntries.Count() == 1);

 	TEST(cache2->iEntries[0]->iStreamIdCount==40);

 	TEST(cache2->iEntries[0]->iLastId==56);

 	//stream id for bitmapid=26 will be @ the 0th position inside the array

 	TStreamId id56_26=cache2->iEntries[0]->iStreamIdCache[0];

 	TEST(id25_26.Value()==id56_26.Value());

 	delete cache2;

 	//CACHE3 Loading this will fill up the streams with ids from 1-30

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache3->GetStreamIdL(file,KMbmFileEikon,6,0,iSessionHandle));

 	TEST(ret==KErrNone);

 	TEST(cache3->iEntries.Count() == 1);

 	TEST(cache3->iEntries[0]->iStreamIdCount==30);

 	TEST(cache3->iEntries[0]->iLastId==6);

 	TStreamId id6_26=cache3->iEntries[0]->iStreamIdCache[25];

 	TEST(id25_26.Value()==id6_26.Value());

 	delete cache3;

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0580

 	@SYMTestCaseDesc

 	Tests the functionality of the cache when it has already

 	stored some existing bitmap ids The cache is loaded with a 

 	different mbm file and the cache content is examined to make 

 	sure it has the correct new data.

 	@SYMTestActions

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTStreamIdCache::TestReplacingFile()

 	{

 	TInt ret;

 	INFO_PRINTF1(_L("Test loading a file different from previous stored in cache"));

 	CFbTopStreamIdCache* cache1ptr = new CFbTopStreamIdCache(30,30,1);

 	CFbTopStreamIdCache& cache1 = *cache1ptr;

 	RFile file;

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache1.GetStreamIdL(file,KMbmFileEikon,25,0,iSessionHandle));

 	TEST(ret==KErrNone);

 	TEST(cache1.iEntries.Count() == 1);

 	TEST(cache1.iEntries[0]->iStreamIdCount==55);

 	TEST(cache1.iEntries[0]->iLastId==25);

 	TEST(cache1.iEntries[0]->iFilename.Compare(KMbmFileEikon)==0);

 	//Now trying to load an entirely different bitmap file

 	//and check to ensure the cache has reflushed itself

 	//and load itself with new stuff

 	ret=file.Open(iFs,KMbmFileLafcurs,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache1.GetStreamIdL(file,KMbmFileLafcurs,12,0,iSessionHandle));

 	TEST(ret==KErrNone);

 	TEST(cache1.iEntries.Count() == 1);

 	TEST(cache1.iEntries[0]->iStreamIdCount==28);

 	TEST(cache1.iEntries[0]->iLastId==12);

 	TEST(cache1.iEntries[0]->iFilename.Compare(KMbmFileLafcurs)==0);

 	delete cache1ptr;

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0581

 	@SYMTestCaseDesc

 	Tests the error values that would be returned by

 	the cache when supplied with invalid arguments such 

 	as bad file name  negative bitmap ids, out of range 

 	bitmap ids, and invalid file offset.

 	@SYMDEF INC047122 INC046632

 	@SYMTestActions

 	Creates an FbTopStreamIdCache object. Tests to ensure the cache 

 	can deal with non error cases immediately after error cases.

 	Passing an in bound bitmap id. Passing an out of bound bitmap id.

 	Passing an in bound bitmap id. Passing an out of bound bitmap id.

 	Passing an in bound bitmap id. Passing negative bitmap id.

 	Passing an invalid file name. Passing an invalid file offset.

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTStreamIdCache::TestInvalidArgument()

 	{

 	TInt ret;

 	INFO_PRINTF1(_L("Test loading a file bitmap with invalid argument"));

 	CFbTopStreamIdCache* cache1ptr = new CFbTopStreamIdCache(30,30,1);

 	CFbTopStreamIdCache& cache1 = *cache1ptr;

 	//Eikon mbm only can accept ids from 0-77

 	//The following sequence of 4 tests ensures the cache can deal with

 	//non error cases immediately after error cases.

 	//Passing an in bound bitmap id

 	RFile file;

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache1.GetStreamIdL(file,KMbmFileEikon,0,0,iSessionHandle));

 	TEST(ret==KErrNone);

 	//Passing an out of bound bitmap id

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache1.GetStreamIdL(file,KMbmFileEikon,78,0,iSessionHandle));

 	TEST(ret==KErrEof);

 	//Passing an in bound bitmap id

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache1.GetStreamIdL(file,KMbmFileEikon,74,0,iSessionHandle));

 	TEST(ret==KErrNone);

 	//Passing an out of bound bitmap id

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache1.GetStreamIdL(file,KMbmFileEikon,78,0,iSessionHandle));

 	TEST(ret==KErrEof);

 	//Passing an in bound bitmap id

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache1.GetStreamIdL(file,KMbmFileEikon,77,0,iSessionHandle));

    	TEST(ret==KErrNone);

 	//Passing negative bitmap id

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache1.GetStreamIdL(file,KMbmFileEikon,-1,0,iSessionHandle));

 	TEST(ret==KErrEof);

 	//Passing an invalid file name

 	ret=file.Open(iFs,_L("invalid.mbm"),EFileShareReadersOnly);

 	cache1.FlushCache();

 	TEST((ret==KErrNotFound)||(ret==KErrPathNotFound));

 	//Passing an invalid file offset

 	ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	TRAP(ret,cache1.GetStreamIdL(file,KMbmFileEikon,12,10,iSessionHandle));

 	TEST(ret==KErrNotSupported);

 	//Tests for INC047122 and INC046632

 	TInt err(KErrNone);

 	TInt id(0);

 	for (; id<100; id++)

 		{

 		err=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 		TEST(err==KErrNone);

 		TRAP(err,cache1.GetStreamIdL(file,KMbmFileEikon,id,0,iSessionHandle));

 		if(err != KErrNone)

 			break;

 		}

 	TEST(id==78);

 	INFO_PRINTF2(_L("Starting from 0 the number of bitmaps in KMbmFileEikon is calculated to be %d\n\n"), id);

 	delete cache1ptr;

 	// New cache, start from Id 50

 	CFbTopStreamIdCache* cache2ptr = new CFbTopStreamIdCache(30,30,1);

 	CFbTopStreamIdCache& cache2 = *cache2ptr;

 	for (id=50,	err=KErrNone; id<100; id++)

 		{

 		err=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 		TEST(err==KErrNone);

 		TRAP(err,cache2.GetStreamIdL(file,KMbmFileEikon,id,0,iSessionHandle));

 		if(err != KErrNone)

 			break;

 		}

 	TEST(id==78);

 	INFO_PRINTF2(_L("Starting from 50 the number of bitmaps in KMbmFileEikon is calculated to be %d\n\n"), id);

 	delete cache2ptr;

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0582

 	@SYMTestCaseDesc

 	Tests the out of memory condition during memory 

 	allocation inside the test function GetStreamIdL

 	to ensure that there is no memory leaks.

 	@SYMTestActions

 	Tests the cache by opening a file and calls GetStreamIdL

 	and checks the heap for memory leaks. Tests the cache

 	for a cache hit. Test the cache for a cache miss.

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTStreamIdCache::TestOOMCondition()

 	{

 	INFO_PRINTF1(_L("Test of CFbTopStreamIdCache OOM"));

 	// Test a cache for the first time

 	for (TInt count = 1; ; count++)

         {

         __UHEAP_MARK;

 		CFbTopStreamIdCache* cache=new CFbTopStreamIdCache(30,30,1);

 		__UHEAP_SETFAIL(RHeap::EDeterministic,count);

 		RFile file;

 		TInt ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 		TEST(ret==KErrNone);

 		TRAP(ret,cache->GetStreamIdL(file,KMbmFileEikon,30,0,iSessionHandle));

 		__UHEAP_RESET;

 	    delete cache;

 	    __UHEAP_MARKEND;

 		if (ret==KErrNone)

 			break;

 		TEST(ret==KErrNoMemory);

 		}

 	// Test a cache hit

 	for (TInt count = 1; ; count++)

         {

         __UHEAP_MARK;

 		CFbTopStreamIdCache* cache=new CFbTopStreamIdCache(30,30,1);

 		RFile file1;

 		TInt ret=file1.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 		TEST(ret==KErrNone);

 		TRAP(ret,cache->GetStreamIdL(file1,KMbmFileEikon,30,0,iSessionHandle));

 		TEST(ret==KErrNone);		

 		__UHEAP_SETFAIL(RHeap::EDeterministic,count);

 		RFile file;

 		ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 		TEST(ret==KErrNone);

 		TRAP(ret,cache->GetStreamIdL(file,KMbmFileEikon,30,0,iSessionHandle));

 		__UHEAP_RESET;

 	    delete cache;

 	   	__UHEAP_MARKEND;

 		if (ret==KErrNone)

 			break;

 		TEST(ret==KErrNoMemory);

 		}

 	// Test a cache miss

 	for (TInt count = 1; ; count++)

         {

         __UHEAP_MARK;

 		CFbTopStreamIdCache* cache=new CFbTopStreamIdCache(30,30,1);

 		RFile file1;

 		TInt ret=file1.Open(iFs,KMbmFileLafcurs,EFileShareReadersOnly);

 		TEST(ret==KErrNone);

 		TRAP(ret,cache->GetStreamIdL(file1,KMbmFileLafcurs,0,0,iSessionHandle));

 		TEST(ret==KErrNone);		

 		__UHEAP_SETFAIL(RHeap::EDeterministic,count);

 		RFile file;

 		ret=file.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 		TEST(ret==KErrNone);

 		TRAP(ret,cache->GetStreamIdL(file,KMbmFileEikon,30,0,iSessionHandle));

 		__UHEAP_RESET;

 	    delete cache;

 	   	__UHEAP_MARKEND;

 		if (ret==KErrNone)

 			{

 			__UHEAP_SETFAIL(RHeap::ENone,count);

 			break;

 			}

 		TEST(ret==KErrNoMemory);

 		}

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0583

 	@SYMTestCaseDesc

 	This test is used to measure the performance improvement 

 	when the font bitmap server is using a cache to store the 

 	stream ids.

 	@SYMTestActions

 	Starts the timing. Gets the current time. Creates a FbsBitmap

 	on the heap. Simulates loading during boot time by loading

 	bitmaps from ROM. Does forward testing before optimised duration.

 	Retreives the current time and calculates the time taken by the tests.

 	Does forward testing after optimised duration. Does backward testing

 	before optimised duration. Does backward testing after optimised duration.

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTStreamIdCache::TestPerformance()

 	{

 	//Start the timing

 	TTime starttime;

 	starttime.UniversalTime();

 	CFbsBitmap* bitmap=new (ELeave) CFbsBitmap;

 	TInt ret;

 	//simulating loading during boottime

 	TInt i,j;

 	for (i=0;i<30;i++)

 		{

 		for (j=0;j<10;j++)

 			{

 			ret=bitmap->Load(KMbmFileEikon,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=0;j<2;j++)

 			{

 			ret=bitmap->Load(_L("z:\\system\\data\\tfbs.mbm"),j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=0;j<28;j++)

 			{

 			ret=bitmap->Load(KMbmFileLafcurs,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=71;j<73;j++)

 			{

 			ret=bitmap->Load(KMbmFileEikon,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=0;j<2;j++)

 			{

 			ret=bitmap->Load(_L("z:\\system\\data\\tfbs.mbm"),j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=20;j<22;j++)

 			{

 			ret=bitmap->Load(KMbmFileLafcurs,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		}

 	TTime endtime;

 	endtime.UniversalTime();

 	INFO_PRINTF1(_L("Forward Testing Before optimised duration= 3515625 microseconds \n"));

 	TTimeIntervalMicroSeconds difftime=endtime.MicroSecondsFrom(starttime);

 	INFO_PRINTF2(_L("Forward Testing After optimised duration=%Ld  microseconds\n\n"),difftime.Int64());

 	starttime.UniversalTime();

 	for (i=0;i<30;i++)

 		{

 		for (j=10;j>=0;j--)

 			{

 			ret=bitmap->Load(KMbmFileEikon,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=1;j>=0;j--)

 			{

 			ret=bitmap->Load(_L("z:\\system\\data\\tfbs.mbm"),j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=27;j>=0;j--)

 			{

 			ret=bitmap->Load(KMbmFileLafcurs,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=73;j>=72;j--)

 			{

 			ret=bitmap->Load(KMbmFileEikon,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=1;j>=0;j--)

 			{

 			ret=bitmap->Load(_L("z:\\system\\data\\tfbs.mbm"),j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=22;j>=20;j--)

 			{

 			ret=bitmap->Load(KMbmFileLafcurs,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		}	

 	endtime.UniversalTime();

 	difftime=endtime.MicroSecondsFrom(starttime);

 	INFO_PRINTF1(_L("Backward Testing Before optimised duration= 3515625 microseconds \n"));

 	INFO_PRINTF2(_L("Backward Testing After optimised duration=%Ld  microseconds\n\n"),difftime.Int64());

 	starttime.UniversalTime();

 	for (i=0;i<30;i++)

 		{

 		for (j=40;j<70;j++)

 			{

 			ret=bitmap->Load(KMbmFileEikon,j,EFalse);

 			TEST(ret==KErrNone);

 			ret=bitmap->Load(KMbmFileEikon2,j,EFalse);

 			TEST(ret==KErrNone);

 			ret=bitmap->Load(KMbmFileEikon3,j,EFalse);

 			TEST(ret==KErrNone);

 			ret=bitmap->Load(KMbmFileEikon4,j,EFalse);

 			TEST(ret==KErrNone);

 			ret=bitmap->Load(KMbmFileEikon5,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		}

 	endtime.UniversalTime();

 	difftime=endtime.MicroSecondsFrom(starttime);

 	INFO_PRINTF1(_L("Multiple File Testing Before optimised duration= ? microseconds \n"));

 	INFO_PRINTF2(_L("Multiple File Testing After optimised duration=%Ld  microseconds\n\n"),difftime.Int64());

 	starttime.UniversalTime();

 	for (i=0;i<30;i++)

 		{

 		for (j=0;j<30;j++)

 			{

 			ret=bitmap->Load(KMbmFileEikon,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		for (j=40;j<70;j++)

 			{

 			ret=bitmap->Load(KMbmFileEikon,j,EFalse);

 			TEST(ret==KErrNone);

 			}

 		}

 	endtime.UniversalTime();

 	difftime=endtime.MicroSecondsFrom(starttime);

 	INFO_PRINTF1(_L("Single File Testing Before optimised duration= ? microseconds \n"));

 	INFO_PRINTF2(_L("Single File Testing After optimised duration=%Ld  microseconds\n\n"),difftime.Int64());

 	bitmap->Reset();

 	delete bitmap;

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-0584

 	@SYMTestCaseDesc

 	Tests loading of bitmaps at an offset

 	(Bitmap file section offset within the file).

 	@SYMTestActions

 	Creates an FbsBitmap object on the heap. Loads

 	a monochrone bitmap with zero offset. Checks if

 	loading completed successfully. Checks the pixel

 	size. Gets a pixel. Checks if pixel is KRgbBlack. 

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTStreamIdCache::TestLoadAtOffset()

 	{

 	CFbsBitmap* bitmap = NULL;

 	TRAPD(ret, bitmap = new (ELeave) CFbsBitmap);

 	TEST(ret==KErrNone);

 	if(iStep->TestStepResult() != EPass)

 		{

 		return;

 		}

 	INFO_PRINTF1(_L("Testing repeated CFbsBitmap Load with different offsets"));

 	do // use a do{}while(false) so we can break out of the test code and fall back to the cleanup code

 		{

 		ret = bitmap->Load(KBlackAndWhite, 0, EFalse, 0);

 		TEST(ret==KErrNone);

 		if(iStep->TestStepResult() != EPass)

 			{

 			INFO_PRINTF1(_L("TestLoadAtOffset: Failed to load first mbm"));

 			break;

 			}

 		TEST( bitmap->SizeInPixels() == TSize(1,1) && bitmap->IsMonochrome() );

 		if(iStep->TestStepResult() == EPass)

 			{

 			TRgb colour;

 			bitmap->GetPixel(colour, TPoint(0,0));

 			TEST( colour == KRgbBlack );

 			}

 		if(iStep->TestStepResult() != EPass)

 			{

 			INFO_PRINTF1(_L("TestLoadAtOffset: First mbm loaded incorrectly"));

 			break;

 			}

 		ret = bitmap->Load(KBlackAndWhite, 0, EFalse, WHITE_OFFSET);

 		TEST(ret==KErrNone);

 		if(iStep->TestStepResult() != EPass)

 			{

 			INFO_PRINTF1(_L("TestLoadAtOffset: Failed to load second mbm"));

 			break;

 			}

 		TEST( bitmap->SizeInPixels() == TSize(1,1) && bitmap->IsMonochrome() );

 		if(iStep->TestStepResult() == EPass)

 			{

 			TRgb colour;

 			bitmap->GetPixel(colour, TPoint(0,0));

 			TEST( colour == KRgbWhite );

 			}

 		if(iStep->TestStepResult() != EPass)

 			{

 			INFO_PRINTF1(_L("TestLoadAtOffset: Second mbm loaded incorrectly"));

 			break;

 			}

 		} while( EFalse );

 	bitmap->Reset();

 	delete bitmap;

 	}

 /**

 @SYMTestCaseID			GRAPHICS-FBSERV-0509

 @SYMDEF					DEF104261

 @SYMTestCaseDesc		Tests file store cleanup for corresponding fbs session

 @SYMTestPriority		Medium

 @SYMTestStatus			Implemented

 @SYMTestActions			1. Create a file store object from file stream cache using current session handle

 						2. Create new file store object using some dummy session handle

 						3. Check two file store object belongs to the corresponding dummy session handle.

 						4. Close file store and check 

 								- if corresponing session's handle file store used to close.

 								- if we send wrong session handle none of the file store should close

 								- if we haven't send any session handle close all the file store object irrespective of the session handle

 @SYMTestExpectedResults	1. File store should close only for the corresponding session, while disconnecting the session

 						2. By flushing cache should close all file stores and reset cache entries, irrespective of the session

 */

 void CTStreamIdCache::TestSessionClose()

 	{

 	TInt ret;

 	INFO_PRINTF1(_L("Test file store clean up"));

 	CFbTopStreamIdCache* mbmcacheptr = new CFbTopStreamIdCache(30,30,2);

 	CFbTopStreamIdCache& mbmcache = *mbmcacheptr;

 	RFile file1;

 	ret=file1.Open(iFs,KMbmFileEikon,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	RFile file2;

 	ret=file2.Open(iFs,KMbmFileLafcurs,EFileShareReadersOnly);

 	TEST(ret==KErrNone);

 	//Create a file store with dummy session handle 1

 	TRAP(ret,mbmcache.GetStreamIdL(file1,KMbmFileEikon,50,0,1));

 	TEST(ret==KErrNone);

 	//Create a file store with dummy session handle 2

 	TRAP(ret,mbmcache.GetStreamIdL(file2,KMbmFileLafcurs,12,0,2));

 	TEST(ret==KErrNone);

 	TEST(mbmcache.iEntries.Count() == 2);

 	TEST(2==mbmcache.iEntries[0]->SessionHandle());

 	TEST(1==mbmcache.iEntries[1]->SessionHandle());

 	TEST(mbmcache.iEntries[0]->iFilestore!=NULL);

 	TEST(mbmcache.iEntries[1]->iFilestore!=NULL);

 	mbmcache.CloseFileStores(1);

 	TEST(mbmcache.iEntries.Count() == 2);

 	TEST(mbmcache.iEntries[0]->iFilestore!=NULL);

 	TEST(mbmcache.iEntries[1]->iFilestore==NULL);

 	TEST(2==mbmcache.iEntries[0]->SessionHandle());

 	TEST(0==mbmcache.iEntries[1]->SessionHandle());

 	//All File stores should deleted

 	mbmcache.CloseFileStores(0);

 	TEST(mbmcache.iEntries.Count() == 2);

 	TEST(mbmcache.iEntries[0]->iFilestore==NULL);

 	TEST(mbmcache.iEntries[1]->iFilestore==NULL);

 	TEST(0==mbmcache.iEntries[0]->SessionHandle());

 	TEST(0==mbmcache.iEntries[1]->SessionHandle());

 	// Should remove all the file store objects and reset the cache entries.

 	mbmcache.FlushCache();

 	TEST(mbmcache.iEntries.Count() == 0);

 	delete mbmcacheptr;

 	}

 //--------------

 __CONSTRUCT_STEP__(StreamIdCache)

 void CTStreamIdCacheStep::TestSetupL()

 	{

 	// Leaking thread handles

 	iThread.HandleCount(iStartProcessHandleCount, iStartThreadHandleCount);

 	}

 void CTStreamIdCacheStep::TestClose()

 	{

 	// Check for open handles

 	iThread.HandleCount(iEndProcessHandleCount, iEndThreadHandleCount);

 	if(iStartThreadHandleCount != iEndThreadHandleCount)

 		{__DEBUGGER()}							// Oops leaked some handles

 	}