// 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 - Internal Symbian test code
*/

#include "tredrawstoreperf.h"

const TInt KIterationsToTest = 100; // Number of iterations to run tests
TRect seg1;
TRect seg2;
TRect seg3;
TRect seg4;
TRect seg5;
TRect seg6;

CTRedrawstorePerf::CTRedrawstorePerf()
	{
	SetTestStepName(KTRedrawstorePerf);
	}

CTRedrawstorePerf::~CTRedrawstorePerf()
	{
	delete iGc;
	delete iScreenDevice;
	iWin.Close();
	iWinGroup.Close();
	iWs.Close();
	}

void CTRedrawstorePerf::CreateRWindowL()
	{
	iWin = RWindow(iWs);
	User::LeaveIfError(iWin.Construct(iWinGroup, 2));
	User::LeaveIfError(iWin.SetTransparencyAlphaChannel());	
	iWin.SetBackgroundColor(TRgb(255,255,255,128 ));
	iWin.Activate();
	Init();
	}

void CTRedrawstorePerf::Init()
	{
	// Create RedrawStore segments
	seg1=TRect( TSize( iWin.Size() ) );	
	seg2=TRect( TPoint(50,0), seg1.Center()-TPoint(20,20) );
	seg3=TRect( TPoint(seg1.Width()/2 + 20, 0), TPoint(seg1.Width()-50, seg1.Height()/2 -20 ) );
	seg4=TRect( TPoint(50, seg1.Height()/2 + 20 ), TPoint(seg1.Width()/2 - 20, seg1.Height() ) );
	seg5=TRect( seg1.Center()+TPoint(20,20), TPoint( seg1.Width()-50, seg1.Height()) );
	seg6=TRect( seg1.Center()-TPoint(75,75), TSize(150,150) );
	}

/**
Override of base class virtual

@return - TVerdict code
*/
TVerdict CTRedrawstorePerf::doTestStepPreambleL()
	{
	CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();
	return TestStepResult();
	}

/**
Override of base class pure virtual
Our implementation only gets called if the base class doTestStepPreambleL() did
not leave. That being the case, the current test result value will be EPass.

@return TVerdict code
*/
TVerdict CTRedrawstorePerf::doTestStepL()
	{
	User::LeaveIfError(iWs.Connect());	
	iScreenDevice = new(ELeave) CWsScreenDevice(iWs);
	User::LeaveIfError(iScreenDevice->Construct(0)); // screen number (0 is first screen)
	iGc = new(ELeave) CWindowGc(iScreenDevice);
	User::LeaveIfError(iGc->Construct());
	iWinGroup = RWindowGroup(iWs);
	User::LeaveIfError(iWinGroup.Construct(1, EFalse));

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0137"));
	TestStoreWithFewRectsL();
	RecordTestResultL();
	SetTestStepID(_L("GRAPHICS-UI-BENCH-0167"));
	TestStoreWithManyRectsL();
	RecordTestResultL();
	SetTestStepID(_L("GRAPHICS-UI-BENCH-0139"));
	TestPlaybackWithFewRectsL();
	RecordTestResultL();
	SetTestStepID(_L("GRAPHICS-UI-BENCH-0168"));
	TestPlaybackWithManyRectsL();
	RecordTestResultL();
	SetTestStepID(_L("GRAPHICS-UI-BENCH-0141"));
	TestStoreAndPlaybackWithFewRectsL();
	RecordTestResultL();
	SetTestStepID(_L("GRAPHICS-UI-BENCH-0142"));
	TestStoreAndPlaybackWithManyRectsL();
	RecordTestResultL();
	
	return TestStepResult();
	}

void CTRedrawstorePerf::TestStoringL(const TDesC& aTestName, TRedrawstoreTestCase aTestCase)
	{
	iProfiler->InitResults();
	for (TInt count=0; count<KIterationsToTest; count++)
		{
		CreateRWindowL();
		iWin.SetVisible(EFalse); // To make sure no playing back occurs
		iWs.Finish();		
		iGc->Activate(iWin);
		iProfiler->StartTimer();		
		if (aTestCase==EFragmentStore)
			{
			PopulateRedrawStore();
			}
		else if (aTestCase==EFragmentStoreWithManyRects)
			{
			PopulateRedrawStoreWithManyRects();
			}			
		iProfiler->MarkResultSetL();		
		iGc->Deactivate();	
		iWin.Close();
		}
	iProfiler->ResultsAnalysis(aTestName, 0, 0, iScreenDevice->DisplayMode(), KIterationsToTest);
	}

void CTRedrawstorePerf::TestPlayingbackL(const TDesC& aTestName, TRedrawstoreTestCase aTestCase)
	{
	iProfiler->InitResults();
	for (TInt count=0; count<KIterationsToTest; count++)
		{
		CreateRWindowL();
		iGc->Activate(iWin);
		if (aTestCase==EFragmentStore)
			{
			PopulateRedrawStore();
			}
		else if (aTestCase==EFragmentStoreWithManyRects)
			{
			PopulateRedrawStoreWithManyRects();
			}			
		iWin.SetVisible( EFalse );
		iWs.Finish();		
		iProfiler->StartTimer();
		iWin.SetVisible( ETrue );	// Make iWin visible to trigger playing back of redraw cmds
		iWs.Finish();
		iProfiler->MarkResultSetL();
		iGc->Deactivate();	
		iWin.Close();
		}
	iProfiler->ResultsAnalysis(aTestName, 0, 0, iScreenDevice->DisplayMode(), KIterationsToTest);
	}

void CTRedrawstorePerf::TestStoringAndPlayingbackL(const TDesC& aTestName, TRedrawstoreTestCase aTestCase)
	{
	iProfiler->InitResults();
	for (TInt count=0; count<KIterationsToTest; count++)
		{
		CreateRWindowL();
		iGc->Activate(iWin);
		iProfiler->StartTimer();		
		if (aTestCase==EFragmentStore)
			{
			PopulateRedrawStore();
			}
		else if (aTestCase==EFragmentStoreWithManyRects)
			{
			PopulateRedrawStoreWithManyRects();
			}				
		iWs.Finish();
		iProfiler->MarkResultSetL();
		iGc->Deactivate();	
		iWin.Close();
		}
	iProfiler->ResultsAnalysis(aTestName, 0, 0, iScreenDevice->DisplayMode(), KIterationsToTest);
	}


// Fragments the fullscreen window by creating segments and drawing overlaping rects across the whole window 
void CTRedrawstorePerf::PopulateRedrawStoreWithManyRects()
	{
	iWin.Invalidate();
	iWin.BeginRedraw();
	iGc->SetBrushColor(KRgbCyan);
	iGc->Clear();
	iWin.EndRedraw();

	TInt x=0;
	TBool offset=EFalse;
	for(TInt y=0; y<=seg1.Height(); y+=20)
		{
		if (offset)
			{
			x=x+20;
			offset=EFalse;
			}
		else
			{
			offset=ETrue;
			}
		
		for(; x<=seg1.Width(); x+=40)
			{
			TRect seg(TPoint(x,y),TSize(30,30));
			iWin.Invalidate(seg);
			iWin.BeginRedraw(seg);
			iGc->SetPenColor(KRgbRed);
			iGc->DrawRect(seg);
			iWin.EndRedraw();
			}
		x=0;
		}
	}

void CTRedrawstorePerf::PopulateRedrawStore()
	{
	iWin.Invalidate(seg1);
	iWin.BeginRedraw();
	iGc->SetPenColor(KRgbBlack);
	iGc->Reset();
	iGc->DrawRect(seg1);	
	iWin.EndRedraw();
	
	iWin.Invalidate(seg2);
	iWin.BeginRedraw(seg2);
	iGc->SetPenColor(KRgbBlack);
	iGc->DrawRect(seg2);
	iWin.EndRedraw();	
	
	iWin.Invalidate(seg3);
	iWin.BeginRedraw(seg3);
	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	iGc->SetBrushColor(KRgbBlue);
	iGc->DrawRect(seg3);
	iWin.EndRedraw();
	
	iWin.Invalidate(seg4);
	iWin.BeginRedraw(seg4);
	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	iGc->SetBrushColor(KRgbGreen);
	iGc->DrawRect(seg4);
	iWin.EndRedraw();
		
	iWin.Invalidate(seg5);
	iWin.BeginRedraw(seg5);
	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	iGc->SetBrushColor(KRgbRed);
	iGc->DrawRect(seg5);
	iWin.EndRedraw();	
		
	iWin.Invalidate(seg6);
	iWin.BeginRedraw(seg6);
	iGc->Reset();
	iGc->DrawRect(seg6);
	iWin.EndRedraw();
	}
	
/**
	@SYMTestCaseID
	GRAPHICS-UI-BENCH-0137

	@SYMTestCaseDesc
	The test case mesures the time it takes to store redraw commands  

	@SYMTestActions
	A fullscreen window(RWindow) is created and made invisible. The window is then segmented
 	6 times, drawn to storing the corresponding Redraw Commands and destroyed.

	@SYMTestExpectedResults
	Test should pass and display average test time per iteration
*/
void CTRedrawstorePerf::TestStoreWithFewRectsL()
	{
	_LIT(KTestName, "TestStoreWithFewRectsL");
	TestStoringL(KTestName,EFragmentStore);
	}

/**
	@SYMTestCaseID
	GRAPHICS-UI-BENCH-0167

	@SYMTestCaseDesc
	A pathological test case. It measures the time it takes to store Redraw commands corresponding to 
	hundereds of overlapping segments

	@SYMTestActions
	A fullscreen window(RWindow) is created and made invisible. The window is then segmented
 	a few hundered times, drawn to storing the corresponding Redraw Commands and destroyed.

	@SYMTestExpectedResults
	Test should pass and display average test time per iteration
*/
void CTRedrawstorePerf::TestStoreWithManyRectsL()
	{
	_LIT(KTestName, "TestStoreWithManyRectsL");
	TestStoringL(KTestName,EFragmentStoreWithManyRects);
	}

/**
	@SYMTestCaseID
	GRAPHICS-UI-BENCH-0139

	@SYMTestCaseDesc
	This test case measures the time it takes to play back the commands from the RedrawStore

	@SYMTestActions
	A fullscreen window(RWindow) is created, segmented 6 times and drawn to storing the corresponding
	Redraw Commands. It is made invisible and then visible again which triggers the playing back of 
	commands.The time is measured between when the window is made visible and the screen has been rendered.
	The time is logged and window is destroyed.
	
	@SYMTestExpectedResults
	Test should pass and display average test time per iteration
*/
void CTRedrawstorePerf::TestPlaybackWithFewRectsL()
	{
	_LIT(KTestName, "TestPlaybackWithFewRectsL");
	TestPlayingbackL(KTestName,EFragmentStore);
	}

/**
	@SYMTestCaseID
	GRAPHICS-UI-BENCH-0168

	@SYMTestCaseDesc
	A pathological test case. It measures the time it takes to play back the commands corresponding to 
	hundereds of overlapping segments, from the RedrawStore

	@SYMTestActions
	A fullscreen window(RWindow) is created, segmented a few hundered times and drawn to storing the
	corresponding Redraw Commands. It is made invisible and then visible again which triggers the playing
	back of commands.The time is measured between when the window is made visible and the screen has been
	rendered. The time is logged and window is destroyed.

	@SYMTestExpectedResults
	Test should pass and display average test time per iteration
*/
void CTRedrawstorePerf::TestPlaybackWithManyRectsL()
	{
	_LIT(KTestName, "TestPlaybackWithManyRectsL");
	TestPlayingbackL(KTestName,EFragmentStoreWithManyRects);
	}

/**
	@SYMTestCaseID
	GRAPHICS-UI-BENCH-0141

	@SYMTestCaseDesc
	This test cases measures the time it takes to store and play back redraw commands from the RedrawStore

	@SYMTestActions
	A fullscreen window(RWindow) is created, segmented 6 times and drawn to storing the corresponding
	Redraw Commands. Finish() is called then to trigger the playing back from RedrawStore. The time it takes
	to store and play back commands is logged and window is destroyed. 

	@SYMTestExpectedResults
	Test should pass and display average test time per iteration
*/
void CTRedrawstorePerf::TestStoreAndPlaybackWithFewRectsL()
	{
	_LIT(KTestName, "TestStoreAndPlaybackWithFewRectsL");
	TestStoringAndPlayingbackL(KTestName,EFragmentStore);
	}

/**
	@SYMTestCaseID
	GRAPHICS-UI-BENCH-0142

	@SYMTestCaseDesc
	A pathological test case. It measures the time it takes to store and playback commands corresponding to 
	hundereds of overlapping segments, from RedrawStore

	@SYMTestActions
	A fullscreen window(RWindow) is created, segmented a few hundered times and drawn to storing the
	corresponding Redraw Commands. Finish() is called then to render the screen by playing back the
	commands from the RedrawStore. The time it takes to store and play back commands is logged and window
	is destroyed. 

	@SYMTestExpectedResults
	Test should pass and display average test time per iteration
*/	
void CTRedrawstorePerf::TestStoreAndPlaybackWithManyRectsL()
	{
	_LIT(KTestName, "TestStoreAndPlaybackWithManyRectsL");
	TestStoringAndPlayingbackL(KTestName,EFragmentStoreWithManyRects);
	}