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

 */

 #include "t_wservratelimiterteststep.h"

 #include <test/tefunit.h>

 #include <e32const.h>

 #include <gdi.h>

 #include <stdlib.h>

 #include "constants.h"

 const TPoint KWinPos(0,0);

 const TSize KWinSize(640,240);

 const TRect KWinRect(KWinPos,KWinSize);

 const TRect KEllipseRect(TPoint(10,10), TSize(50,50));

 //Name of the test step

 _LIT(KT_WServRateLimiterTestStep,"T_WServRateLimiterTestStep");

 /**

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

 protected:

 	static CTestManager* NewL(MTestCases* aAutoTestApp);

 	~CTestManager();

 	void FinishAllTestCases();

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

 private: 

 	CTestManager(MTestCases* aAutoTestApp);

 	// from CActive

 	void RunL();

 	void DoCancel();

 private:

 	MTestCases* iTestCase;

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

 	TBool iTestCompleted;

 	};

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

 CTestManager::CTestManager(MTestCases* aTestCases) :

 			CActive(EPriorityIdle), 

 			iTestCase(aTestCases)

 	{

 	}

 CTestManager::~CTestManager()

 	{

 	Cancel();

 	}

 CTestManager* CTestManager::NewL(MTestCases* aTestCases)

 	{

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

      CActiveScheduler::Add(theTestManager);

 	 return theTestManager;

 	}

 void CTestManager::RunL()

 	{

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

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

 	iTestCase -> RunTestCaseL(iCurTestCaseNumber);

 	if(!iTestCompleted)

 		{

 		StartTest();

 		}

 	}

 void CTestManager::DoCancel()

 	{

 	iTestCompleted = ETrue;

 	}

 /**

  	Initialize an active object and set it as active

  */

 void CTestManager::StartTest()

 	{

 	TRequestStatus *pS= (&iStatus);

 	User::RequestComplete(pS, 0);

 	SetActive();

 	}

 /**

  Stop active scheduler, and quit a test step	

  */

 void CTestManager::FinishAllTestCases()

 	{

 	iTestCompleted = ETrue;

 	CActiveScheduler::Stop();

 	}

 //

 // Wait till redraws finished //

 //

 enum TTRateLimiterActivePriorities

 	{

 	ETRateLimiterRedrawActivePriority=-10,

 	};

 class CStopTheScheduler : public CAsyncOneShot

 	{

 public:

 	CStopTheScheduler(TInt aPriority);

 	static CStopTheScheduler* NewL(TInt aPriority);

 	void RunL();

 	};

 CStopTheScheduler* CStopTheScheduler::NewL(TInt aPriority)

 	{

 	return new(ELeave)CStopTheScheduler(aPriority);

 	}

 CStopTheScheduler::CStopTheScheduler(TInt aPriority)

 	:CAsyncOneShot(aPriority)

 	{

 	}

 void CStopTheScheduler::RunL()

 	{

 	CActiveScheduler::Stop();

 	}

 void WaitForRedrawsToFinish()

 	{

 	CStopTheScheduler* ps=new CStopTheScheduler(ETRateLimiterRedrawActivePriority);

 	if(ps)

 		{

 		ps->Call();

 		CActiveScheduler::Start();

 		delete ps;

 		}

 	}

 /**

 Constructor of CT_WServRateLimiterTestStep

 */

 CT_WServRateLimiterTestStep::CT_WServRateLimiterTestStep():

 		iTwoScreens(EFalse)

 	{

 	SetTestStepName(KT_WServRateLimiterTestStep);

 	}

 /**

 Destructor of CT_WServRateLimiterTestStep

 */

 CT_WServRateLimiterTestStep::~CT_WServRateLimiterTestStep()

 	{

 	delete iGc;

 	delete iGc2;

 	delete iScreen;

 	delete iScreen1;

 	iWinGroup.Close();

 	iWinGroup1.Close();

 	iWsSession.Flush();

 	iWsSession.Close();

 	if(iTestManager)

 		{

 		iTestManager -> Cancel();

 		}

 	delete iTestManager;

 	}

 /**

 Starts test step

 @return TVerdict pass / fail

 */

 enum TVerdict CT_WServRateLimiterTestStep::doTestStepL()

 	{

 	iDisplayMode = EColor64K;

 	User::LeaveIfError(iWsSession.Connect());

 	// Screen 1 setup

 	iScreen = new (ELeave) CWsScreenDevice(iWsSession);

 	User::LeaveIfError(iScreen->Construct());

 	iWinGroup = RWindowGroup(iWsSession);

 	User::LeaveIfError(iWinGroup.Construct(KNullWsHandle, iScreen));

 	iWinGroup.AutoForeground(ETrue);

 	// Gc setup

 	iGc = new (ELeave) CWindowGc(iScreen);

 	User::LeaveIfError(iGc->Construct());

 	// Screen 2 setup

 	iScreen1 = new (ELeave) CWsScreenDevice(iWsSession);

 	if (iWsSession.NumberOfScreens() > 1)

 		{

 		iTwoScreens = ETrue;

 		}

 	if (iTwoScreens)

 		{

 		User::LeaveIfError(iScreen1->Construct(1));

 		iWinGroup1 = RWindowGroup(iWsSession);

 		User::LeaveIfError(iWinGroup1.Construct(KNullWsHandle, iScreen1) );

 		iWinGroup1.AutoForeground(ETrue);

 		// Gc setup

 		iGc2 = new (ELeave) CWindowGc(iScreen1);

 		User::LeaveIfError(iGc2->Construct());

 		}

 	iWsSession.Finish();

 	CActiveScheduler* theAs = new (ELeave) CActiveScheduler;

 	CleanupStack::PushL(theAs);

 	CActiveScheduler::Install(theAs);

 	iTestManager = CTestManager::NewL(this);

 	iTestManager -> StartTest();

 	CActiveScheduler::Start();

 	CleanupStack::PopAndDestroy(theAs);

 	return TestStepResult();

 	}

 /**

 Creates a RWindow

 @param aWinGroup The window group object

 @param aWin	The window object

 @param aPos	The Position of the window

 @param aBkgdColor The background color of the window

 @param aSize The size of the window

 @param aHandle The handle of the window

 */

 void CT_WServRateLimiterTestStep::CreateRWindowL(const RWindowGroup& aWinGroup, 

 												   RWindow& aWin, 

 												   const TPoint& aPos, 

 												   const TRgb& aBkgdColor, 

 												   const TSize& aWinSize,

 												   const TUint32 aHandle)

 	{

 	aWin = RWindow( iWsSession );

 	CleanupClosePushL( aWin );

 	User::LeaveIfError( aWin.Construct( aWinGroup, aHandle ) );

 	CleanupStack::Pop(&aWin);

 	aWin.SetExtent(aPos, aWinSize);

 	aWin.SetBackgroundColor( aBkgdColor );

 	aWin.Activate();

 	aWin.SetVisible( ETrue );

 	}

 /**

 Draw the actual animation

 @param aWin The window object

 @param aGraphic The graphic to draw

 @param aGc The gc do draw with

 */

 void CT_WServRateLimiterTestStep::DrawGraphic(RWindow& aWin, CWsGraphic* aGraphic, CWindowGc* aGc)

 	{

 	aGc->Activate(aWin);

 	TBuf8<1> animData; 

 	animData.Append(0);

 	aGc->DrawWsGraphic(aGraphic->Id(),TRect(KWinPos, KWinSize),animData);

 	aGc->Deactivate();

 	}

 /**

 @param aActualFrameRate The actual frame rate of the animation

 @param aExpectedFrameRate The expected frame rate of the animation

 @param aErrorThreshhold The error allowed between the actual and expected frame rate

 */

 TBool CT_WServRateLimiterTestStep::IsRunningAtExpectedFrameRate(TReal aActualFrameRate, TReal aExpectedFrameRate, TReal aErrorThreshHold)

 	{

 	TReal diff=aActualFrameRate-aExpectedFrameRate;

 	return (-diff<=aErrorThreshHold && diff<=aErrorThreshHold);

 	}

 /**

 @SYMTestCaseID			GRAPHICS-WSERV-2095-0014

 @SYMPREQ				2095

 @SYMTestCaseDesc		Running a CRP animation on one screen at a limited rate or both screens both at different rates			

 @SYMTestActions			Run CRP animation on one or 2 screens if 2 are available 

 @SYMTestStatus			Implemented

 @SYMTestPriority		2

 @SYMTestExpectedResults	If 1 screen available:

 						CRP animation occurs at ratelimited rate

 						If 2 screens available:

 						CRP animation occur at different rates on both screens.

 						CRP animation occur at expected rates on both screens.

 @SYMTestType			CT

 */	

 void CT_WServRateLimiterTestStep::TestRateLimitedAnimationL()

 	{

 	CWsRateLimitGraphic* rateLimitGraphic1 = CWsRateLimitGraphic::NewL();

 	CleanupStack::PushL(rateLimitGraphic1);

 	CWsRateLimitGraphic* rateLimitGraphic2 = NULL;

 	if (iTwoScreens)

 		{

 		rateLimitGraphic2 = CWsRateLimitGraphic::NewL();

 		CleanupStack::PushL(rateLimitGraphic2);

 		}

 	RWindow win1;

 	CleanupClosePushL(win1);

 	CreateRWindowL(iWinGroup, win1, KWinPos, KRgbBlue, KWinSize);

 	win1.BeginRedraw();

 	DrawGraphic(win1, rateLimitGraphic1, iGc); // running at a limited rate

 	win1.EndRedraw();

 	RWindow win2;

 	if (iTwoScreens)

 		{

 		CleanupClosePushL(win2);

 		CreateRWindowL(iWinGroup1, win2, KWinPos, KRgbBlue, KWinSize);

 		win2.BeginRedraw();

 		DrawGraphic(win2, rateLimitGraphic2, iGc2); // running flat out

 		win2.EndRedraw();

 		}

 	iWsSession.Finish();

 	User::After(KAnimLength + 2000000); // Animation length + 2 secs

 	//Stores data obtained from server side of CRP

 	TAnimData animData;

 	//Invoke the plug-in and get the frame rate values

 	Mem::FillZ(&animData, sizeof(TAnimData));

 	// Retrieve anim data from first crp

 	rateLimitGraphic1->QueryPluginForFrameRate(animData);

 	iWsSession.Finish();

 	WaitForRedrawsToFinish();

 	TReal frameRate1 = animData.iFrameRate; 

 	TReal frameRate2 = 0.0;

 	if (iTwoScreens)

 		{

 		// Retrieve anim data from second crp

 		rateLimitGraphic2->QueryPluginForFrameRate(animData);

 		iWsSession.Finish();

 		WaitForRedrawsToFinish();

 		frameRate2 = animData.iFrameRate; 

 		}

 	/* Test, screen0(first screen) is running at approximately the correct rate */ 

 	TReal rateLimtedExpectedFrameRate = KOneSecondInMicroSecs / KFrameRateDelay;

 	INFO_PRINTF2(_L("Test if screen0 is running at approximately the correct rate of %f"), rateLimtedExpectedFrameRate);

 	INFO_PRINTF2(_L("Screen0 Actual Frame Rate = %f"), frameRate1);

 	TBool isCorrectRate1 = IsRunningAtExpectedFrameRate(frameRate1,rateLimtedExpectedFrameRate, KStdErrorThreshHold);

 	TEST(isCorrectRate1);

 	if (iTwoScreens)

 		{

 		/* Test, screen1(second screen) is running at approximately the correct rate */ 

 		INFO_PRINTF2(_L("Test if screen1 is running at faster than %f fps"), KStdMinimumFrameRate);

 		INFO_PRINTF2(_L("Screen1 Actual Frame Rate = %f"), frameRate2);

 		TBool isCorrectRate2 = frameRate2 > KStdMinimumFrameRate;

 		TEST(isCorrectRate2);

 		}

 	if (iTwoScreens)

 		{

 		CleanupStack::PopAndDestroy(4, rateLimitGraphic1);

 		}

 	else

 		{

 		CleanupStack::PopAndDestroy(2,rateLimitGraphic1);

 		}

 	}

 void CT_WServRateLimiterTestStep::RunTestCaseL(TInt /*aCurTestCase*/)

 	{

 	switch( iTestId )

 		{

 		case 0:

 			if (iTwoScreens)

 				{

 				INFO_PRINTF1(_L("Testing both screens running animation at different frame rates"));

 				}

 			else

 				{

 				INFO_PRINTF1(_L("Testing one screen running animation at ratelimited frame rate"));

 				}

 			TestRateLimitedAnimationL();

 			break;

 		default:

 			iTestManager->FinishAllTestCases();

 			break;	

 		}

 	iTestId++;

 	}