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

#include <w32debug.h>

#include <e32std.h> 

#include <graphics/fbsdefs.h>

#include "apgrfxfacade.h"

#include "TGraphicsHarness.h"

#include "GraphicsTestUtilsServer.h"

_LIT(KGraphicsTestFrameworkPanic, "Graphics Test Framework");

const TInt KTestCleanupStack = 0x40;

const TDisplayMode testDisplayModes[] =	

	{

	EGray2,

	EGray4,

	EGray16,

	EGray256,

	EColor16,

	EColor256,

	EColor64K,

	EColor16M,

	EColor4K,

	EColor16MU,

	EColor16MA,

	EColor16MAP,

	};

/**

  The test code manager, provides functions to set active object 

  with lowest priority for running tests in auto mode.

 */

class CTestManager : public CActive

	{

friend class CTGraphicsBase;

protected:

	static CTestManager* NewL(MTestCases* aAutoTestApp);

	~CTestManager();

	void FinishAllTestCases();

	void StartTest(); //initialize an active object and set it status as active

	void SetSelfDrive(TBool aSelfDrive);

	void CaseComplete();

private:

	CTestManager(MTestCases* aAutoTestApp);

	void NextTest();

	// from CActive

	void RunL();

	void DoCancel();

	TInt RunError(TInt aError);

private:

	MTestCases* iTestCase;

	TInt iCurTestCaseNumber; //a current test case, every time when function RunTestCaseL is called this member inc by one

	TBool iTestCompleted;

	TBool iSelfDrive;

	};

/** Construct an active object with the lowest priority */

CTestManager::CTestManager(MTestCases* aTestCases) :

		CActive(EPriorityIdle), iTestCase(aTestCases), iSelfDrive(EFalse)

	{}

CTestManager::~CTestManager()

	{

	Cancel();

	}

CTestManager* CTestManager::NewL(MTestCases* aTestCases)

	{

     CTestManager *theTestManager=new (ELeave) CTestManager(aTestCases);

     CActiveScheduler::Add(theTestManager);

	 return theTestManager;

	}

void CTestManager::RunL()

	{

	__ASSERT_ALWAYS(iTestCase, User::Panic(KGraphicsTestFrameworkPanic, KErrBadHandle));

	if(	iTestCompleted)

		{

		return;

		}

	// debug statement to indicate progress of test suite by

	// printing the sub-test that is currently active

	TTime timeStamp;

	timeStamp.HomeTime();

	TBuf<50> dateStr;

	_LIT(KDateString3,"%-B%:0%J%:1%T%:2%S%:3.%Cms");

	timeStamp.FormatL(dateStr, KDateString3);

	++iCurTestCaseNumber;

	RDebug::Print(_L("%S - Test Case Number: %d"), &dateStr, iCurTestCaseNumber);

	iTestCase->RunTestCaseL(iCurTestCaseNumber);

	if (iTestCompleted)

		{

		_LIT(KFinished,"Finished test case %d and test completed");

		RDebug::Print(KFinished,iCurTestCaseNumber);

		}

	else

		{

		if (iSelfDrive)

			{

			_LIT(KStarted,"Started test case %d");

			RDebug::Print(KStarted,iCurTestCaseNumber);

			}

		else

			{

			NextTest();

			}

		}

	}

void CTestManager::DoCancel()

	{

	if (!iSelfDrive)

		iTestCompleted = ETrue;

	}

TInt CTestManager::RunError(TInt aError)

	{

	TTime timeStamp;

	timeStamp.HomeTime();

	TBuf<50> dateStr;

	_LIT(KDateString3,"%-B%:0%J%:1%T%:2%S%:3 %Cms");

	timeStamp.FormatL(dateStr, KDateString3);

	_LIT(KTestLeft,"RunTestCaseL left of %S - Test Case Number: %d");

	RDebug::Print(KTestLeft, &dateStr, iCurTestCaseNumber);

	aError = iTestCase->RunTestCaseLeft(aError);

	FinishAllTestCases();

	return aError;

	}

/**

 	Initialize an active object and set it as active

 */

void CTestManager::StartTest()

	{

	TRequestStatus *pS= (&iStatus);

	User::RequestComplete(pS, 0);

	SetActive();

	}

/**

 Time to move on to the next test step

 */

void CTestManager::NextTest()

	{

	_LIT(KFinished,"Finished test case %d");

	RDebug::Print(KFinished,iCurTestCaseNumber);

	StartTest();

	}

/**

 Stop active scheduler, and quit a test step

 */

void CTestManager::FinishAllTestCases()

	{

	iTestCompleted = ETrue;

	CActiveScheduler::Stop();

	}

/**

 Controls wether the manager calls RunTestCaseL whenever the system is otherwise idol

 */

void CTestManager::SetSelfDrive(TBool aSelfDrive)

	{

	if (iSelfDrive!=aSelfDrive)

		{

		iSelfDrive = aSelfDrive;

		if (aSelfDrive)

			{

			if (IsActive())

				Cancel();

			}

		else

			{

			if (!IsActive() && !iTestCompleted)

				NextTest();

			}

		}

	}

/**

 Tells the manager this case is finished so you can call RunTestCaseL again

 */

void CTestManager::CaseComplete()

	{

	__ASSERT_DEBUG(!IsActive(), User::Panic(KGraphicsTestFrameworkPanic, ETestPanicAlreadyActive));

	if (iSelfDrive && !iTestCompleted)

		NextTest();

	}

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

EXPORT_C const TDesC& CTGraphicsBase::ColorModeName(TDisplayMode aMode)

	{

	_LIT(KNone,"None");

	_LIT(KGray2,"Grey2");

	_LIT(KGray4,"Grey4");

	_LIT(KGray16,"Grey16");

	_LIT(KGray256,"Grey256");

	_LIT(KColor16,"Color16");

	_LIT(KColor256,"Color256");

	_LIT(KColor4K,"Color4K");

	_LIT(KColor64K,"Color64K");

	_LIT(KColor16M,"Color16M");

	_LIT(KColor16MU,"Color16MU");

	_LIT(KColor16MA,"Color16MA");

	_LIT(KColor16MAP,"Color16MAP");

	_LIT(KRgb,"RGB");

	_LIT(KUnknown,"Unknown");

	switch(aMode)

		{

	case ENone:

		return KNone;

	case EGray2:

		return KGray2;

	case EGray4:

		return KGray4;

	case EGray16:

		return KGray16;

	case EGray256:

		return KGray256;

	case EColor16:

		return KColor16;

	case EColor256:

		return KColor256;

	case EColor64K:

		return KColor64K;

	case EColor16M:

		return KColor16M;

	case ERgb:

		return KRgb;

	case EColor4K:

		return KColor4K;

	case EColor16MU:

		return KColor16MU;

	case EColor16MA:

		return KColor16MA;

	case EColor16MAP:

		return KColor16MAP;

	default:

		return KUnknown;

		}

	}

EXPORT_C const TDesC& CTGraphicsBase::RotationName(CFbsBitGc::TGraphicsOrientation aOrientation)

	{

	_LIT(K0,"Normal");

	_LIT(K90,"Rotated90");

	_LIT(K180,"Rotated180");

	_LIT(K270,"Rotated270");

	_LIT(KUnknown,"Unknown");

	switch(aOrientation)

		{

	case CFbsBitGc::EGraphicsOrientationNormal:

		return K0;

	case CFbsBitGc::EGraphicsOrientationRotated90:

		return K90;

	case CFbsBitGc::EGraphicsOrientationRotated180:

		return K180;

	case CFbsBitGc::EGraphicsOrientationRotated270:

		return K270;

	default:

		return KUnknown;

		}

	}

EXPORT_C void CTGraphicsBase::SaveScreenShotL(CFbsScreenDevice* aScdv)

	{

#ifdef __WINS__

	_LIT(KBitmapDrive, "c:");

#else

	_LIT(KBitmapDrive, "e:");

#endif

	_LIT(KBitmapPath, "\\screenshot.mbm");

	TDisplayMode dispMode = aScdv->DisplayMode();

	TSize scrSize = aScdv->SizeInPixels();

	CFbsBitmap* dstBmp = new(ELeave) CFbsBitmap;

	CleanupStack::PushL(dstBmp);

	User::LeaveIfError(dstBmp->Create(scrSize, dispMode));

	HBufC8* row = HBufC8::NewLC(scrSize.iWidth*4);

	TPtr8 prow = row->Des();

	for (TInt ii = 0; ii < scrSize.iHeight; ++ii)

		{

		aScdv->GetScanLine(prow, TPoint(0, ii), scrSize.iWidth, dispMode);

		dstBmp->SetScanLine(prow,ii);

		}

	CleanupStack::PopAndDestroy(row);

	TFileName mbmFile;

	mbmFile.Append(KBitmapDrive);

	mbmFile.Append(KBitmapPath);	

	User::LeaveIfError(dstBmp->Save(mbmFile));

	CleanupStack::PopAndDestroy(dstBmp);

	}

EXPORT_C CTGraphicsBase::CTGraphicsBase(CTestStep* aStep) :

			iStep(aStep)

	{}

EXPORT_C CTGraphicsBase::~CTGraphicsBase()

	{

	if(iTestManager)

		{

		iTestManager -> Cancel();

		}

	delete iTestManager;

	}

void CTGraphicsBase::InitializeL()

	{

	__ASSERT_DEBUG(iStep, User::Panic(KGraphicsTestFrameworkPanic, KErrBadHandle));

	iTestManager = CTestManager::NewL(this);

	}

/**

 	The function must be called after all test cases completed 

 */	

EXPORT_C void CTGraphicsBase::TestComplete()

	{

	if(iTestManager)

		{

		iTestManager -> FinishAllTestCases();

		}

	}

EXPORT_C void CTGraphicsBase::SetSelfDrive(TBool aSelfDrive)

	{

	if (iTestManager)

		iTestManager->SetSelfDrive(aSelfDrive);

	}

EXPORT_C void CTGraphicsBase::CaseComplete()

	{

	if (iTestManager)

		iTestManager->CaseComplete();

	}

EXPORT_C TInt CTGraphicsBase::RunTestCaseLeft(TInt aError)

	{

	_LIT(KRunTestCaseLLeft,"The RunTestCaseL left with %d");

	ERR_PRINTF2(KRunTestCaseLLeft,aError);

	iStep->SetTestStepResult(EFail);

	return KErrNone;

	}

/** Start a test cases loop */

void CTGraphicsBase::Execute()

	{

	__ASSERT_DEBUG(iTestManager, User::Panic(KGraphicsTestFrameworkPanic, KErrBadHandle));

	__ASSERT_DEBUG(CActiveScheduler::Current(), User::Panic(KGraphicsTestFrameworkPanic, KErrBadHandle));

	iTestManager -> StartTest();

	CActiveScheduler::Start();

	}

/**

	Reset test cases counter to a new value. Can be used for running the same consequence of test 

	cases with different initial parameters.

	aNewCurrentTestCase cannot be negative.

*/

EXPORT_C void CTGraphicsBase::ResetCounter(TInt aNewCurrentTestCase )

	{

	__ASSERT_DEBUG(aNewCurrentTestCase >= 0, User::Panic(KGraphicsTestFrameworkPanic, KErrArgument));

	iTestManager->iCurTestCaseNumber = aNewCurrentTestCase;

	}

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

/**

 Initialise the cleanup stack.

*/

void CTGraphicsStep::SetupCleanup(CTrapCleanup*& tc)

    {

	tc = CTrapCleanup::New();

	if (!tc)

		{

		User::Panic(_L("Out of memory"), KErrNoMemory);

		}

	TRAPD(r, 

		{

		for ( TInt ii = KTestCleanupStack; ii > 0; ii-- )

			CleanupStack::PushL( (TAny*)1 );

		TEST( r == KErrNone );

		CleanupStack::Pop( KTestCleanupStack );

		} );

	}

void CTGraphicsStep::LogHeapInfo(RWsSession& aWs, TBool aStart)

	{

	_LIT(KInfoStart,"Start");

	_LIT(KInfoEnd,"End");

	_LIT(KInfoCheckPassed,"WsHeap leak check passed");

	_LIT(KInfoCheckFailed,"Memory leak detected. Number of orphaned cells=%d.");

	_LIT(KInfoCheckFailed2,"See epocwindout for the address of the first orphaned cell.");

	_LIT(KInfoHeapSummary," WsHeap - Count=%d,Total=%d,Free=%d,Max free=%d");

	_LIT(KInfoDisabled,"Memory leak testing has not been enabled.");

	TPckgBuf<TWsDebugHeapInfo> heapInfo;

	aWs.DebugInfo(EWsDebugInfoHeap,heapInfo);

	TBuf<256> infoBuf;

	if (aStart)

		{

		infoBuf.Append(KInfoStart);

		}

	else

		{

		infoBuf.Append(KInfoEnd);

		TInt heapFailCount=aWs.DebugInfo(EWsDebugFetchCheckHeapResult);

		if (heapFailCount==KErrNone)

			{

			INFO_PRINTF1(KInfoCheckPassed);

			}

		else if (heapFailCount>0) // Negative error should be ignored as it means the check has not been enabled

			{

			TEST(0);

			ERR_PRINTF2(KInfoCheckFailed,heapFailCount);

			ERR_PRINTF1(KInfoCheckFailed2);

			}

		else

		    {

		    WARN_PRINTF1(KInfoDisabled);

		    }

		}

	infoBuf.AppendFormat(KInfoHeapSummary,heapInfo().iCount,heapInfo().iTotal,heapInfo().iAvailable,heapInfo().iLargestAvailable);

	INFO_PRINTF1(infoBuf);

	}

/**

 Main entry point from CTestStep class. 

 Creates cleanup stack, background window and launches a test

*/

EXPORT_C TVerdict CTGraphicsStep::doTestStepL()

	{

	TInt memFree;

	HAL::Get(HALData::EMemoryRAMFree, memFree);

	INFO_PRINTF2(_L("Test started - RAM free: %d"), memFree);	

	__UHEAP_MARK;

	CTrapCleanup* tc = NULL;

	SetupCleanup(tc);

	TInt err = RFbsSession::Connect();

	if(err != KErrNone)

		{

		FbsStartup();

		err = RFbsSession::Connect();

		if(err != KErrNone) 

			{

			User::Panic(_L("Font bitmap session connect"), err);

			}

		}

	RWsSession ws;

	err = ws.Connect();

	if (iLogHeapInfo && err==KErrNone)

		{

		ws.DebugInfo(EWsDebugSetCheckHeapOnDisconnectClient);

		LogHeapInfo(ws,ETrue);

		}

	TInt theId1 = NULL;

#ifdef __WINS__

	RWindowGroup winGroup = RWindowGroup(ws);

	RWindow theWindow(ws);

	if (err==KErrNone)

		{

		const TUint32 ENullWsHandle = 0xFFFFFFFF;	// Events delivered to this handle are thrown away

	//creat background window with the size of the screen

	//it is particulary important for tests which draw on the screen, read screen buffer

	//and compare result. By default top TEF window is concole and blinking cursor can interfere

	//with the work of the tests

		TSize size(640, 240); //some default value

	//retrieve screen size

		err = GetScreenSize(size);

		if(err)

			{

			WARN_PRINTF2(_L("Can't retrieve size from screen driver err = %d"), err);

			}

		winGroup.Construct(ENullWsHandle);

		winGroup.AutoForeground(ETrue);

		theId1 = winGroup.Identifier();

		theWindow.Construct(winGroup, ENullWsHandle);

		theWindow.SetExtent(TPoint(0, 0), size);

		theWindow.SetVisible(ETrue);

		theWindow.Activate();

	//the following trick we need to put the window on the top

		TApaTaskListFacade taskList(ws);

		TApaTaskFacade task = taskList.FindByPos(1);

		task.BringToForeground();

		TApaTaskFacade task1(ws);

		task1.SetWgId(theId1);

		task1.BringToForeground();

		}

#endif

	if (err==KErrNone)

		{

		CloseAllPanicWindows(theId1, ws);

		}

	// initialize the test and kick off the test cases loop

	TRAP(err, TestSetupL();  // initialize a test step

				ExecuteL()); // run active scheduler, in order to complete test execution 

							 // CTGraphicsStep::TestComplete function needs to be called

	if (err)

		{

		SetTestStepResult(EFail);

		}

	TestClose(); // free all allocated resources here

	if (ws.Handle())

		{

		CloseAllPanicWindows(theId1, ws);

#ifdef __WINS__	

		theWindow.Close();

		winGroup.Close();

#endif

		ws.Close();

		User::After(50000);	

		// Prev close will trigger Wserv dummy shutdown and heap check

		// We then re-connect to get the result of the shutdown.

		RWsSession ws2;

		TInt errConnection;

		TInt MaxNumberOfAttempt=10;

		TInt currentAttempt=0;		

		do

			{

			errConnection=ws2.Connect();		

			if (errConnection==KErrNone)

				{

				LogHeapInfo(ws2,EFalse);

				ws2.Close();

				}

			else

				{

				RDebug::Printf("Connection Error with Wserv... %i",errConnection);

				User::After(50000);		

				}

			currentAttempt++;

			}while( (errConnection!=KErrNone) && (currentAttempt<MaxNumberOfAttempt) );

		}

	RFbsSession::Disconnect();	

	delete tc;

	__UHEAP_MARKEND;

	return TestStepResult();

	}

void CTGraphicsStep::CloseAllPanicWindows(TInt aId, RWsSession& ws) const

	{

	TInt idFocus = ws.GetFocusWindowGroup();

	TWsEvent event;

	event.SetType(EEventKey); //EEventKeyDown

	TKeyEvent *keyEvent = event.Key();

	keyEvent->iCode = EKeyEscape;

	keyEvent->iScanCode = EStdKeyEscape;

	keyEvent->iModifiers = 0;

	TInt theLimit = 50;

	while(idFocus != aId && (theLimit-- > 0))

		{

		ws.SendEventToAllWindowGroups(event);

		idFocus = ws.GetFocusWindowGroup();

		}

	}

TInt CTGraphicsStep::GetScreenSize(TSize& aSize) const

	{

	CFbsScreenDevice* dev = NULL;

	TInt err = KErrNone;

	TInt sizeOfDisplayMode = sizeof (testDisplayModes) / sizeof(testDisplayModes[0]);

	for(TInt theScreenModeIndex = sizeOfDisplayMode - 1; theScreenModeIndex ; theScreenModeIndex--)

		{

		TDisplayMode disp = testDisplayModes[theScreenModeIndex];

		TRAP(err, dev = CFbsScreenDevice::NewL(_L(""), disp)); //scdv

		if(err == KErrNone)

			{

			aSize = dev->SizeInPixels();

			delete dev;

			return KErrNone;

			}

		delete dev;

		dev = NULL;		

		}

	return err;		

	}

/** Installs an active scheduler and launches a test*/

void CTGraphicsStep::ExecuteL()

	{

	CActiveScheduler* theAs = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(theAs);

	CActiveScheduler::Install(theAs);

	CTGraphicsBase*	autoTest = CreateTestL();

	User::LeaveIfNull(autoTest);

	CleanupStack::PushL(autoTest);

	autoTest -> InitializeL();

	autoTest -> ConstructL();

	autoTest -> Execute();

	CleanupStack::PopAndDestroy(2, theAs);

	}

TInt  E32Dll( )

	{

	return 0;

	}