// 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 "tspriteperf.h"

 const TInt KIterationsToTest = 60; 		// Number of iterations to run tests

 RTAnim::RTAnim() : RAnim()

 	{

 	}

 RTAnim::RTAnim(RAnimDll& aDll) : RAnim(aDll)

 	{

 	}

 CTSpritePerf::~CTSpritePerf()

 	{

 	}

 CTSpritePerf::CTSpritePerf()

 	{

 	SetTestStepName(KTSpritePerfName);

 	}

 /**

 Override of base class virtual

 @return - TVerdict code

 */

 TVerdict CTSpritePerf::doTestStepPreambleL()

 	{

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

 	CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();

 	return TestStepResult();

 	}

 TVerdict CTSpritePerf::doTestStepPostambleL()

 	{

 	iWs.Close();

 	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 CTSpritePerf::doTestStepL()

 	{

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0128"));

 	SpriteAnimOverWholeScreenL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0129"));

 	SpriteAnimUnderTranslucentWindowsL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0130"));

 	SpriteAnimWithSemitransparentMaskOverWholeScreenL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0131"));

 	SpriteAnimWithSemitransparentMaskUnderTranslucentWindowsL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0143"));

 	OpaqueFloatingSpriteNonOverlapUpdateAreaL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0144"));

 	SemitransparentFloatingSpriteNonOverlapUpdateAreaL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0145"));

 	OpaqueFloatingSpriteOverlapUpdateAreaL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0146"));

 	SemitransparentFloatingSpriteOverlapUpdateAreaL();

 	RecordTestResultL();

 	return TestStepResult();

 	}

 /** Set up the window server environment and load the animation DLL which will be used for 

   	the sprite performance test cases.

     The RWsSession is connected to the window server, the CWsScreenDevice and the RWindowGroup

     members are constructed. Also the client-side interface to the server-side animation DLL is

     constructed and the animation DLL is loaded. 

  */

 void CTSpritePerf::SetUpWindowEnvironmentL(RAnimDll* aAnimDll)

 	{

 	SetScreenModeL(EColor16MA);

 	if (aAnimDll)

 		{

 		TInt err = aAnimDll->Load(KAnimDLLName);

 		if (err)

 			{

 			INFO_PRINTF3(_L("DLL file %S was not loaded properly, leave with error code %i"),KAnimDLLName,err);

 			User::Leave(err);

 			}

 		}

 	iWsScreenDev = new(ELeave) CWsScreenDevice(iWs);

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

 	TSize screenSize = iWsScreenDev->SizeInPixels();

 	iWinGroup = new(ELeave) RWindowGroup(iWs);

 	User::LeaveIfError(iWinGroup->Construct(reinterpret_cast<TUint32>(iWinGroup),iWsScreenDev));

 	}

 /** Populate the RWindow array member by constructing RWindow objects. Set the background colour of the windows according to the

    	tranparency flag. Make the windows visible, activate them and draw them.

   	@param aUseTransparency the transparency flag of the windows

  */

 void CTSpritePerf::ConstructArrayOfWindowsL(TBool aUseTransparency)

 	{

 	TRect rect(TPoint(0,0),iWsScreenDev->SizeInPixels());

 	TInt i;

 	TUint32 winID;

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

 		{

 		iWins[i]=new(ELeave) RWindow(iWs);

 		winID = reinterpret_cast<TUint32>(iWinGroup+i+1);

 		if (i==0)

 			User::LeaveIfError(iWins[i]->Construct(*iWinGroup,winID)); //iWinGroup is the parent of iWins[0]

 		else

 			User::LeaveIfError(iWins[i]->Construct(*iWins[0],winID)); //iWins[0] is the the parent for every subsequent window

 		rect.Resize(-rect.Width()/10,-rect.Height()/10);

 		iWins[i]->SetExtent(TPoint(0,0),rect.Size());

 		if (aUseTransparency)

 			{	

 			iWins[i]->SetTransparencyAlphaChannel();

 			iBackColour[i]= TRgb(240,(200*i)/ENumWins,170-(20*i)/ENumWins,(60*(i+1))/ENumWins); //assign a different background colour to each window in a pseudo-random manner

 			iWins[i]->SetBackgroundColor(iBackColour[i]); //semi-transparent window (R,G,B,Alpha)

 			}

 		else

 			{

 			iBackColour[i]= TRgb(180,(200*i)/ENumWins,170-(20*i)/ENumWins,255);

 			iWins[i]->SetBackgroundColor(iBackColour[i]); //opaque window

 			}

 		iWins[i]->SetVisible(ETrue);

 		iWins[i]->Activate();	

 		iWins[i]->Invalidate();

 		iWins[i]->BeginRedraw();

 		iWins[i]->EndRedraw();

 		}

 	iWs.Flush();

 	iWs.Finish();

 	}

 /** Release the resources that the window server environment, the window construction and the client-side

   	interface to animation DLL have allocated.

  */

 void CTSpritePerf::ReleaseWindowsAndEnvironment()

 	{

 	for (TInt i=0;i<ENumWins;++i)

 		{

 		if (iWins[i])

 			iWins[i]->Close();

 		delete iWins[i];

 		iWins[i]=NULL;

 		}

 	if(iWinGroup)

 		iWinGroup->Close();

 	delete iWinGroup;

 	iWinGroup=NULL;

 	delete iWsScreenDev;

 	iWsScreenDev=NULL;

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0128

 @SYMPREQ PREQ1841

 @SYMTestCaseDesc

 Tests how long it takes to draw the bitmap of a sprite over the whole screen

 @SYMTestActions

 Set up the window server environment, load the animation DLL and construct an array of opaque windows.

 Construct an opaque sprite having the window group as parent. Append a single member (appropriately initialised) to it 

 and construct a sprite animation linked to the sprite. Over a specific number of iterations perform some 

 draw operations on the sprite animation. Record the time the draw requests and the actual drawing require 

 and release the resources.

 @SYMTestExpectedResults

 Test should pass and display average test time per iteration

 */

 void CTSpritePerf::SpriteAnimOverWholeScreenL()

 	{

 	_LIT(KTestName, "SpriteAnimOverWholeScreenL");

 	SpriteAnimTestL(KTestName, ETrue, EFalse);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0129

 @SYMPREQ PREQ1841

 @SYMTestCaseDesc

 Tests how long it takes to draw the bitmap of a sprite under transparent windows

 @SYMTestActions

 Set up the window server environment, load the animation DLL and construct an array of translucent windows.

 Construct an opaque sprite having the bottom window as parent. Append a single member (appropriately initialised) to it.

 and construct a sprite animation linked to the sprite. Over a specific number of iterations perform some draw 

 operations on the sprite animation. Record the time the draw requests and the actual drawing require and release the

 resources.

 @SYMTestExpectedResults

 Test should pass and display average test time per iteration

 */

 void CTSpritePerf::SpriteAnimUnderTranslucentWindowsL()

 	{

 	_LIT(KTestName, "SpriteAnimUnderTranslucentWindowsL");

 	SpriteAnimTestL(KTestName, EFalse, EFalse);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0130

 @SYMPREQ PREQ1841

 @SYMTestCaseDesc

 Tests how long it takes to draw the bitmap of a sprite over the whole screen, when the bitmap mask is partially transparent

 @SYMTestActions

 Set up the window server environment, load the animation DLL and construct an array of opaque windows.

 Construct a semitransparent sprite having the window group as parent. Append a single member (appropriately initialised)

 to it and construct a sprite animation linked to the sprite. Over a specific number of iterations perform some draw

 operations on the sprite animation. Record the time the draw requests and the actual drawing require and release the resources.

 @SYMTestExpectedResults

 Test should pass and display average test time per iteration

 */

 void CTSpritePerf::SpriteAnimWithSemitransparentMaskOverWholeScreenL()

 	{

 	_LIT(KTestName, "SpriteAnimWithSemitransparentMaskOverWholeScreenL");

 	SpriteAnimTestL(KTestName, ETrue, ETrue);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0131

 @SYMPREQ PREQ1841

 @SYMTestCaseDesc

 Tests how long it takes to draw the bitmap of a sprite under translucent windows,  when the bitmap mask is partially transparent

 @SYMTestActions

 Set up the window server environment, load the animation DLL and construct an array of translucent windows.

 Construct a semitransparent sprite having the bottom window as parent. Append a single member (appropriately initialised)

 to it and construct a sprite animation linked to the sprite. Over a specific number of iterations perform some draw

 operations on the sprite animation. Record the time the draw requests and the actual drawing require and release the resources.

 @SYMTestExpectedResults

 Test should pass and display average test time per iteration

 */

 void CTSpritePerf::SpriteAnimWithSemitransparentMaskUnderTranslucentWindowsL()

 	{

 	_LIT(KTestName, "SpriteAnimWithSemitransparentMaskUnderTranslucentWindowsL");

 	SpriteAnimTestL(KTestName, EFalse, ETrue);

 	}

 static void CleanupWindows(TAny* aPtr)

 	{

 	RWindow** wins = static_cast<RWindow**>(aPtr);

 	for (TInt i=0;i<CTSpritePerf::ENumWins;++i)

 		{

 		if (wins[i])

 			{

 			wins[i]->Close();

 			delete wins[i];

 			wins[i]=NULL;

 			}

 		}

 	}

 static void CleanupWindowGroup(TAny* aPtr)

 	{

 	RWindowGroup** windowGroup = static_cast<RWindowGroup**>(aPtr);

 	if (*windowGroup)

 		{

 		(*windowGroup)->Close();

 		delete *windowGroup;

 		*windowGroup=NULL;

 		}

 	}

 static void CleanupScreenDevice(TAny* aPtr)

 	{

 	CWsScreenDevice** screenDevice = static_cast<CWsScreenDevice**>(aPtr);

 	delete *screenDevice;

 	*screenDevice=NULL;	

 	}

 /*

    Set up the window server environment, load the animation DLL and construct an array of (opaque/translucent) windows.

    Construct an opaque/semitransparent sprite with a single member, initialise it and construct a sprite animation linked to the sprite. 

    Over a specific number of iterations perform some draw operations on the sprite animation. Record the time 

    the draw requests and the actual drawing require and release the resources.

    @param aTestName the name of the test case

    @param aOverWholeScreen the flag deciding whether the windows are opaque or tranparent and thus deciding whether 

   		  the sprite is drawn over the whole screen or under transparent windows

    @param aTransparentMask the transparency flag of the sprite bitmap mask

  */

 void CTSpritePerf::SpriteAnimTestL(const TDesC& aTestName,TBool aOverWholeScreen, TBool aTransparentMask)

 	{

 	RAnimDll animDll(iWs);

 	CleanupClosePushL(animDll);

 	TCleanupItem cleanupScreenDevice(CleanupScreenDevice,&iWsScreenDev);

 	CleanupStack::PushL(cleanupScreenDevice);

 	TCleanupItem cleanupWindowGroup(CleanupWindowGroup,&iWinGroup);

 	CleanupStack::PushL(cleanupWindowGroup);

 	SetUpWindowEnvironmentL(&animDll);

 	TCleanupItem cleanupWindows(CleanupWindows,iWins);

 	CleanupStack::PushL(cleanupWindows);

 	ConstructArrayOfWindowsL(!aOverWholeScreen);

 	RWsSprite sprite(iWs);

 	CleanupClosePushL(sprite);

 	if (aOverWholeScreen)

 		User::LeaveIfError(sprite.Construct(*iWinGroup,TPoint(10,10),ESpriteNoChildClip));

 	else

 		User::LeaveIfError(sprite.Construct(*iWins[0],TPoint(10,10),ESpriteNoChildClip));

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

 	CleanupStack::PushL(bitmap);

 	User::LeaveIfError(bitmap->Create(TSize(40,42),EColor16MA));

 	CFbsBitmap* bitmap2 = NULL; //used as bitmap mask for sprite member of opaque sprite 

 	CFbsBitmap* bitmap3 = NULL; //used as bitmap mask for sprite member of semitransparent sprite 

 	if (!aTransparentMask)

 		{ 

 		//opaque sprite uses a bitmap mask set to white

 		bitmap2=new(ELeave) CFbsBitmap();

 		CleanupStack::PushL(bitmap2);

 		User::LeaveIfError(bitmap2->Create(TSize(40,42),EColor16MA));

 		}

 	else	

 		{ 

 		//semitransparent sprite uses a bitmap mask, in which 

 		// *the bottom right quarter is set to black making the sprite fully transparent in this area

 		// *the remaining region is set to a gray shade allowing the sprite to be semitransparent in this area

 		bitmap3=new(ELeave) CFbsBitmap();

 		CleanupStack::PushL(bitmap3);

 		User::LeaveIfError(bitmap3->Create(TSize(40,42),EColor16MA));

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

 		CleanupStack::PushL(device);

 		CFbsBitGc *gc;

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

 		CleanupStack::PushL(gc);

 		gc->SetBrushStyle(CGraphicsContext::ESolidBrush);

 		gc->SetPenSize(TSize());

 		TSize bitmapSize=bitmap3->SizeInPixels();

 		TSize size=bitmapSize;

 		size.SetSize(size.iWidth/2,size.iHeight/2);

 		TPoint point=size.AsPoint();

 		gc->SetBrushColor(TRgb(128,128,128));

 		gc->DrawRect(TRect(TPoint(),bitmapSize));

 		gc->SetBrushColor(TRgb(0,0,0));

 		gc->DrawRect(TRect(point,size));

 		}

 	TSpriteMember member;

 	member.iBitmap=bitmap;

 	if (aTransparentMask)

 		member.iMaskBitmap=bitmap3;

 	else

 		member.iMaskBitmap=bitmap2;

 	member.iInvertMask=EFalse;

 	member.iDrawMode=CGraphicsContext::EDrawModePEN;

 	member.iOffset=TPoint();

 	member.iInterval=TTimeIntervalMicroSeconds32(200000);

 	sprite.AppendMember(member);

 	RTAnim spriteAnim(animDll);

 	CleanupClosePushL(spriteAnim);

 	TPtrC8 des(NULL,0);

 	TPoint pos(10,20);

 	User::LeaveIfError(spriteAnim.Construct(sprite,ESpriteAnimType,des));

 	User::After(500000);

 	iProfiler->InitResults();

 	for (TInt count=KIterationsToTest; count>=0; --count)

 		{

 		iProfiler->StartTimer();

 		// draw on sprite member's bitmap and update the sprite member

 		spriteAnim.Command(EADllDraw1);

 		spriteAnim.Command(EADllDraw2);

 		spriteAnim.Command(EADllDraw3);

 		iWs.Flush();

 		iProfiler->MarkResultSetL();

 		User::After(100000);

 		spriteAnim.Command(EADllDrawBlank);

 		iWs.Flush();

 		User::After(100000);

 		}

 	iProfiler->ResultsAnalysis(aTestName, 0, EColor16MA, EColor16MA, KIterationsToTest);

 	if (!aTransparentMask)

 		CleanupStack::PopAndDestroy(4); //sprite, bitmaps (2), testanim

 	else

 		CleanupStack::PopAndDestroy(6); //sprite, bitmaps (2), device, gc, testanim

 	CleanupStack::Pop(3); //cleanup items(3)

 	CleanupStack::PopAndDestroy(1); //anim Dll

 	ReleaseWindowsAndEnvironment();

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0143

 @SYMPREQ PREQ1841

 @SYMTestCaseDesc

 Tests how long it takes to draw the bitmap of an opaque sprite, when it lies over an area that is not updated.

 @SYMTestActions

 Set up the window server environment and construct an array of opaque windows.

 Construct an opaque floating sprite and place it over an area that will not be followingly updated.

 Append a single member to it. Over a specific number of iterations update a screen area. Record the time

 the actual drawing requires and release the resources.

 @SYMTestExpectedResults

 Test should pass and display average test time per iteration

 */

 void CTSpritePerf::OpaqueFloatingSpriteNonOverlapUpdateAreaL()

 	{

 	_LIT(KTestName, "OpaqueFloatingSpriteNonOverlapUpdateAreaL");

 	FloatingSpriteTestL(KTestName, ETrue, EFalse);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0144

 @SYMPREQ PREQ1841

 @SYMTestCaseDesc

 Tests how long it takes to draw the bitmap of a semitransparent sprite, when it lies over an area that is not updated.

 @SYMTestActions

 Set up the window server environment and construct an array of opaque windows.

 Construct a semitransparent floating sprite and place it over an area that will not be followingly updated.

 Append a single member to it. Over a specific number of iterations update a screen area. Record the time

 the actual drawing requires and release the resources.

 @SYMTestExpectedResults

 Test should pass and display average test time per iteration

 */

 void CTSpritePerf::SemitransparentFloatingSpriteNonOverlapUpdateAreaL()

 	{

 	_LIT(KTestName, "SemitransparentFloatingSpriteNonOverlapUpdateAreaL");

 	FloatingSpriteTestL(KTestName, EFalse, EFalse);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0145

 @SYMPREQ PREQ1841

 @SYMTestCaseDesc

 Tests how long it takes to draw the bitmap of an opaque sprite, when it lies over an area that is updated.

 @SYMTestActions

 Set up the window server environment and construct an array of opaque windows.

 Construct an opaque floating sprite and place it over an area that will be followingly updated.

 Append a single member to it. Over a specific number of iterations update a screen area. Record the time

 the actual drawing requires and release the resources.

 @SYMTestExpectedResults

 Test should pass and display average test time per iteration

 */

 void CTSpritePerf::OpaqueFloatingSpriteOverlapUpdateAreaL()

 	{

 	_LIT(KTestName, "OpaqueFloatingSpriteOverlapUpdateAreaL");

 	FloatingSpriteTestL(KTestName, ETrue, ETrue);

 	}

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0146

 @SYMPREQ PREQ1841

 @SYMTestCaseDesc

 Tests how long it takes to draw the bitmap of a semitransparent sprite, when it lies over an area that is updated.

 @SYMTestActions

 Set up the window server environment and construct an array of opaque windows.

 Construct a semitransparent floating sprite and place it over an area that will be followingly updated.

 Append a single member to it. Over a specific number of iterations update a screen area. Record the time

 the actual drawing requires and release the resources.

 @SYMTestExpectedResults

 Test should pass and display average test time per iteration

 */

 void CTSpritePerf::SemitransparentFloatingSpriteOverlapUpdateAreaL()

 	{

 	_LIT(KTestName, "SemitransparentFloatingSpriteOverlapUpdateAreaL");

 	FloatingSpriteTestL(KTestName, EFalse, ETrue);

 	}

 /*

    Set up the window server environment and construct an array of opaque windows.

    Construct an opaque/semitransparent sprite attached to the window group, thus being a floating sprite.

    Append a single member to the sprite. Over a specific number of iterations update a screen area by rotating

    the background colour of the windows (excluding top window). Record the time the actual drawing requires

    in total (for redrawing the windows and the sprite) and release the resources.

    @param aTestName the name of the test case

    @param aIsOpaqueSprite the flag deciding whether the sprite is opaque or semitranparent

    @param aOverlapUpdateArea the flag deciding whether the sprite overlaps the update area or not

  */

 void CTSpritePerf::FloatingSpriteTestL(const TDesC& aTestName, TBool aIsOpaqueSprite, TBool aOverlapUpdateArea)

 	{

 	TCleanupItem cleanupScreenDevice(CleanupScreenDevice,&iWsScreenDev);

 	CleanupStack::PushL(cleanupScreenDevice);

 	TCleanupItem cleanupWindowGroup(CleanupWindowGroup,&iWinGroup);

 	CleanupStack::PushL(cleanupWindowGroup);

 	SetUpWindowEnvironmentL(NULL);

 	TCleanupItem cleanupWindows(CleanupWindows,iWins);

 	CleanupStack::PushL(cleanupWindows);

 	ConstructArrayOfWindowsL(EFalse);

 	RWsSprite sprite(iWs);

 	CleanupClosePushL(sprite);

 	TPoint point=TPoint();

 	if (aOverlapUpdateArea)

 		{

 		//sprite is set to be right over the area off the top window, where the other windows overlap

 		TSize topWinSize= iWins[ENumWins-1]->Size();

 		point=TPoint(0,topWinSize.iHeight);

 		}

 	User::LeaveIfError(sprite.Construct(*iWinGroup,point,ESpriteNoChildClip));

 	CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

 	CleanupStack::PushL(bitmap);

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

 	User::LeaveIfError(bitmap->Load(TEST_BITMAP_NAME,0));

 	TSize bitmapSize=bitmap->SizeInPixels();

 	CFbsBitmap* bitmap2 = new(ELeave) CFbsBitmap;

 	CleanupStack::PushL(bitmap2);

 	User::LeaveIfError(bitmap2->Create(bitmapSize, iWsScreenDev->DisplayMode())); //blank bitmap

 	TSpriteMember member;

 	member.iBitmap=bitmap;

 	if (aIsOpaqueSprite)

 		member.iMaskBitmap=bitmap2;

 	else

 		member.iMaskBitmap=bitmap;

 	member.iInvertMask=EFalse;

 	member.iDrawMode=CGraphicsContext::EDrawModePEN;

 	member.iOffset=TPoint();

 	member.iInterval=TTimeIntervalMicroSeconds32(200000);

 	User::LeaveIfError(sprite.AppendMember(member));

 	User::LeaveIfError(sprite.Activate());  //make the sprite visible

 	User::After(1000000);

 	iProfiler->InitResults();

 	for (TInt count=KIterationsToTest; count>=0; --count)

 		{

 		iProfiler->StartTimer();

 		//cause a screen area to be updated by rotating the background colour of the windows in the array 

 		//apart from the colour of the top window  

 		for (TInt i=0;i<ENumWins-1;i++)

 			{

 			TRgb tempBackColour = iBackColour[0];

 			if (i!=ENumWins-1)

 				iBackColour[i]=iBackColour[(i+1)%(ENumWins-1)];

 			else

 				iBackColour[ENumWins-2]=tempBackColour;

 			iWins[i]->SetBackgroundColor(iBackColour[i]);

 			iWins[i]->Invalidate();

 			iWins[i]->BeginRedraw();

 			iWins[i]->EndRedraw();

 			}

 		iWs.Flush();

 		iWs.Finish();

 		iProfiler->MarkResultSetL();

 		User::After(100000);

 		}

 	iProfiler->ResultsAnalysis(aTestName, 0, EColor16MA, EColor16MA, KIterationsToTest);

 	CleanupStack::PopAndDestroy(3); //sprite, bitmaps(2)

 	CleanupStack::Pop(3); //cleanup items(3)

 	ReleaseWindowsAndEnvironment();

 	}