// Copyright (c) 2005-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 <f32file.h>

#include <fbs.h>

#include <bitdev.h>

#include <bitstd.h>

#include <graphics/gdi/gdiconsts.h>

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

#include "trfile.h"

#include "fbsmessage.h"

#include "fbsdefs.h"

// Define FBSTEST_SCREENSHOT to save the screen to a .mbm file

//#define FBSTEST_SCREENSHOT

const TInt KNumBitmap = 3;

const TDisplayMode KDisplayMode = EColor64K;

const TSize KLargeSize(128,128);

const TSize KMidSize(64,64);

const TSize KSmallSize(32,32);

_LIT(KRamFile1,"c:\\rf1.mbm");

_LIT(KRamFile2,"c:\\rf2.mbm");

_LIT(KRamFile3,"c:\\rf3.mbm");

_LIT(KRamFile4,"c:\\rf123.mbm");

_LIT(KRomFile1,"z:\\system\\data\\rf1.mbm");

_LIT(KRomFile2,"z:\\system\\data\\rf2.mbm");

_LIT(KRomFile3,"z:\\system\\data\\rf3.mbm");

_LIT(KRomFile4,"z:\\system\\data\\rf123.mbm");

CTFile::CTFile(CTestStep* aStep):

	CTGraphicsBase(aStep),

	iFbs(NULL),

	iSource(KNumBitmap)

	{

	}

CTFile::~CTFile()

	{

	CleanUp();

	if (iShutdownFbs)

		iFbs->SendCommand(EFbsMessShutdown);

	iFbs->Disconnect();

	}

void CTFile::ConstructL()

	{

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

		{

		RFbsSession::Disconnect();

		iShutdownFbs = EFalse;

		}

	else

		{

		FbsStartup();

		iShutdownFbs = ETrue;

		}

	TInt ret = RFbsSession::Connect();

	TEST(ret==KErrNone);

	iFbs = RFbsSession::GetSession();

	TEST(iFbs != NULL);

	ret = iFs.Connect();

	TEST(ret==KErrNone);

	// required to allow file handle to be adopted by another process

	iFs.ShareProtected();

	TUint32* romAddress = NULL;

	if(!CFbsBitmap::IsFileInRom(KRomFile1, romAddress)) //any ROM bitmap

		{

		INFO_PRINTF2(_L("Skipping ROM bitmap tests since file \"%S\" is reported to not be a ROM bitmap."),

				&KRomFile1);

		INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported."));

		iSkipRomBitmapTests = ETrue;

		}

	}

void CTFile::CleanUp()

	{

	const TBufC<32> names[KNumBitmap] =

		{

		(const TDesC&)KRamFile1,

		(const TDesC&)KRamFile2,

		(const TDesC&)KRamFile3

		};

	TInt i;

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

		{

		delete iSource[i];

		iFs.Delete(names[i]);

		}

	iSource.Close();

	iFs.Delete(KRamFile4);

	iFs.Close();	

	}

void CTFile::RunTestCaseL(TInt aCurTestCase)

	{

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

	switch(aCurTestCase)

		{

	case 1:

		((CTFileStep*)iStep)->SetTestStepID(_L("	GRAPHICS-FBSERV-0588"));

		CreateL();

		break;

	case 2:

		((CTFileStep*)iStep)->SetTestStepID(_L("	GRAPHICS-FBSERV-0589"));

		SaveL();

		break;

	case 3:

		((CTFileStep*)iStep)->SetTestStepID(_L("	GRAPHICS-FBSERV-0590"));

		StoreL();

		break;

	case 4:

		((CTFileStep*)iStep)->SetTestStepID(_L("	GRAPHICS-FBSERV-0591"));

		LoadL();

		break;

	case 5:

		((CTFileStep*)iStep)->SetTestStepID(_L("	GRAPHICS-FBSERV-0592"));

		LoadAndCompressL();

		break;

	case 6:

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

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

		TestComplete();

		break;

		}

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

	}

/**

	Draw union jack

*/

void CTFile::Draw(CFbsBitGc* aGc, const TSize& aSize)

	{

	const TSize thick(aSize.iWidth/4,aSize.iWidth/4);

	const TSize thin(thick.iWidth/2,thick.iWidth/2);

	// background

	aGc->SetBrushColor(KRgbBlue);

	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc->SetPenStyle(CGraphicsContext::ESolidPen);

	aGc->DrawRect(aSize);

	// corner to corner section

	aGc->SetPenColor(KRgbWhite);

	aGc->SetPenSize(thick);

	aGc->DrawLine(TPoint(0,0),TPoint(aSize.iWidth,aSize.iHeight));

	aGc->DrawLine(TPoint(aSize.iWidth,0),TPoint(0,aSize.iHeight));	

	aGc->SetPenColor(KRgbRed);

	aGc->SetPenSize(thin);

	aGc->DrawLine(TPoint(0,0),TPoint(aSize.iWidth,aSize.iHeight));

	aGc->DrawLine(TPoint(aSize.iWidth,0),TPoint(0,aSize.iHeight));	

	// cross section

	aGc->SetPenColor(KRgbWhite);

	aGc->SetPenSize(thick);

	aGc->DrawLine(TPoint(aSize.iWidth/2,0),TPoint(aSize.iWidth/2,aSize.iHeight));	

	aGc->DrawLine(TPoint(0,aSize.iHeight/2),TPoint(aSize.iWidth,aSize.iHeight/2));	

	aGc->SetPenColor(KRgbRed);

	aGc->SetPenSize(thin);

	aGc->DrawLine(TPoint(aSize.iWidth/2,0),TPoint(aSize.iWidth/2,aSize.iHeight));	

	aGc->DrawLine(TPoint(0,aSize.iHeight/2),TPoint(aSize.iWidth,aSize.iHeight/2));	

	}

/**

*/	

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0588

	@SYMTestCaseDesc

	Create various size bitmap for testing (original bitmaps) 

	ie small (<4KB), mid (=4KB) and large (>4KB).

	@SYMTestActions	

	@SYMTestExpectedResults

	Test should pass

*/

void CTFile::CreateL()

	{

	const TSize sizes[KNumBitmap] = 

		{

		KSmallSize,

		KMidSize,

		KLargeSize

		};

	TInt i;

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

		{

		CFbsBitmap* bmp = new(ELeave) CFbsBitmap;

		CleanupStack::PushL(bmp);

		User::LeaveIfError(bmp->Create(sizes[i],KDisplayMode));

		CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(bmp);

		CleanupStack::PushL(dev);

		CFbsBitGc* gc;

		User::LeaveIfError(dev->CreateContext(gc));

		Draw(gc,sizes[i]);

		delete gc;

		CleanupStack::PopAndDestroy(dev);

		iSource.AppendL(bmp);

		CleanupStack::Pop(bmp);

		}

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0589

	@SYMTestCaseDesc

	Save single bitmap to file using an opened file handle

	@SYMTestActions

	Save original bitmap to file using file handle (saved bitmap)

	Load saved bitmap using file name and compare against original

	Leave saved bitmap files for next test (Load,LoadAndCompress)

	@SYMTestExpectedResults

	Saved bitmap match original bitmap

*/

void CTFile::SaveL()

	{

	const TBufC<32> names[KNumBitmap] =

		{

		(const TDesC&)KRamFile1,

		(const TDesC&)KRamFile2,

		(const TDesC&)KRamFile3

		};

	INFO_PRINTF1(_L("Saving bitmap"));		

	TInt i;

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

		{

		RFile f;

		TInt mode = EFileWrite;

		TInt ret = f.Open(iFs,names[i],mode);

		if (ret==KErrNotFound)

			ret = f.Create(iFs,names[i],mode);

		TEST(ret==KErrNone);

		TEST(iSource[i]->Save(f)==KErrNone);

		f.Close();

		CFbsBitmap bmp;

		TEST(bmp.Load(names[i])==KErrNone);

		CFbsBitmap* orig = iSource[i];

		TSize size = orig->SizeInPixels();

		TInt bytes = orig->ScanLineLength(size.iWidth,KDisplayMode)*size.iHeight;

		orig->LockHeap();

		bmp.LockHeap();

		TEST(Mem::Compare((TUint8*)orig->DataAddress(),bytes,(TUint8*)bmp.DataAddress(),bytes)==0);

		orig->UnlockHeap();

		bmp.UnlockHeap();

		}

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0590

	@SYMTestCaseDesc

	Save multi bitmaps to file using an opened file handle.

	@SYMTestActions

	Save original bitmaps to file (saved bitmaps).

	Load saved bitmaps and compare it against originals.

	@SYMTestExpectedResults

	Saved bitmaps match original bitmaps

*/

void CTFile::StoreL()

	{

	const TBufC<32> names[KNumBitmap] =

		{

		(const TDesC&)KRamFile1,

		(const TDesC&)KRamFile2,

		(const TDesC&)KRamFile3

		};

	INFO_PRINTF1(_L("Storing bitmaps"));

	RFile f;

	TInt mode = EFileWrite;

	TInt ret = f.Open(iFs,KRamFile4,mode);

	if (ret==KErrNotFound)

		ret = f.Create(iFs,KRamFile4,mode);

	TEST(ret==KErrNone);

	const TDesC* bmps[] = {&names[0],&names[1],&names[2]};

	TInt32 ids[] = {0,0,0};

	TRAP(ret,CFbsBitmap::StoreL(f,KNumBitmap,bmps,ids));

	TEST(ret==KErrNone);

	f.Close();

	TInt id;

	for (id=0; id<KNumBitmap; ++id)

		{

		CFbsBitmap bmp;

		TEST(bmp.Load(KRamFile4,id)==KErrNone);

		CFbsBitmap* orig = iSource[id];

		TSize size = orig->SizeInPixels();

		TInt bytes = orig->ScanLineLength(size.iWidth,KDisplayMode)*size.iHeight;

		orig->LockHeap();

		bmp.LockHeap();

		TEST(Mem::Compare((TUint8*)orig->DataAddress(),bytes,(TUint8*)bmp.DataAddress(),bytes)==0);

		orig->UnlockHeap();

		bmp.UnlockHeap();

		}

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0591

	@SYMTestCaseDesc

	Load bitmap from file using an opened file handle.

	@SYMTestActions

	Load bitmap using file handle.

	Compare loaded bitmaps against original.

	@SYMTestExpectedResults

	Loaded bitmap match original

*/

void CTFile::LoadL()

	{

	// Load single bitmap file

	const TBufC<32> names[2*KNumBitmap] =

		{

		(const TDesC&)KRamFile1, //keep ram files at the top to make it easier to skip rom bitmaps

		(const TDesC&)KRamFile2,

		(const TDesC&)KRamFile3,

		(const TDesC&)KRomFile1,

		(const TDesC&)KRomFile2,

		(const TDesC&)KRomFile3

		};

	INFO_PRINTF1(_L("Loading bitmaps"));

	TInt i;

	TInt maxIndex = (iSkipRomBitmapTests ? KNumBitmap - 1 : 2 * KNumBitmap - 1);

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

		{

		RFile f;

		TInt mode = EFileShareReadersOnly;

		TInt ret = f.Open(iFs,names[i],mode);

		TEST(ret==KErrNone);

		CFbsBitmap bmp;

		TEST(bmp.Load(f)==KErrNone);

		f.Close();

		CFbsBitmap* orig = iSource[i%KNumBitmap];

		TSize size = orig->SizeInPixels();

		TInt bytes = orig->ScanLineLength(size.iWidth,KDisplayMode)*size.iHeight;

		orig->LockHeap();

		bmp.LockHeap();

		TEST(Mem::Compare((TUint8*)orig->DataAddress(),bytes,(TUint8*)bmp.DataAddress(),bytes)==0);

		orig->UnlockHeap();

		bmp.UnlockHeap();

		}

	// Load multi bitmap file

	const TBufC<32> mbm[] =

		{

		(const TDesC&)KRamFile4, //keep ram files at the top to make it easier to skip rom bitmaps

		(const TDesC&)KRomFile4

		};

	maxIndex = (iSkipRomBitmapTests ? 0 : 1);

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

		{

		RFile f;

		TInt mode = EFileShareReadersOnly;

		TInt ret = f.Open(iFs,mbm[i],mode);

		TEST(ret==KErrNone);

		TInt id;

		for (id=0; id<KNumBitmap; ++id)

			{

			CFbsBitmap bmp;

			TEST(bmp.Load(f,id)==KErrNone);

			CFbsBitmap* orig = iSource[id];

			TSize size = orig->SizeInPixels();

			TInt bytes = orig->ScanLineLength(size.iWidth,KDisplayMode)*size.iHeight;

			orig->LockHeap();

			bmp.LockHeap();

			TEST(Mem::Compare((TUint8*)orig->DataAddress(),bytes,(TUint8*)bmp.DataAddress(),bytes)==0);

			orig->UnlockHeap();

			bmp.UnlockHeap();

			}

		f.Close();

		}

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0592

	@SYMTestCaseDesc

	Load and compress bitmap from file using an opened file handle.

	@SYMTestActions

	Compress original bitmap.

	Load and compress bitmap using file handle.

	Blit loaded+compressed bitmaps and compressed original to screen.

	Compare screen area.

	@SYMTestExpectedResults

	LoadAndCompress ROM file return KErrAccessDenied.

	Drawn bitmap on screen match.

*/

void CTFile::LoadAndCompressL()

	{

	INFO_PRINTF1(_L("Loading and compressing bitmaps"));

	RFile f;

	TInt ret = KErrNone;

	if(!iSkipRomBitmapTests)

		{

		// load and compress ROM file

		ret = f.Open(iFs,KRomFile1,EFileShareReadersOnly);

		TEST(ret==KErrNone);

		CFbsBitmap bmp;

		TEST(bmp.LoadAndCompress(f)==KErrAccessDenied);

		f.Close();

		}

	// load single bitmap file

	const TBufC<32> names[KNumBitmap] =

		{

		(const TDesC&)KRamFile1,

		(const TDesC&)KRamFile2,

		(const TDesC&)KRamFile3

		};

	TInt i;

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

		{

		ret = f.Open(iFs,names[i],EFileShareReadersOnly);

		TEST(ret==KErrNone);

		CFbsBitmap bmp;

		TEST(bmp.LoadAndCompress(f)==KErrNone);

		f.Close();

		TEST(bmp.IsCompressedInRAM());

		CFbsBitmap* orig = iSource[i];

		TEST(orig->Compress()==KErrNone);

		TEST(orig->IsCompressedInRAM());

		TRAP(ret,BlitAndCompareL(orig,&bmp,orig->SizeInPixels()));

		TEST(ret==KErrNone);

		}

	// Load multi bitmap KRamFile4

	ret = f.Open(iFs,KRamFile4,EFileShareReadersOnly);

	TEST(ret==KErrNone);

	TInt id;

	for (id=0; id<KNumBitmap; ++id)

		{

		CFbsBitmap bmp;

		TEST(bmp.LoadAndCompress(f,id)==KErrNone);

		TEST(bmp.IsCompressedInRAM());

		CFbsBitmap* orig = iSource[id];

		TEST(orig->Compress()==KErrNone);

		TEST(orig->IsCompressedInRAM());

		TRAP(ret,BlitAndCompareL(orig,&bmp,orig->SizeInPixels()));

		TEST(ret==KErrNone);

		}

	f.Close();

	}

/**

	Blit two bitmap to screen device and compare if both match

*/

void CTFile::BlitAndCompareL(CFbsBitmap* aBmpOrig,CFbsBitmap* aBmpTest,const TSize& aBmpSize)

	{

	CFbsScreenDevice* scd=NULL;

	TRAPD(err,scd=CFbsScreenDevice::NewL(KDefaultScreenNo,KDisplayMode));

	if (err!=KErrNone)

		{

		_LIT(KLog,"Failed to create screen device for mode %S  err=%d");

		INFO_PRINTF3(KLog,&ColorModeName(KDisplayMode),err);

		}

	if (err==KErrNotSupported)

		{

		TRAPD(err,scd=CFbsScreenDevice::NewL(KDefaultScreenNo,EColor256));

		if (err!=KErrNone)

			{

			_LIT(KLog,"Failed to create Color256 screen device  err=%d");

			INFO_PRINTF2(KLog,err);

			}

		}

	if (err==KErrNotSupported)

		{

		TRAPD(err,scd=CFbsScreenDevice::NewL(KDefaultScreenNo,EColor16MA));

		if (err!=KErrNone)

			{

			_LIT(KLog,"Failed to create Color16MA screen device  err=%d");

			INFO_PRINTF2(KLog,err);

			}

		}

	if (err==KErrNotSupported)

		{

		TRAPD(err,scd=CFbsScreenDevice::NewL(KDefaultScreenNo,EColor16MAP));

		if (err!=KErrNone)