--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tauto/tdrawresource.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1144 @@
+// 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 "tdrawresource.h"
+#include <graphics/sgimage.h>
+#include <graphics/sgutils.h>
+#include <graphics/directgdidrawablesource.h>
+#include <graphics/sgresourceinternal.h>
+#include <graphics/wsdrawresource.h>
+
+
+__WS_CONSTRUCT_STEP__(DrawResource);
+
+
+#if defined(__X86GCC__)
+extern "C" TInt atexit(void (*function)(void))
+	{
+	return KErrNone;
+	}
+#endif
+
+//
+// class CTestWsGraphicsContext
+//
+CTestWsGraphicsContext* CTestWsGraphicsContext::NewL(RDirectGdiImageTarget& aTarget)
+	{
+	CTestWsGraphicsContext* self = new(ELeave) CTestWsGraphicsContext;
+	CleanupStack::PushL(self);
+	self->ConstructL(aTarget);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+void CTestWsGraphicsContext::ConstructL(RDirectGdiImageTarget& aTarget)
+	{
+	CDirectGdiDriver* driver = CDirectGdiDriver::Static();
+	User::LeaveIfNull(driver);
+	iContext = CDirectGdiContext::NewL(*driver);
+	TInt err = iContext->Activate(aTarget);
+	User::LeaveIfError(err);
+	}
+
+CTestWsGraphicsContext::~CTestWsGraphicsContext()
+	{
+	delete iContext;
+	}
+
+TAny* CTestWsGraphicsContext::ResolveObjectInterface(TUint aTypeId)
+	{
+	switch(aTypeId)
+		{
+	case MWsDrawableSourceProvider::EWsObjectInterfaceId:
+		return static_cast<MWsDrawableSourceProvider*>(this);
+		}
+	return NULL;
+
+	}
+	
+TInt CTestWsGraphicsContext::CreateDrawableSource(const TSgDrawableId& aDrawableId, TAny*& aSource)
+	{
+	TRAPD(err, DoCreateDrawableSourceL(aDrawableId, aSource));
+	return err;
+	}
+
+void CTestWsGraphicsContext::DoCreateDrawableSourceL(const TSgDrawableId& aDrawableId, TAny*& aSource)
+	{
+	CDirectGdiDriver* driver = CDirectGdiDriver::Static();
+	if (!driver)
+		{
+		User::Leave(KErrNotReady);
+		}
+	RDirectGdiDrawableSource* drawableSource = new(ELeave) RDirectGdiDrawableSource(*driver);
+	CleanupStack::PushL(drawableSource);
+	RSgDrawable drawable;
+	User::LeaveIfError(drawable.Open(aDrawableId, ESgDoNotRestrictUsage));
+	CleanupClosePushL(drawable);
+	User::LeaveIfError(drawableSource->Create(drawable));
+	CleanupStack::PopAndDestroy();
+	CleanupStack::Pop(drawableSource);
+	aSource = drawableSource;
+	}
+
+void CTestWsGraphicsContext::CloseDrawableSource(TAny* aSource)
+	{
+	RDirectGdiDrawableSource* drawableSource = static_cast<RDirectGdiDrawableSource*>(aSource);
+	drawableSource->Close();
+	delete drawableSource;
+	}
+
+void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TPoint& aPos, CWindowGc::TGraphicsRotation aRotation)
+	{
+	const RDirectGdiDrawableSource* drawableSource = static_cast<const RDirectGdiDrawableSource*>(aSource);
+	iContext->DrawResource(aPos, *drawableSource, (DirectGdi::TGraphicsRotation)aRotation);
+	iPos = aPos;
+	iRotation = (DirectGdi::TGraphicsRotation)aRotation;
+	}
+
+void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TRect& aRect, CWindowGc::TGraphicsRotation aRotation)
+	{
+	const RDirectGdiDrawableSource* drawableSource = static_cast<const RDirectGdiDrawableSource*>(aSource);
+	iContext->DrawResource(aRect, *drawableSource, (DirectGdi::TGraphicsRotation)aRotation);
+	iDestRect = aRect;
+	iRotation = (DirectGdi::TGraphicsRotation)aRotation;
+	}
+
+void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TRect& aRectDest, const TRect& aRectSrc, CWindowGc::TGraphicsRotation aRotation)
+	{
+	const RDirectGdiDrawableSource* drawableSource = static_cast<const RDirectGdiDrawableSource*>(aSource);
+	iContext->DrawResource(aRectDest, *drawableSource, aRectSrc, (DirectGdi::TGraphicsRotation)aRotation);
+	iDestRect = aRectDest;
+	iSrcRect = aRectSrc;
+	iRotation = (DirectGdi::TGraphicsRotation)aRotation;
+	}
+
+void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TRect& aRect, const TDesC8& aParam)
+	{
+	const RDirectGdiDrawableSource* drawableSource = static_cast<const RDirectGdiDrawableSource*>(aSource);
+	iContext->DrawResource(aRect, *drawableSource, aParam);
+	iDestRect = aRect;
+	}
+
+
+void CTestWsGraphicsContext::Clear()
+	{
+	iContext->Clear();
+	}
+
+//
+// class CTDrawResource
+//
+
+CTDrawResource::CTDrawResource(CTestStep* aStep)
+	: CTWsGraphicsBase(aStep)
+	{
+	}
+
+CTDrawResource::~CTDrawResource()
+	{
+	iWindow.Close();
+	delete iRefBitmap;
+	delete iRotatedRefBitmap;
+	delete iScaledBitmap;
+	delete iScaledCroppedBitmap;
+	delete iCopyBitmap;
+	delete iBitmapWrongScreenNumber;
+
+	delete iWsGrapicResolver;
+	delete iGraphicsCon;
+
+	iWsDrawableSource.Close();
+	iImage.Close();
+	iImageTarget.Close();
+	iImageCollection.Close();
+
+	CDirectGdiDriver* dGdiDriver = CDirectGdiDriver::Static();
+	if(dGdiDriver)
+		{
+		dGdiDriver->Close();
+		}
+	SgDriver::Close();
+	}
+
+void CTDrawResource::ConstructL()
+	{
+	//Constrcut and setup window to be drawn to
+	iWindow = RWindow(TheClient->iWs);
+    User::LeaveIfError(iWindow.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle));
+    TSize iWinSize=TSize(TheClient->iScreen->SizeInPixels());
+    iWindow.SetExtent(TPoint(0,0),iWinSize);
+	iWindow.Activate();
+	iWindow.BeginRedraw();
+	iWindow.EndRedraw();
+	
+	//Creates all reference and copy bitmaps required for all tests
+	CreateReferenceAndCopyBitmapsL();
+
+	TInt err = CDirectGdiDriver::Open();
+	User::LeaveIfError(err);
+	err = SgDriver::Open();
+	User::LeaveIfError(err);
+	
+	//create image target
+	CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static();
+	if(!theDGdiDriver)
+		{
+		User::Leave(KErrNotReady);
+		}
+	TSgImageInfo info;
+	info.iUsage = ESgUsageDirectGdiTarget | ESgUsageDirectGdiSource | ESgUsageCompositionSource;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iSizeInPixels = TSize(200, 200);
+	info.iShareable = ETrue;
+	const TInt KImageCount = 1;
+	err = iImageCollection.Create(info, KImageCount);
+	User::LeaveIfError(err);
+	
+	err = iImageCollection.OpenImage(0, iImage);
+	User::LeaveIfError(err);
+	iImageTarget = RDirectGdiImageTarget(*theDGdiDriver);
+	err = iImageTarget.Create(iImage);
+	User::LeaveIfError(err);
+	
+	// construction of image source
+	RSgImage sgImage;
+	CreateSgImageFromBitmapL(sgImage);
+	CleanupClosePushL(sgImage);
+	iWsDrawableSource = RWsDrawableSource(TheClient->iWs);
+	User::LeaveIfError(iWsDrawableSource.Create(sgImage, TheClient->iScreen->GetScreenNumber()));
+	
+    //Create dummy MWsGraphicResolver - required RemoteGc testing
+	iWsGrapicResolver = new (ELeave) CWSGraphicsRes();
+	
+	//Create dummy MWsGraphicsContext - required RemoteGc testing
+	iGraphicsCon =  CTestWsGraphicsContext::NewL(iImageTarget);
+	
+	CleanupStack::PopAndDestroy(&sgImage);
+	}
+
+void CTDrawResource::RunTestCaseL(TInt aCurTestCase)
+	{	
+	((CTDrawResourceStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
+	switch(aCurTestCase)
+		{
+	case 1:		
+		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0001"));
+		INFO_PRINTF1(_L("DrawResourcePos Test"));		
+		TestDrawResourcePos();
+		break;
+	case 2:
+		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0002"));
+		INFO_PRINTF1(_L("DrawResourceRect Test"));	
+		TestDrawResourceRect();
+		break;
+	case 3:
+		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0003"));
+		INFO_PRINTF1(_L("DrawResourceScale Test"));		
+		TestDrawResourceScale();
+		break;
+	case 4:
+		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0004"));
+		INFO_PRINTF1(_L("RWsDrawableSource Reference Counting Test"));		
+		TestRWsDrawableSourceReferenceCountingL();
+		break;	
+	case 5:
+		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0005"));
+		INFO_PRINTF1(_L("RemoteGcDrawResourcePos Test"));	
+		TestRemoteGcDrawResourcePosL();
+		break;
+	case 6:
+		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0006"));
+		INFO_PRINTF1(_L("RemoteGcDrawResourceRect Test"));	
+		TestRemoteGcDrawResourceRectL();
+		break;
+	case 7:
+		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0007"));
+		INFO_PRINTF1(_L("RemoteGcDrawResourceScale Test"));	
+		TestRemoteGcDrawResourceScaleL();
+		break;
+	case 8:
+		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0008"));
+		INFO_PRINTF1(_L("DrawResourceScreens Test"));	
+		TestDrawResourceScreensL();
+		break;
+	case 9:
+		((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-TestCopyScreenToBitmapWithDifferentDisplayModes-0001"));
+		INFO_PRINTF1(_L("CopyScreenToBitmapWithDifferentDisplayModes Test\n"));
+		TestCopyScreenToBitmapWithDifferentDisplayModesL();
+		break;
+	case 10:
+		((CTDrawResourceStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+		((CTDrawResourceStep*)iStep)->CloseTMSGraphicsStep();
+		INFO_PRINTF1(_L("Test complete\n"));
+		TestComplete();
+		break;
+		}
+	((CTDrawResourceStep*)iStep)->RecordTestResultL();
+	}
+
+/**
+@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0001
+@SYMPREQ                 PREQ2095
+@SYMTestPriority         High
+@SYMTestCaseDesc         Draw RSgImage using DrawResource(const TPoint&, const RWsDrawableSource&, TGraphicsRotation)
+@SYMTestActions          Draw to position (0,0) with default rotation (none)
+						 Draw to position (10,10) with 90 degrees rotation 
+@SYMTestExpectedResults  Drawn images should match reference CFbsBitmap
+*/
+void CTDrawResource::TestDrawResourcePos()
+	{
+	// Draw to TPoint(0,0) with EGraphicsRotationNone
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	MWsDrawResource* dr = static_cast<MWsDrawResource*>(TheGc->Interface(KMWsDrawResourceInterfaceUid));
+	TEST(dr != NULL);
+	dr->DrawResource(KDestPoint, iWsDrawableSource, CWindowGc::EGraphicsRotationNone);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();  
+	TheClient->WaitForRedrawsToFinish();
+
+	//Copy the screen to the copy bitmap
+	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);
+
+	//Compare the bitmaps
+	INFO_PRINTF1(_L("Draw to TPoint(0,0) with EGraphicsRotationNone"));
+	TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iRefBitmap);
+	TEST(compRes);
+
+	/*** Draw to position (10,10) with 90 degrees rotation ***/
+	TPoint const KDestPoint2(10,10);
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+    TheGc->Clear();
+	dr->DrawResource(KDestPoint2, iWsDrawableSource, KTestRotation);
+    TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish(); 
+	TheClient->WaitForRedrawsToFinish();
+
+	//Copy the screen to the copy bitmap
+	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, TRect(KDestPoint2, KSourceSize));
+
+	//Compare the bitmaps
+	INFO_PRINTF1(_L("Draw to position (10,10) with 90 degrees rotation"));
+	compRes = CompareBitmapsByPixel(iCopyBitmap, iRotatedRefBitmap);
+	TEST(compRes);
+	}
+
+/**
+@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0002
+@SYMPREQ                 PREQ2095
+@SYMTestPriority         High
+@SYMTestCaseDesc         Draw RSgImage using DrawResource(const TRect& , const RWsDrawableSource&, TGraphicsRotation aRotation)
+@SYMTestActions          Draw to rect pos (10,10), rect size (60,60) with 90 degrees rotation
+@SYMTestExpectedResults  Drawn images should match the reference CFbsBitmap
+*/
+void CTDrawResource::TestDrawResourceRect()
+	{
+	//Use DrawResource
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	MWsDrawResource* dr = static_cast<MWsDrawResource*>(TheGc->Interface(KMWsDrawResourceInterfaceUid));
+	TEST(dr != NULL);
+	dr->DrawResource(KDestRect, iWsDrawableSource, KTestRotation);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();  
+	TheClient->WaitForRedrawsToFinish();
+
+	//Copy the screen to the copy bitmap
+	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);
+
+	//Compare the bitmaps
+	INFO_PRINTF1(_L("Draw to rect pos (10,10), rect size (60,60) with 90 degrees rotation"));
+	TInt compRes = CompareBitmapsByPixel(iCopyBitmap, iScaledBitmap);
+	TEST(compRes);
+	}
+
+/**
+@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0003
+@SYMPREQ                 PREQ2095
+@SYMTestPriority         High
+@SYMTestCaseDesc         Draw RSgImage using DrawResource(const TRect& , const RWsDrawableSource&, const TRect&, TGraphicsRotation aRotation)
+@SYMTestActions          Draw the part of the source image (rect Pos (0,0), rect size(50,50))
+						 to rect pos(10,10), rect size(60,60) and and 90 degrees rotation
+@SYMTestExpectedResults  Drawn images should match the reference CFbsBitmap
+*/
+void CTDrawResource::TestDrawResourceScale()
+	{
+	//Use DrawResource
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	MWsDrawResource* dr = static_cast<MWsDrawResource*>(TheGc->Interface(KMWsDrawResourceInterfaceUid));
+	TEST(dr != NULL);
+	dr->DrawResource(KDestRect, iWsDrawableSource, KSourceRect, KTestRotation);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();  
+	TheClient->WaitForRedrawsToFinish();
+
+	//Copy the screen to the copy bitmap
+	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);
+
+	//Compare the bitmaps
+	INFO_PRINTF1(_L("Draw the part of the source image to rect pos(10,10), rect size(60,60) and and 90 degrees rotation"));
+	TInt compRes = CompareBitmapsByPixel(iCopyBitmap, iScaledCroppedBitmap);
+	TEST(compRes);
+	}
+
+/**
+@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0004
+@SYMPREQ                 PREQ2095
+@SYMTestPriority         High
+@SYMTestCaseDesc         Draw RSgImage using DrawResource(const TPoint&, const RWsDrawableSource&, TGraphicsRotation) after closing the image source
+@SYMTestActions          Draw to position (0,0) with default rotation (none) after closing the image source
+@SYMTestExpectedResults  Drawn image should match reference CFbsBitmap
+*/
+void CTDrawResource::TestRWsDrawableSourceReferenceCountingL()
+	{	
+	// construction of image source
+	RSgImage sgImage;
+	CreateSgImageFromBitmapL(sgImage);
+	CleanupClosePushL(sgImage);
+	RWsDrawableSource drawableSource(TheClient->iWs);
+	CleanupClosePushL(drawableSource);
+	User::LeaveIfError(drawableSource.Create(sgImage, TheClient->iScreen->GetScreenNumber())); 
+
+	//Draw using DrawResource
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	MWsDrawResource* dr = static_cast<MWsDrawResource*>(TheGc->Interface(KMWsDrawResourceInterfaceUid));
+	TEST(dr != NULL);
+	dr->DrawResource(KDestPoint, drawableSource, CWindowGc::EGraphicsRotationNone);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+
+	//Close the image source but this should not stop the source from being drawn 
+	drawableSource.Close();
+	TheClient->iWs.Finish();
+	TheClient->WaitForRedrawsToFinish();
+
+	//Copy the screen to the copy bitmap
+	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);
+
+	//Compare the bitmaps
+	INFO_PRINTF1(_L("Draw to TPoint(0,0) with EGraphicsRotationNone"));
+	TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iRefBitmap);
+	TEST(compRes);
+
+	CleanupStack::PopAndDestroy(2, &sgImage);
+	}
+
+/**
+@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0005
+@SYMPREQ                 PREQ2095
+@SYMTestPriority         High
+@SYMTestCaseDesc         Draw RSgImage using RemotGc->DrawResource(const TPoint&, const RWsDrawableSource&, TGraphicsRotation)
+@SYMTestActions          Record the draw resource commands using CRemoteGc and play the recorded commands on a window using
+ 						 Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&) and then play the recorded commands using . 
+						 Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&).
+@SYMTestExpectedResults  Drawn images should match reference CFbsBitmap and also values received by MWsGraphicsContext should 
+ 						 match what was originally sent to DrawResource.
+*/
+void CTDrawResource::TestRemoteGcDrawResourcePosL()
+	{
+	const TRect KRemotGcSourceRect(0, 0, iWindow.Size().iWidth, iWindow.Size().iHeight);
+	const TRegionFix<1> KClippingRegion(KRemotGcSourceRect);
+	CWindowGc::TGraphicsRotation testRotation= CWindowGc::EGraphicsRotationNone;
+	
+	//Create remote gc - required RemoteGc testing
+	CRemoteGc* remoteGc = CRemoteGc::NewL(TheClient->iScreen);
+	CleanupStack::PushL(remoteGc);
+
+	//Record draw messages
+	remoteGc->ResetCommandBuffer();
+	remoteGc->BeginDraw(KRemotGcSourceRect);
+	MWsDrawResource* dr = static_cast<MWsDrawResource*>(remoteGc->Interface(KMWsDrawResourceInterfaceUid));
+	TEST(dr != NULL);
+	dr->DrawResource(KDestPoint, iWsDrawableSource, CWindowGc::EGraphicsRotationNone);
+	remoteGc->EndDraw();
+	
+	RWsGraphicMsgBuf msgBuf;
+	CleanupClosePushL(msgBuf);
+	//Externalize the captured commands from remote gc in to a buffer
+	remoteGc->ExternalizeL(msgBuf, ETrue);
+	//Create command buffer - required RemoteGc testing
+	CCommandBuffer* cmdBuffer = CCommandBuffer::NewL();
+	CleanupStack::PushL(cmdBuffer);
+	//Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer
+	cmdBuffer->InternalizeL(msgBuf.Pckg());
+
+	// Play stored commands using Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&) 
+	remoteGc->ResetCommandBuffer();
+	iWindow.Invalidate();
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	cmdBuffer->Play(KPlayOffset, &KClippingRegion, KRemotGcSourceRect, TheClient->iWs, *TheGc);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();
+	TheClient->WaitForRedrawsToFinish();
+
+	//Copy the screen to the copy bitmap
+	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);
+
+	//Compare the bitmaps
+	INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&)"));
+	TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iRefBitmap);
+	TEST(compRes);
+
+	// Play stored commands using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&) 
+	remoteGc->ResetCommandBuffer();
+	iWindow.Invalidate();
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	cmdBuffer->Play(KPlayOffset,&KClippingRegion,KRemotGcSourceRect,*iWsGrapicResolver,*iGraphicsCon);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();
+
+	//Compare the values received by CTestWsGraphicsContext and the values sent to it
+	INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&)"));
+	TBool valuesSame = EFalse;
+	CFbsBitmap* bmp;
+	BitmapLC(bmp);
+	compRes = CompareBitmapsByPixel(bmp, iRefBitmap);
+	CleanupStack::PopAndDestroy(bmp);
+
+	if((iGraphicsCon->iPos == KDestPoint) && (compRes)
+									&& (reinterpret_cast<TInt&>(iGraphicsCon->iRotation)==reinterpret_cast<TInt&>(testRotation)))
+		valuesSame = ETrue;
+	TEST(valuesSame);
+	CleanupStack::PopAndDestroy(3, remoteGc);
+	}
+
+/**
+@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0006
+@SYMPREQ                 PREQ2095
+@SYMTestPriority         High
+@SYMTestCaseDesc         Draw RSgImage using RemotGc->DrawResource(const TRect&, const RWsDrawableSource&, TGraphicsRotation)
+@SYMTestActions          Record the draw resource commands using CRemoteGc and play the recorded commands on a window using
+ 						 Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&) and then play the recorded commands using . 
+						 Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&).
+@SYMTestExpectedResults  Drawn images should match reference CFbsBitmap and also values received by MWsGraphicsContext should 
+ 						 match what was originally sent to DrawResource.
+*/
+void CTDrawResource::TestRemoteGcDrawResourceRectL()
+	{
+	const TRect KRemotGcSourceRect(0, 0, iWindow.Size().iWidth, iWindow.Size().iHeight);
+	const TRegionFix<1> KClippingRegion(KRemotGcSourceRect);
+	
+	//Create remote gc - required RemoteGc testing
+	CRemoteGc* remoteGc = CRemoteGc::NewL(TheClient->iScreen);
+	CleanupStack::PushL(remoteGc);
+
+	//Record draw messages
+	remoteGc->BeginDraw(KRemotGcSourceRect);
+	MWsDrawResource* dr = static_cast<MWsDrawResource*>(remoteGc->Interface(KMWsDrawResourceInterfaceUid));
+	TEST(dr != NULL);
+	dr->DrawResource(KDestRect, iWsDrawableSource, KTestRotation);
+	remoteGc->EndDraw();
+	
+	RWsGraphicMsgBuf msgBuf;
+	CleanupClosePushL(msgBuf);
+	//Externalize the captured commands from remote gc in to a buffer
+	remoteGc->ExternalizeL(msgBuf, ETrue);
+
+	//Create command buffer - required RemoteGc testing
+	CCommandBuffer* cmdBuffer = CCommandBuffer::NewL();
+	CleanupStack::PushL(cmdBuffer);
+	//Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer
+	cmdBuffer->InternalizeL(msgBuf.Pckg());
+
+	// Play stored commands using Play(const TRect&, const TRect&, RWsSession&, CWindowGc&)
+	iWindow.Invalidate();
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	cmdBuffer->Play(KPlayOffset, &KClippingRegion, KRemotGcSourceRect, TheClient->iWs, *TheGc);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();
+	TheClient->WaitForRedrawsToFinish();
+
+	//Copy the screen to the copy bitmap
+	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);
+
+	//Compare the bitmaps
+	INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&)"));
+	TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iScaledBitmap);
+	TEST(compRes);
+
+	// Play stored commands using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&) 
+	iWindow.Invalidate();
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	iGraphicsCon->Clear();
+	cmdBuffer->Play(KPlayOffset,&KClippingRegion,KRemotGcSourceRect,*iWsGrapicResolver,*iGraphicsCon);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();
+	TheClient->WaitForRedrawsToFinish();
+
+	//Compare the values received by CTestWsGraphicsContext and the values sent to it
+	INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&)"));
+	TBool valuesSame = EFalse;
+
+	CFbsBitmap* bmp;
+	BitmapLC(bmp);
+	compRes = CompareBitmapsByPixel(bmp, iScaledBitmap);
+	CleanupStack::PopAndDestroy(bmp);
+
+	if((iGraphicsCon->iDestRect == KDestRect) && (compRes)
+								&& (reinterpret_cast<TInt&>(iGraphicsCon->iRotation)==reinterpret_cast<const TInt&>(KTestRotation)))
+		valuesSame = ETrue;
+	TEST(valuesSame);
+	CleanupStack::PopAndDestroy(3, remoteGc);
+	}
+
+/**
+@SYMTestCaseID           GRAPHICS-WSERV-DRAWRESOURCE-0007
+@SYMPREQ                 PREQ2095
+@SYMTestPriority         High
+@SYMTestCaseDesc         Draw RSgImage using RemotGc->DrawResource(const TRect&, const RWsDrawableSource&, const TRect&, TGraphicsRotation)
+@SYMTestActions          Record the draw resource commands using CRemoteGc and play the recorded commands on a window using
+ 						 Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&) and then play the recorded commands using . 
+						 Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&).
+@SYMTestExpectedResults  Drawn images should match reference CFbsBitmap and also values received by MWsGraphicsContext should 
+ 						 match what was originally sent to DrawResource.
+*/
+void CTDrawResource::TestRemoteGcDrawResourceScaleL()
+	{
+	const TRect KRemotGcSourceRect(0, 0, iWindow.Size().iWidth, iWindow.Size().iHeight);
+	const TRegionFix<1> KClippingRegion(KRemotGcSourceRect);
+	
+	//Create remote gc - required RemoteGc testing
+	CRemoteGc* remoteGc = CRemoteGc::NewL(TheClient->iScreen);
+	CleanupStack::PushL(remoteGc);
+
+	//Record draw messages
+	remoteGc->BeginDraw(KRemotGcSourceRect);
+	MWsDrawResource* dr = static_cast<MWsDrawResource*>(remoteGc->Interface(KMWsDrawResourceInterfaceUid));
+	TEST(dr != NULL);
+	dr->DrawResource(KDestRect, iWsDrawableSource, KSourceRect, KTestRotation);
+	remoteGc->EndDraw();
+	
+	RWsGraphicMsgBuf msgBuf;
+	CleanupClosePushL(msgBuf);
+	//Externalize the captured commands from remote gc in to a buffer
+	remoteGc->ExternalizeL(msgBuf, ETrue);
+
+	//Create command buffer - required RemoteGc testing
+	CCommandBuffer* cmdBuffer = CCommandBuffer::NewL();
+	CleanupStack::PushL(cmdBuffer);
+	//Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer
+	cmdBuffer->InternalizeL(msgBuf.Pckg());
+
+	// Play the stored commands using Play(const TRect&, const TRect&, RWsSession&, CWindowGc&)
+	remoteGc->ResetCommandBuffer();
+	iWindow.Invalidate();
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	cmdBuffer->Play(KPlayOffset, &KClippingRegion, KRemotGcSourceRect, TheClient->iWs, *TheGc);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();
+	TheClient->WaitForRedrawsToFinish();
+	//Copy the screen to the copy bitmap
+	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);
+
+	//Compare the bitmaps
+	INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&)"));
+	TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iScaledCroppedBitmap);
+	TEST(compRes);
+
+	// Play the stored commands using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&) 	
+	iWindow.Invalidate();
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	iGraphicsCon->Clear();
+	cmdBuffer->Play(KPlayOffset,&KClippingRegion,KRemotGcSourceRect,*iWsGrapicResolver,*iGraphicsCon);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();
+	TheClient->WaitForRedrawsToFinish();
+
+	//Compare the values received by CTestWsGraphicsContext and the values sent to it
+	INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&)"));
+	TBool valuesSame = EFalse;
+
+	CFbsBitmap* bmp;
+	BitmapLC(bmp);
+	compRes = CompareBitmapsByPixel(bmp, iScaledCroppedBitmap);
+	CleanupStack::PopAndDestroy(bmp);
+
+	if((iGraphicsCon->iDestRect == KDestRect) && (compRes) && (iGraphicsCon->iSrcRect == KSourceRect)
+								&& (reinterpret_cast<TInt&>(iGraphicsCon->iRotation)==reinterpret_cast<const TInt&>(KTestRotation)))
+		valuesSame = ETrue;
+	TEST(valuesSame);
+	CleanupStack::PopAndDestroy(3, remoteGc);
+	}
+
+/**
+@SYMTestCaseID          GRAPHICS-WSERV-DRAWRESOURCE-0008
+@SYMPREQ                PREQ2095
+@SYMTestPriority        High
+@SYMTestCaseDesc        Negative testing. Draw graphics recourses which associated with different screens.
+@SYMTestActions         Open RWsDrawableSource associated with the screen which doesn’ exist.  
+						Open RWsDrawableSource associated with the screen which exists but differes from drawing target.
+						Draw Rectangle and Resource to the screen via CWindowGc
+						Draw Rectangle and Resource to the screen via CRemoteGc
+@SYMTestExpectedResults  Opening drawable resource on the screen which doesn’t exist must fail with error code KErrArgument 
+						Drawing primitives will result only rectangles be drawn as drawable recourses get associated with different screen
+*/
+void CTDrawResource::TestDrawResourceScreensL()
+	{
+	TInt numOfScreens = TheClient->iWs.NumberOfScreens();
+	if(numOfScreens < 2)
+		{
+		INFO_PRINTF2(_L("This test case will be running if the number of available screens more than 1, current number is %d"), numOfScreens);
+		return;
+		}
+	TInt screenNumber = TheClient->iScreen->GetScreenNumber();
+	TInt differentScreen = (screenNumber == 0) ? 1 : 0;
+
+	RSgImage sgImage;
+	CreateSgImageFromBitmapL(sgImage);
+	CleanupClosePushL(sgImage);
+
+	RWsDrawableSource drawableSource(TheClient->iWs);
+	TInt res = drawableSource.Create(sgImage, differentScreen + 200); //wrong screen number
+	TEST(res == KErrArgument);
+
+	res = drawableSource.Create(iImage, differentScreen);
+	TEST(res == KErrNotSupported); //in order to succeed the image must be created with flag usage ESgUsageWindowGcSource
+	
+	TSgImageInfo info; 
+	User::LeaveIfError(sgImage.GetInfo(info));
+
+	res = drawableSource.Create(sgImage, differentScreen);
+	if(res == KErrNotSupported)
+		{
+		INFO_PRINTF1(_L("The second screen is not supports drawable source. This test case terminates now."));
+		CleanupStack::PopAndDestroy(&sgImage);
+		return;
+		}
+	TEST(res == KErrNone);
+	User::LeaveIfError(res);
+	CleanupClosePushL(drawableSource);
+	
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	TheGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
+	TheGc->SetPenStyle(CFbsBitGc::ENullPen);
+	TheGc->SetBrushColor(KRgbGreen);
+	TheGc->DrawRect(TRect(KDestPoint, info.iSizeInPixels));
+	// Draw to TPoint(0,0) with EGraphicsRotationNone but to the different screen
+	MWsDrawResource* winDr = static_cast<MWsDrawResource*>(TheGc->Interface(KMWsDrawResourceInterfaceUid));
+	TEST(winDr != NULL);
+	winDr->DrawResource(KDestPoint, drawableSource, CWindowGc::EGraphicsRotationNone);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();  
+	TheClient->WaitForRedrawsToFinish();
+
+	//Copy the screen to the copy bitmap
+	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);
+
+	//Compare the bitmaps
+	INFO_PRINTF1(_L("Draw to TPoint(0,0) with EGraphicsRotationNone but to different screen"));
+	TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iBitmapWrongScreenNumber);
+	TEST(compRes);
+
+	//--------------------------- remoteGc 
+	const TRect KRemotGcSourceRect(0, 0, iWindow.Size().iWidth, iWindow.Size().iHeight);
+	const TRegionFix<1> KClippingRegion(KRemotGcSourceRect);
+	
+	//Create remote gc - required RemoteGc testing
+	CRemoteGc* remoteGc = CRemoteGc::NewL(TheClient->iScreen);
+	CleanupStack::PushL(remoteGc);
+
+	//Record draw messages
+	remoteGc->BeginDraw(KRemotGcSourceRect);
+	remoteGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
+	remoteGc->SetPenStyle(CFbsBitGc::ENullPen);
+	remoteGc->SetBrushColor(KRgbGreen);
+	remoteGc->DrawRect(TRect(KDestPoint, info.iSizeInPixels));
+	MWsDrawResource* remDr = static_cast<MWsDrawResource*>(remoteGc->Interface(KMWsDrawResourceInterfaceUid));
+	TEST(remDr != NULL);
+	remDr->DrawResource(KDestRect, drawableSource, CWindowGc::EGraphicsRotationNone);
+	remoteGc->EndDraw();
+	
+	RWsGraphicMsgBuf msgBuf;
+	CleanupClosePushL(msgBuf);
+	//Externalize the captured commands from remote gc in to a buffer
+	remoteGc->ExternalizeL(msgBuf, ETrue);
+
+	//Create command buffer - required RemoteGc testing
+	CCommandBuffer* cmdBuffer = CCommandBuffer::NewL();
+	CleanupStack::PushL(cmdBuffer);
+	//Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer
+	cmdBuffer->InternalizeL(msgBuf.Pckg());
+	
+	// Play stored commands using Play(const TRect&, const TRect&, RWsSession&, CWindowGc&)
+	iWindow.Invalidate();
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->Clear();
+	cmdBuffer->Play(KPlayOffset, &KClippingRegion, KRemotGcSourceRect, TheClient->iWs, *TheGc);
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();
+	TheClient->WaitForRedrawsToFinish();
+
+	//Copy the screen to the copy bitmap
+	TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect);
+
+	INFO_PRINTF1(_L("Draw to TPoint(0,0) with EGraphicsRotationNone but to different screen"));
+	TBool compRes1 = CompareBitmapsByPixel(iCopyBitmap, iBitmapWrongScreenNumber);
+	TEST(compRes1);
+
+	CleanupStack::PopAndDestroy(5, &sgImage);
+	}
+
+/**
+@SYMTestCaseID          GRAPHICS-WSERV-TestCopyScreenToBitmapWithDifferentDisplayModes-0001
+@SYMPREQ                PREQ2095
+@SYMTestPriority        High
+@SYMTestCaseDesc        Get bitmap and scanline from the screen.  
+@SYMTestActions         Draw bitmap in various display modes to the screen. 
+						Retrieve scan line and bitmap from the screen using standard WSERV API.  
+
+@SYMTestExpectedResults Checks that obtained bitmap matches with the reference bitmap.
+*/
+void CTDrawResource::TestCopyScreenToBitmapWithDifferentDisplayModesL()
+	{
+	TDisplayMode mode = TheClient->iScreen->DisplayMode();
+    INFO_PRINTF2(_L("Screen display mode %d"), mode);
+	CFbsBitmap* bitmap = NULL;
+	
+	TSize bitmapSize(163, 120);
+	CreateBitmapLC(bitmap, bitmapSize, mode);
+	
+	iWindow.BeginRedraw();
+	TheGc->Activate(iWindow);
+	TheGc->SetBrushStyle(CWindowGc::ESolidBrush);
+	TheGc->SetBrushColor(KRgbYellow);
+	TheGc->Clear();
+	const TPoint ptOffset(10, 15);
+	TheGc->BitBlt(KDestPoint + ptOffset, bitmap);
+
+	TheGc->Deactivate();
+	iWindow.EndRedraw();
+	TheClient->iWs.Finish();
+	TheClient->WaitForRedrawsToFinish();
+
+	const TInt length = bitmapSize.iWidth;
+	const TInt height = bitmapSize.iHeight;
+	const TInt buffersSize = length * 4;
+	TUint8 *screenData = (TUint8*) User::AllocL(buffersSize);
+	CleanupStack::PushL(screenData);
+	TUint8 *bitmapData = (TUint8*) User::AllocL(buffersSize);
+	CleanupStack::PushL(bitmapData);
+	TPtr8 ptrScreen (screenData, buffersSize, buffersSize);
+	TPtr8 ptrBitmap (bitmapData, buffersSize, buffersSize);
+	
+	//EGray mode uses dithering in BitGdi, wserv doesnt support this, thus skipping the first mode 
+	for(TInt ii =2; ; ii++)
+		{
+		TDisplayMode dispMode = (TDisplayMode)ii; 
+		if(dispMode >= EColorLast)
+			break;
+		if(dispMode == ERgb)
+			continue;
+
+	    INFO_PRINTF2(_L("Copy Screen to bitmap, destination mode %d"), dispMode);
+		
+		CFbsBitmap *bmp = new (ELeave) CFbsBitmap;
+		CleanupStack::PushL(bmp);
+		User::LeaveIfError(bmp->Create(bitmapSize, dispMode));
+		TUidPixelFormat pixelFormat = SgUtils::DisplayModeToPixelFormat(dispMode);
+    	const TInt minStride = SgUtils::MinDataStride(length, pixelFormat);
+    	const TInt bitmapStride = bmp->DataStride();
+    	TEST(minStride <= bitmapStride);
+	
+	//Copy the screen to the copy bitmap
+		TRect rc = bitmapSize;
+		rc.Move(ptOffset);
+		TheClient->iScreen->CopyScreenToBitmap(bmp, rc);
+		CFbsBitmap *bmpRef = NULL;
+		CreateReferenceBitmapLC(bmpRef, bitmap, dispMode);
+		TEST(bmpRef->DisplayMode() == dispMode);
+		
+		//Compare the bitmaps
+	    TBool compRes = CompareBitmapsByPixel(bmp, bmpRef);
+	    TEST(compRes);
+	    
+	    for(TInt jj = 0; jj < height; jj++)
+	    	{
+	    	TPoint pt(0, jj);
+	    	TPoint ptScreen = pt + ptOffset;
+	    	
+	    	Mem::Fill(screenData, bitmapStride, 0xff);
+	    	Mem::Fill(bitmapData, bitmapStride, 0xff);
+	    	
+	    	TheClient->iScreen->GetScanLine(ptrScreen, ptScreen, length, dispMode);
+	    	bitmap->GetScanLine(ptrBitmap, pt, length, dispMode);
+	    	TInt length1 = ptrScreen.Length();
+	    	
+	    	TInt res = Mem::Compare(screenData, length1, bitmapData, length1);
+	    	TEST(res == 0);
+	    	}
+	    CleanupStack::PopAndDestroy(2, bmp);
+		}//screen modes;
+		
+	CleanupStack::PopAndDestroy(3, bitmap);
+	}
+
+//Helper function: Creates reference bitmap with specified display mode
+void CTDrawResource::CreateReferenceBitmapLC(CFbsBitmap*& aBmpTarget, CFbsBitmap* aBmpSrc, TDisplayMode aDestMode) 
+	{
+	TSize size = aBmpSrc->SizeInPixels();
+	aBmpTarget = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(aBmpTarget);
+	User::LeaveIfError(aBmpTarget->Create(size, aDestMode));
+    CFbsBitmapDevice *refBitmapDev = CFbsBitmapDevice::NewL(aBmpTarget);
+    CleanupStack::PushL(refBitmapDev);
+    CFbsBitGc *originalBitGc;
+	User::LeaveIfError(refBitmapDev->CreateContext(originalBitGc));
+	CleanupStack::PushL(originalBitGc);
+	originalBitGc->BitBlt(TPoint(0,0), aBmpSrc);
+	CleanupStack::PopAndDestroy(2, refBitmapDev);
+	}
+
+//Helper function: Creates reference bitmap with specified display mode
+void CTDrawResource::CreateBitmapLC(CFbsBitmap*& aBmpTarget, const TSize& aSize, TDisplayMode aDispMode) const
+	{
+	aBmpTarget = new (ELeave) CFbsBitmap;
+	CleanupStack::PushL(aBmpTarget);
+	User::LeaveIfError(aBmpTarget->Create(aSize, aDispMode));
+    CFbsBitmapDevice *refBitmapDev = CFbsBitmapDevice::NewL(aBmpTarget);
+    CleanupStack::PushL(refBitmapDev);
+    CFbsBitGc *originalBitGc;
+	User::LeaveIfError(refBitmapDev->CreateContext(originalBitGc));
+	CleanupStack::PushL(originalBitGc);
+	
+	TRect rect = TRect(aSize); 
+	rect.Shrink(21, 15);
+	
+	originalBitGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
+	originalBitGc->SetBrushColor(TRgb(0,150,150));
+	originalBitGc->DrawRect(TRect(TPoint(0,0), TSize(aSize.iWidth, aSize.iHeight / 2)));
+	originalBitGc->SetBrushColor(TRgb(150,100,150));
+	originalBitGc->DrawRect(TRect(TPoint(0,aSize.iHeight / 2), TSize(aSize.iWidth, aSize.iHeight)));
+
+	originalBitGc->SetBrushColor(TRgb(0,0,128));
+	originalBitGc->DrawRect(rect);
+	
+	
+	CleanupStack::PopAndDestroy(2, refBitmapDev);
+	}
+
+//Helper function: Creates a RSgImage from a bitmap
+void CTDrawResource::CreateSgImageFromBitmapL(RSgImage& aSgImage)
+	{
+	TUint32* data = iRefBitmap->DataAddress();
+	TInt stride = iRefBitmap->DataStride();
+	TSize size = iRefBitmap->SizeInPixels();
+
+	TSgImageInfo info;
+	info.iSizeInPixels = size;
+	info.iScreenId = TheClient->iScreen->CurrentScreenMode();
+	info.iShareable = ETrue; //must be shareable since wserv is in other process
+	info.iUsage = ESgUsageWindowGcSource;
+	info.iPixelFormat = SgUtils::DisplayModeToPixelFormat(iRefBitmap->DisplayMode());
+
+	User::LeaveIfError(aSgImage.Create(info, data, stride));
+	}
+
+//Helper function: Creates all reference bitmaps required for all tests
+void CTDrawResource::CreateReferenceAndCopyBitmapsL()
+	{
+	//Create reference bitmap
+	iRefBitmap = new (ELeave) CFbsBitmap();
+	User::LeaveIfError(iRefBitmap->Create(TSize(160,120),EColor64K));
+	
+	//Setup to draw to original reference bitmap
+    CFbsBitmapDevice *refBitmapDev = CFbsBitmapDevice::NewL(iRefBitmap);
+    CleanupStack::PushL(refBitmapDev);
+    CFbsBitGc *originalBitGc;
+	User::LeaveIfError(refBitmapDev->CreateContext(originalBitGc));
+	CleanupStack::PushL(originalBitGc);
+	
+	//Draw to reference bitmap
+	originalBitGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
+	originalBitGc->SetBrushColor(TRgb(0,150,150));
+	originalBitGc->DrawRect(TRect(TPoint(0,0), TSize(160,60)));
+	originalBitGc->SetBrushColor(TRgb(150,100,150));
+	originalBitGc->DrawRect(TRect(TPoint(0,60), TSize(160,60)));
+	
+	//create a rotated version of the reference bitmap
+	iRotatedRefBitmap = new (ELeave) CFbsBitmap();
+	User::LeaveIfError(iRotatedRefBitmap->Create(TSize(120,160),EColor64K));
+	
+	//Setup to draw to rotated reference bitmap
+    CFbsBitmapDevice *rotRefBitmapDev = CFbsBitmapDevice::NewL(iRotatedRefBitmap);
+    CleanupStack::PushL(rotRefBitmapDev);
+    CFbsBitGc *rotatedBitGc;
+	User::LeaveIfError(rotRefBitmapDev->CreateContext(rotatedBitGc));
+	CleanupStack::PushL(rotatedBitGc);
+	
+	//Draw to rotated reference bitmap
+	rotatedBitGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
+	rotatedBitGc->SetBrushColor(TRgb(0,150,150));
+	rotatedBitGc->DrawRect(TRect(TPoint(60,0), TSize(60,160)));
+	rotatedBitGc->SetBrushColor(TRgb(150,100,150));
+	rotatedBitGc->DrawRect(TRect(TPoint(0,0), TSize(60,160)));
+	
+	//Prepare a scaled version of the rotated reference bitmap to later compare against
+    iScaledBitmap = new (ELeave) CFbsBitmap();
+    User::LeaveIfError(iScaledBitmap->Create(TSize(160,120),EColor64K));
+	//Setup to draw to bitmap
+    CFbsBitmapDevice *scaledBitDev = CFbsBitmapDevice::NewL(iScaledBitmap);
+    CleanupStack::PushL(scaledBitDev);
+    CFbsBitGc *scaledBitGc;
+	User::LeaveIfError(scaledBitDev->CreateContext(scaledBitGc));
+	CleanupStack::PushL(scaledBitGc);
+	//Draw the rotated reference bitmap scaled
+	scaledBitGc->DrawBitmap(KDestRect, iRotatedRefBitmap); 
+	
+	//Prepare a scaled version of the rotated reference bitmap to later compare against
+	iScaledCroppedBitmap = new (ELeave) CFbsBitmap();
+	User::LeaveIfError(iScaledCroppedBitmap->Create(TSize(160,120),EColor64K));
+    
+	//Setup to draw to bitmap
+    CFbsBitmapDevice *scaledCroppedBitDev = CFbsBitmapDevice::NewL(iScaledCroppedBitmap);
+    CleanupStack::PushL(scaledCroppedBitDev);
+    CFbsBitGc *scaledCroppedBitGc;
+	User::LeaveIfError(scaledCroppedBitDev->CreateContext(scaledCroppedBitGc));
+	CleanupStack::PushL(scaledCroppedBitGc);
+	
+	//Draw the rotated reference bitmap scaled
+	TInt width = iRotatedRefBitmap->SizeInPixels().iWidth;
+	TInt height = iRotatedRefBitmap->SizeInPixels().iHeight; 
+	
+	TRect rectSrc;
+	rectSrc.iTl.iX= width - KSourceRect.Height();
+	rectSrc.iTl.iY= 0;
+	rectSrc.iBr.iX= width;
+	rectSrc.iBr.iY= KSourceRect.Width();
+
+	scaledCroppedBitGc->DrawBitmap(KDestRect, iRotatedRefBitmap, rectSrc); 
+	
+	//Prepare bitmap for testing drawable which opened with different screen number
+	iBitmapWrongScreenNumber = new (ELeave) CFbsBitmap();
+    User::LeaveIfError(iBitmapWrongScreenNumber->Create(TSize(160,120),EColor64K));
+	//Setup to draw to bitmap
+    CFbsBitmapDevice *wrongScreenNumberBitDev = CFbsBitmapDevice::NewL(iBitmapWrongScreenNumber);
+    CleanupStack::PushL(wrongScreenNumberBitDev);
+    CFbsBitGc *wrongScreenNumberBitGc;
+	User::LeaveIfError(wrongScreenNumberBitDev->CreateContext(wrongScreenNumberBitGc));
+	CleanupStack::PushL(wrongScreenNumberBitGc);
+	//Draw the rotated reference bitmap scaled
+	wrongScreenNumberBitGc->SetBrushColor(KRgbGreen);
+	wrongScreenNumberBitGc->SetBrushStyle(CFbsBitGc::ESolidBrush);
+	wrongScreenNumberBitGc->SetPenStyle(CFbsBitGc::ENullPen);
+	wrongScreenNumberBitGc->DrawRect(TRect(0, 0, 160, 120)); //
+	
+	//Create a bitmap  to copy to with the same display mode as the reference bitmap
+	iCopyBitmap = new (ELeave) CFbsBitmap();
+	User::LeaveIfError(iCopyBitmap->Create(TSize(640,240),EColor64K));
+	
+	CleanupStack::PopAndDestroy(10, refBitmapDev);
+	}
+
+//Helper function: This function compares two bitmaps on a pixel by pixel basis */
+TBool CTDrawResource::CompareBitmapsByPixel(CFbsBitmap* aCandidateBitmap, CFbsBitmap* aReferenceBitmap)
+	{
+	TBool result = ETrue;
+
+	TSize candidateSize = aCandidateBitmap->SizeInPixels();
+	TSize referenceSize = aReferenceBitmap->SizeInPixels();
+
+	TInt mismatchedPixels = 0;
+	
+	TRgb nativePixel;
+	TRgb referencePixel;
+	for (TInt x = 0; x < referenceSize.iWidth; x++)
+		{
+		for (TInt y = 0; y < referenceSize.iHeight; y++)
+			{
+			TPoint point(x,y);
+			nativePixel = TRgb(0,0,0,0);
+			referencePixel = TRgb(0,0,0,0);
+			aCandidateBitmap->GetPixel(nativePixel, point);
+			aReferenceBitmap->GetPixel(referencePixel, point);
+
+			if (nativePixel != referencePixel)
+				{
+				mismatchedPixels++;
+				result = EFalse;
+				}
+			}
+		}
+	
+	INFO_PRINTF2(_L("Number of different pixels: %i"), mismatchedPixels);
+	return result;
+	}
+//Helper function: This function extracts content of the image associated with the image target and copies it into bitmap
+void CTDrawResource::BitmapLC(CFbsBitmap*& aBmp)
+	{
+	aBmp = new(ELeave) CFbsBitmap;
+    CleanupStack::PushL(aBmp);
+	
+	TSgImageInfo info;
+	TInt res = iImage.GetInfo(info);
+	User::LeaveIfError(res);
+	
+	res = aBmp ->Create(info.iSizeInPixels, SgUtils::PixelFormatToDisplayMode(info.iPixelFormat));
+	User::LeaveIfError(res);
+	TUint32* dataAddressDest = aBmp->DataAddress();
+	
+	RSgImage image;
+	info.iUsage = ESgUsageNone;
+	info.iCpuAccess = ESgCpuAccessReadOnly;
+	res = image.Create(info, iImage);
+	User::LeaveIfError(res);
+	CleanupClosePushL(image);
+	const TAny* dataAddress = NULL; 
+	TInt dataStride;
+	res = image.MapReadOnly(dataAddress, dataStride);
+	User::LeaveIfError(res);
+	Mem::Copy(dataAddressDest, dataAddress, dataStride * info.iSizeInPixels.iHeight);
+	image.Unmap();
+	CleanupStack::PopAndDestroy(&image);
+	}