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