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

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include <test/testexecutestepbase.h>

#include <openfont.h>

#include <test/thashreferenceimages.h>

#include <hash.h>

_LIT(KHashIDFormat, "%S_%d_%S_%S_%d");

const TInt KLengthOfHashValue = 256;

const TInt KNumOfDisplayModes = 12;

/* This is a list of display modes used - the parameter passed to the string 

   creation function is an index into this table

 	EGray2,

	EGray4,

	EGray16,

	EGray256,

	EColor16,

	EColor256,

	EColor64K,

	EColor16M,

	EColor4K,

	EColor16MU,

	EColor16MA,

	EColor16MAP

   */

_LIT(KMode0,"EGray2");

_LIT(KMode1,"EGray4");

_LIT(KMode2,"EGray16");

_LIT(KMode3,"EGray256");

_LIT(KMode4,"EColor16");

_LIT(KMode5,"EColor256");

_LIT(KMode6,"EColor64K");

_LIT(KMode7,"EColor16M");

_LIT(KMode8,"EColor4K");

_LIT(KMode9,"EColor16MU");

_LIT(KMode10,"EColor16MA");

_LIT(KMode11,"EColor16MAP");

//Uncomment the line below to save the image of the screen to a mbm file.

//#define SAVEBITMAP

//Note: To updated existing hash values in toutlineandshadow.ini, you need to delete the previous entries along with hashid's in toutlineandshadow.ini and export this ini

//If a existing test case need updating that will change the hash value, then the hash for this test case needs to be removed from the .ini file 

//Uncomment the line below to add a new hash value for any test cases that do not already have a hash.

//#define APPEND_NEW_OR_MISSING_HASH_DATA

// Constructor

CTHashReferenceImages::CTHashReferenceImages(CTestStep* aStep, RFbsSession* aFbs):CBase(),iFbs(aFbs),iStep(aStep) { }

EXPORT_C CTHashReferenceImages* CTHashReferenceImages::NewL(CTestStep* aStep, RFbsSession* aFbs, const TDesC *aPath)

	{

	CTHashReferenceImages* ptr = new (ELeave)CTHashReferenceImages(aStep,aFbs);

	CleanupStack::PushL(ptr);

	ptr->ConstructL(aPath);

	CleanupStack::Pop();

	return ptr;

	}

void CTHashReferenceImages::ConstructL(const TDesC *aPath)

	{

	iPath = aPath->AllocL();

	}

// Destructor

EXPORT_C CTHashReferenceImages::~CTHashReferenceImages()

	{

	//nothing is owned by this class, except iPath

	delete iPath;

	}

/**

Auxilary function should be called only when we need to generate hash values from the screen and returns its hex format.

@param aHexString the output MD5 hash hex string obtained from iBitmapDevice

*/

EXPORT_C void CTHashReferenceImages::GenerateHashAndReturnInHexFormatL(TDes &aHexString)

	{

	TInt bufLen = CFbsBitmap::ScanLineLength(iBitmapDevice->SizeInPixels().iWidth, iBitmapDevice->DisplayMode());

	RBuf8 buff;

	buff.CreateL(bufLen);

	CleanupClosePushL(buff);	

	CMD5 *md = CMD5::NewL();

	CleanupStack::PushL(md);

	for (TPoint pos(0, 0); pos.iY < iBitmapDevice->SizeInPixels().iHeight; pos.iY++)

		{

		iBitmapDevice->GetScanLine(buff,pos,iBitmapDevice->SizeInPixels().iWidth,iBitmapDevice->DisplayMode());

		md->Update(buff);

		}

	TBuf8<KLengthOfHashValue> hashString;

	//md will be reset after calling CMD5::Final() as Final will call Reset.

	hashString.Copy(md->Final());

	aHexString.Zero();

	for(TInt icount=0; icount < hashString.Length(); icount++)

		{

		aHexString.AppendNumFixedWidth(hashString[icount], EHex, 4);

		}

	CleanupStack::PopAndDestroy(2, &buff);

	}

/**

Auxilary function called to compare generated hash with reference hash and report error if they don't match.

@param aHashIndex holds the hashId.

*/

EXPORT_C void CTHashReferenceImages::CompareHashValuesL(const TDesC& aHashIndex)

	{

	TBuf<KLengthOfHashValue>  hexString;

	//Gets the hash value for the current drawings

	GenerateHashAndReturnInHexFormatL(hexString);

	TPtrC hashFromConfig;

	TBool stringFound = iStep->GetStringFromConfig(iStep->ConfigSection(), aHashIndex, hashFromConfig);

	if (stringFound)

		{

		//cannot use the macro //TEST((hashFromConfig.Compare(hexString)) == 0); since iStep needs to be 

		//referenced

		iStep->testBooleanTrue((hashFromConfig.Compare(hexString)) == 0, (TText8*)__FILE__, __LINE__, ETrue);

		}

	else

		{

#ifdef APPEND_NEW_OR_MISSING_HASH_DATA

		//Hash data will be written to ini file if hash id is not found.

		//If written the status will be as INI WRITE with the new hash id and value in test log file.

		iStep->testBooleanTrue(iStep->WriteStringToConfig(iStep->ConfigSection(), aHashIndex, hexString), (TText8*)__FILE__, __LINE__);

#ifdef SAVEBITMAP

		CopyScreenToBitmapL(aHashIndex);

#endif

#else

		//Report error in case hash data is missing and APPEND_NEW_OR_MISSING_HASH_DATA is not defined

		iStep->testBooleanTrue( 0, (TText8*)__FILE__, __LINE__);

#endif

		}

	}

/**

Auxilary function called to generate Hash ID String based on the parameters (test case ID, subtest etc...) and returns

HashId looks like:Testcasecame_0010_9_Swiss_EGray2_0 (aTestCase = DrawText_0010 or DrawTextVertical_0010, aSubTestNumber = 9, aFontFaceIndex = Swiss, aDisplayMode = EGray2, aOrientation = 0)

@param aTestCase holds the testcase ID

@param aSubTestNumber holds the subtest number

@param aFontFaceIndex holds the font face index (index used in KFontFace[])

@param aDisplayMode holds the display mode

@param aOrientation holds the orientation number

*/

EXPORT_C HBufC* CTHashReferenceImages::GenerateHashIdStringLC(const TDesC& aTestCase, TInt aSubTestNumber, const TPtrC aName[], TInt aNameIndex,

												TInt aDisplayMode, TInt aOrientation)

	{

	//this is here because at file scope there is uninitialised writable data

	const TDesC * KDisplayModeNames[KNumOfDisplayModes] = 

		{

		&KMode0,

		&KMode1,

		&KMode2,

		&KMode3,

		&KMode4,

		&KMode5,

		&KMode6,

		&KMode7,

		&KMode8,

		&KMode9,

		&KMode10,

		&KMode11,

		};	

	TBuf<KLengthOfHashValue> tempBuffer;

	tempBuffer.Format(KHashIDFormat, &aTestCase, aSubTestNumber, &aName[aNameIndex], KDisplayModeNames[aDisplayMode], aOrientation);

	return tempBuffer.AllocLC();

	}

/**

Auxilary function called to Copy the screen to bitmap (mbm) file.

@param aHashIndex contains hashID. Bitmap is created with the aHashIndex as name

*/

EXPORT_C void CTHashReferenceImages::CopyScreenToBitmapL(const TDesC& aHashIndex)

	{

	CFbsBitmap *bitmap = new(ELeave)CFbsBitmap();

	CleanupStack::PushL(bitmap);

	User::LeaveIfError(bitmap->Create(iBitmapDevice->SizeInPixels(), iBitmapDevice->DisplayMode()));

	TRect rect = TRect(iBitmapDevice->SizeInPixels());

	CFbsBitmapDevice *device=CFbsBitmapDevice::NewL(bitmap);

	CleanupStack::PushL(device);

	CFbsBitGc *gc;

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

	gc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

	gc->BitBlt(TPoint(), iBitmap, rect);

	TFileName mbmFile;

	mbmFile.Format(iPath->Des(), &aHashIndex);

	bitmap->Save(mbmFile);

	delete gc;

	CleanupStack::PopAndDestroy(2);

	}

/* 

Auxilary function used to change the referenced member data (ownership is not transferred)

*/

EXPORT_C void CTHashReferenceImages::SetScreenDeviceAndBitmap(CBitmapDevice* aBitmapDevice, CFbsBitmap* aBitmap, CFbsBitGc* aGc )

	{

	iBitmapDevice = aBitmapDevice;

	iBitmap = aBitmap;

	iGc = aGc;

	}