graphicsresourceservices/graphicsresource/test/tsgimagegeneric.cpp
changeset 0 5d03bc08d59c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsresourceservices/graphicsresource/test/tsgimagegeneric.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,2523 @@
+// Copyright (c) 2007-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 "tsgimagegeneric.h"
+#include <hal.h>
+#include <e32math.h>
+
+CTSgImageGeneric::CTSgImageGeneric()
+	{
+	INFO_PRINTF1(_L("Graphics resource component test - RSgImage Generic Tests.\r\n"));
+	}
+
+CTSgImageGeneric::~CTSgImageGeneric()
+	{
+	TInt count = iTestImages.Count();
+	for(TInt i=0; i<count; ++i)
+		{
+		iTestImages[i].Close();
+		}	
+	iTestImages.Reset();
+	}
+
+/** 
+Overrides 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.
+@leave Gets system wide error code
+@return TVerdict code
+*/
+TVerdict CTSgImageGeneric::doTestStepL()
+	{
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0003"));
+	INFO_PRINTF1(_L("Getting pixel formats supported on all platforms.\r\n"));
+	TestGetPixelFormatsL();
+	RecordTestResultL();	
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0004"));
+	INFO_PRINTF1(_L("Create an uninitialised image.\r\n"));
+	TestCreateImageUninitializedL();
+	RecordTestResultL();
+		
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0005"));
+	INFO_PRINTF1(_L("Create an image from a block of memory.\r\n"));
+	TestCreateImageL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0006"));
+	INFO_PRINTF1(_L("Create an image from an existing image.\r\n"));
+	TestCreateImageFromExistingImageL();
+	RecordTestResultL();
+		
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0007"));
+	INFO_PRINTF1(_L("Getting information about the image.\r\n"));
+	TestGetImageInfoL();
+	RecordTestResultL();
+		
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0008"));
+	INFO_PRINTF1(_L("Retrieving drawable id of an image.\r\n"));
+	TestGetImageDrawableIdL();
+	RecordTestResultL();
+		
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0009"));
+	INFO_PRINTF1(_L("Mapping and unmapping an image from its creator process.\r\n"));
+	TestMapImageL();
+	RecordTestResultL();
+		
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0010"));
+	INFO_PRINTF1(_L("Opening a handle to an image in both the current process and another process.\r\n"));
+	TestOpenImageL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0011"));
+	INFO_PRINTF1(_L("Opening a handle to an image with an open mode.\r\n"));
+	TestOpenImageInternalL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0044"));
+	INFO_PRINTF1(_L("Getting the available interfaces from an image.\r\n"));	
+	TestGetInterfaceL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0024"));
+	INFO_PRINTF1(_L("Getting supported pixel formats with invalid parameters.\r\n"));
+	TestGetPixelFormatsInvalidL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0025"));
+	INFO_PRINTF1(_L("Opening an image with different invalid parameters.\r\n"));
+	TestOpenImageInvalidL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0026"));
+	INFO_PRINTF1(_L("Closing the handle to an image object multiple times.\r\n"));
+	TestCloseImageManyTimesL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0027"));
+	INFO_PRINTF1(_L("Closing the handle to an image object without opening it.\r\n"));
+	TestCloseImageWithoutOpenL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0028"));
+	INFO_PRINTF1(_L("Creating an image with various invalid parameters.\r\n"));
+	TestCreateImageInvalidL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0039"));
+	INFO_PRINTF1(_L("Getting information about an invalid image.\r\n"));
+	TestGetInfoInvalidImageL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0030"));
+	INFO_PRINTF1(_L("Mapping an image under various invalid conditions. \r\n"));
+	TestMapImageInvalidL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0031"));
+	INFO_PRINTF1(_L("Unmapping an image under various invalid conditions.\r\n"));
+	TestUnmapImageInvalidL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0048"));
+	INFO_PRINTF1(_L("RSgImage generic stress test.\r\n"));
+	TestStress1L();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0049"));
+	INFO_PRINTF1(_L("RSgImage generic multi-thread stress test.\r\n"));
+	TestStress2L();
+	RecordTestResultL();
+
+#ifdef _DEBUG
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0095
+*/
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0095"));
+	INFO_PRINTF1(_L("RSgImage generic Out of memory test.\r\n"));
+	TestOOM();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0052"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - GetInterface() with invalid image handle\r\n"));
+	TestPanicImageGetInterfaceInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0052"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - GetInterface() with non null image handle and uninitialised driver\r\n"));
+	TestPanicImageGetInterfaceNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0053"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Close() with invalid image handle\r\n"));
+	TestPanicImageCloseInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0054"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Close() with non null image handle and uninitialised driver\r\n"));
+	TestPanicImageCloseNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0055"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Id() with invalid image handle\r\n"));
+	TestPanicImageIdInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0056"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Id() with non null image handle and uninitialised driver\r\n"));
+	TestPanicImageIdNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0057"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Create() with invalid image handle\r\n"));
+	TestPanicImageCreateInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0058"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - GetInfo() with invalid image handle\r\n"));
+	TestPanicImageGetInfoInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0059"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - GetInfo() with non null image handle and uninitialised driver\r\n"));
+	TestPanicImageGetInfoNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0060"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - MapReadOnly() with invalid image handle\r\n"));
+	TestPanicImageMapReadOnlyInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0061"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - MapReadOnly() with non null image handle and uninitialised driver\r\n"));
+	TestPanicImageMapReadOnlyNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0062"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - MapWriteOnly() with invalid image handle\r\n"));
+	TestPanicImageMapWriteOnlyInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0063"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - MapWriteOnly() with non null image handle and uninitialised driver\r\n"));
+	TestPanicImageMapWriteOnlyNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0064"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - MapReadWrite() with invalid image handle\r\n"));
+	TestPanicImageMapReadWriteInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0065"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - MapReadWrite() with non null image handle and uninitialised driver\r\n"));
+	TestPanicImageMapReadWriteNoDriverL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0066"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Unmap() with invalid image handle\r\n"));
+	TestPanicImageUnmapInvalidHandleL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0067"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Unmap() with non null image handle and uninitialised driver\r\n"));
+	TestPanicImageUnmapNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0082"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Open() with an uninitialised driver\r\n"));
+	TestPanicImageOpenNoDriver1L();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0093"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Open() with a mode flag with an uninitialised driver\r\n"));
+	TestPanicImageOpenNoDriver2L();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0083"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Create() from memory with an uninitialised driver\r\n"));
+	TestPanicImageCreateNoDriver1L();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0084"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - Create() from existing image with an uninitialised driver\r\n"));
+	TestPanicImageCreateNoDriver2L();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0085"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - GetPixelFormats() with an uninitialised driver\r\n"));	
+	TestPanicImageGetPixelFormatsNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0088"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - DrawableType() with an uninitialised driver\r\n"));	
+	TestPanicImageDrawableTypeNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0089"));
+	INFO_PRINTF1(_L("RSgImage generic panic test - DrawableType() with invalid image handle\r\n"));	
+	TestPanicImageDrawableTypeInvalidHandleL();
+	RecordTestResultL();
+#else
+	INFO_PRINTF1(_L("Warning: Skipping the panic tests in release build. \r\n"));
+#endif	
+	return TestStepResult();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0003
+@SYMTestCaseDesc		Gets supported pixel formats on all platforms.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::GetPixelFormats(const TSgImageInfo&, TUidPixelFormat*, TInt&)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure all the available pixel formats are returned 
+						in the array and the actual number of pixel formats in
+						the input/output aCount parameter.
+@SYMTestActions			Initialise the graphics resource component. Construct a
+						TSgImageInfo object and Initialise the member variables.
+						Construct a TInt array of size\n
+						\t 1. NULL\n						
+						\t 2. greater than the number of supported pixel formats\n
+						\t 3. equal to the number of supported pixel formats\n
+						\t 4. less than the number of supported pixel formats
+@SYMTestExpectedResults	The function must return\n
+						\t 1. KErrNone\n
+						\t 2. KErrNone\n
+						\t 3. KErrNone\n
+						\t 4. KErrOverFlow\n
+						The supported pixel formats are populated into the array
+						and aCount stores the actual number of supported pixel formats.
+						The returned pixel formats should cover the pixel formats
+						in the image compatibility table that works on all platforms.
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestGetPixelFormatsL()
+	{
+	TestOpenDriverL();
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(10, 10);
+	info.iCpuAccess = ESgCpuAccessNone;
+	info.iUsage = ESgUsageDirectGdiSource;
+	info.iShareable = EFalse;
+	info.iScreenId = 0;
+		
+	TInt numPixelFormats = 0;
+	//NULL array
+	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(info, NULL, numPixelFormats), (TText8*)__FILE__, __LINE__);
+	TEST(numPixelFormats > 1);
+	
+	//array length bigger than available pixel formats
+	TInt count = numPixelFormats + 10;
+	TUidPixelFormat* pixelFormatArray = new(ELeave) TUidPixelFormat[count];
+	CleanupArrayDeletePushL(pixelFormatArray);
+	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(info, pixelFormatArray, count), (TText8*)__FILE__, __LINE__);
+	TEST(count == numPixelFormats);
+	
+	info.iScreenId = -1;
+	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(info, pixelFormatArray, count), (TText8*)__FILE__, __LINE__);
+	TEST(count == numPixelFormats);
+	
+	info.iScreenId = 0;	
+	CleanupStack::PopAndDestroy(pixelFormatArray);
+	//array length is equal to the supported pixel formats
+	count = numPixelFormats;
+	pixelFormatArray = new(ELeave) TUidPixelFormat[count];
+	CleanupArrayDeletePushL(pixelFormatArray);
+	
+	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(info, pixelFormatArray, count), (TText8*)__FILE__, __LINE__);
+	TEST(count == numPixelFormats);
+	
+	CleanupStack::PopAndDestroy(pixelFormatArray);
+	//array length is smaller than the supported pixel formats
+	count = numPixelFormats - 1;
+	pixelFormatArray = new(ELeave) TUidPixelFormat[count];
+	CleanupArrayDeletePushL(pixelFormatArray);
+	TEST(KErrOverflow == RSgImage::GetPixelFormats(info, pixelFormatArray, count));
+	TEST(count == numPixelFormats);
+	CleanupStack::PopAndDestroy(pixelFormatArray);
+	
+	//check all the pixel formats returned are in the common compatibility guarantees table
+	TestGetPixelFormatCompatibilityGuaranteesL();
+	
+	//reset the array used by the GetPixelFormats function to prevent memory leaks
+	info.iCpuAccess = ESgCpuAccessReadWrite;
+	info.iScreenId = 100;
+	TEST(KErrNone == RSgImage::GetPixelFormats(info, NULL, count));
+	TEST(count == 0);
+	
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0004
+@SYMTestCaseDesc		Creates an uninitialised image.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Create(const TSgImageInfo&, const TAny*, TInt)\n 
+						RSgImage::IsNull()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure an uninitialised image can be created.
+@SYMTestActions			Initialise the graphics resource component. Construct well-defined 
+						TSgImageInfo objects that work on all platforms. Create an image 
+						with a NULL base address for each of the TSgImageInfo object.
+@SYMTestExpectedResults	The function should return KErrNone in all cases. The created images
+						are uninitialised.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestCreateImageUninitializedL()
+	{	
+	TestOpenDriverL();
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(100, 100);
+	info.iUsage = ESgUsageDirectGdiTarget;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	
+	RSgImage image;	
+	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0005
+@SYMTestCaseDesc		Creates an image from a block of memory.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Create(const TSgImageInfo&, const TAny*, TInt)\n 
+						RSgImage::IsNull()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure images can be created from a block of memory.
+@SYMTestActions			Initialise the graphics resource component. Construct well-defined 
+						TSgImageInfo objects that work on all platforms. Create a block of
+						memory with or without initialised data. Then create an image with 
+						the starting address of that memory.
+@SYMTestExpectedResults	The function should return KErrNone in all cases. The user data starting
+						at address aDataAddress will be populated into the new image.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestCreateImageL()
+	{	
+	TestOpenDriverL();
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iUsage = ESgUsageDirectGdiSource;
+	info.iShareable = ETrue;
+	
+	RSgImage image;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	CleanupStack::PopAndDestroy();	
+#ifdef __WINS__	
+	//create an image with usage set to screen source
+	TSize screenSize;
+	if(HAL::Get(info.iScreenId, HALData::EDisplayXPixels, screenSize.iWidth) == KErrNone
+		&& HAL::Get(info.iScreenId, HALData::EDisplayYPixels, screenSize.iHeight) == KErrNone)
+		{
+		info.iUsage = ESgUsageScreenSource;
+		info.iScreenId = KSgScreenIdMain;
+		info.iSizeInPixels = TSize(screenSize.iWidth, screenSize.iHeight);
+		CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+		CleanupClosePushL(image);
+		CleanupStack::PopAndDestroy();
+		
+		info.iSizeInPixels = TSize(screenSize.iHeight, screenSize.iWidth);
+		CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+		CleanupClosePushL(image);
+		CleanupStack::PopAndDestroy();
+		}
+#endif	
+	//create an image with some user attributes
+	TSgUserAttribute testAttributes[] = {{0x00008888, 1}, {0x00009999, 2}};
+	info.iUserAttributes = testAttributes;
+	info.iUserAttributeCount = 2;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	CleanupStack::PopAndDestroy();
+	
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0006
+@SYMTestCaseDesc		Creates an image from an existing image.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9192
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Create(const TSgImageInfo&, const RSgImage&)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure images can be created from existing images.
+@SYMTestActions			Initialise the graphics resource component. Create an image. Create another
+						image with the attributes of this image as the TSgImageInfo.
+@SYMTestExpectedResults	The function should return KErrNone. The new image should be identical to
+						the old one. 
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestCreateImageFromExistingImageL()
+	{
+	RSgImage image1;
+	RSgImage image2;
+	TSgImageInfo info;
+	
+	TestOpenDriverL();		
+	CreateImageL(image1);
+	CleanupClosePushL(image1);
+	TEST(KErrNone == image1.GetInfo(info));
+	CheckErrorL(KErrNone, image2.Create(info, image1), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image2);
+	TSgImageInfo info2;
+	TEST(KErrNone == image2.GetInfo(info2));
+	TEST(CompareInfos(info, info2));
+	CleanupStack::PopAndDestroy(2);
+	TestCloseDriver();
+	}
+
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0007
+@SYMTestCaseDesc		Calls GetInfo on an image.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::GetInfo(TSgImageInfo&)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure the information about the image is correct.
+@SYMTestActions			Initialise the graphics resource component. Construct a TSgImageInfo object
+						and Initialise all the member variables. Create images without and with
+						user attributes. Call GetInfo() and compare the resulting TSgImageInfo objects 
+						with the previous ones.
+@SYMTestExpectedResults	The function should return KErrNone. Information about the image object
+						is stored in the aInfo parameter. The retrieved TSgImageInfo objects should be 
+						identical to the original ones.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestGetImageInfoL()
+	{
+	TestOpenDriverL();
+	TSgImageInfo info;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iSizeInPixels = TSize(100, 100);
+	info.iUsage = ESgUsageDirectGdiTarget;
+	
+	RSgImage image;
+	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	
+	TSgImageInfo info2;
+	TEST(KErrNone == image.GetInfo(info2));
+	TEST(CompareInfos(info, info2));
+	CleanupStack::PopAndDestroy();
+	
+	//get info of image with user attributes
+	TSgUserAttribute testAttributes[] = {{0x00008888, 1}, {0x00009999, 2}};
+	info.iUserAttributes = testAttributes;
+	info.iUserAttributeCount = 2;
+	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	TSgImageInfo info3;
+	TSgUserAttribute testAttributes2[2];
+	testAttributes2[0].iUid = TUid::Uid(0x00008888);
+	testAttributes2[1].iUid = TUid::Uid(0x00009999);
+	info3.iUserAttributes = testAttributes2;
+	info3.iUserAttributeCount = 2;
+	TEST(KErrNone == image.GetInfo(info3));
+	TEST(CompareInfos(info, info3));	
+	CleanupStack::PopAndDestroy();
+	
+	info.iShareable = ETrue;
+	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	TEST(KErrNone == image.GetInfo(info3));
+	TEST(CompareInfos(info, info3));
+	CleanupStack::PopAndDestroy();
+	
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0008
+@SYMTestCaseDesc		Retrieves drawable id and drawable type of an image.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Id()\n
+						RSgImage::DrawableType()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure the globally unique drawable id of the image can be retrieved.
+@SYMTestActions			Initialise the graphics resource component. Create an image. Call
+						Id() to retrieve its drawable id.
+@SYMTestExpectedResults	A valid drawable id should be successfully returned.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestGetImageDrawableIdL()
+	{	
+	RSgImage image;
+	TEST(KNullUid == image.DrawableType());
+	TSgDrawableId id = image.Id();
+	TEST(id == KSgNullDrawableId);
+	TestOpenDriverL();	
+	CreateImageL(image);
+	CleanupClosePushL(image);
+	id = image.Id();
+	TEST(id != KSgNullDrawableId);	
+	TEST(KSgImageTypeUid == image.DrawableType());
+
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0009
+@SYMTestCaseDesc		Maps and unmaps an image from its creator process.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9193
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::MapReadOnly(const TAny*&, TInt&) const\n
+ 						RSgImage::MapWriteOnly(TAny*&, TInt&)\n 
+						RSgImage::MapReadWrite(TAny*&, TInt&)\n 
+						RSgImage::Unmap()
+						by its creator process.
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure an image can be successfully mapped and unmapped
+@SYMTestActions			Initialise the graphics resource component. Create mappable images
+						with different TSgImageInfo values. Call different map functions the Unmap()
+						function on each of them.
+@SYMTestExpectedResults	All the functions should return KErrNone.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestMapImageL()
+	{
+	TestOpenDriverL();
+	RSgImage image;
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iUsage = ESgUsageDirectGdiSource;
+	info.iCpuAccess = ESgCpuAccessReadOnly;
+	
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	
+	//test MapReadOnly
+	const TAny* dataAddress;
+	TInt dataStride;	
+	TInt mapResult = image.MapReadOnly(dataAddress, dataStride);
+	TEST(KErrNone == mapResult);
+	if(KErrNone == mapResult)
+		{
+		for (TInt y = 0; y < 8; ++y)
+			for (TInt x = 0; x < 8; ++x)
+				{
+				TUint16 pixelValue = *(TUint16*)PtrAdd(dataAddress, sizeof(TUint16) * x + dataStride * y);
+				if (pixelValue != 0x7E0)
+					{
+					TEST(EFalse);
+					break;
+					}
+				}
+		}
+	TEST(KErrNone == image.Unmap());
+	CleanupStack::PopAndDestroy(&image);
+	
+	//test MapWriteOnly
+	TAny* dataAddress1;
+	
+	info.iCpuAccess = ESgCpuAccessWriteOnly;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	mapResult = image.MapWriteOnly(dataAddress1, dataStride);
+	TEST(KErrNone == mapResult);
+	//change the second line to red
+	if(KErrNone == mapResult)
+		{
+		for(TInt x = 0; x < 8; ++x)
+			{
+			*(TUint16*)PtrAdd(dataAddress1, sizeof(TUint16) * x + dataStride * 1) = 0xF800;
+			}
+		}
+	TEST(KErrNone == image.Unmap());
+	
+	//check if the modification is successful	
+	//create another image from the existing one and map it as read only
+	info.iCpuAccess = ESgCpuAccessReadOnly;
+	RSgImage image1;
+	CheckErrorL(KErrNone, image1.Create(info, image), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image1);
+	mapResult = image1.MapReadOnly(dataAddress, dataStride);
+	TEST(mapResult == KErrNone);
+	if(mapResult == KErrNone)
+		{
+		for(TInt x = 0; x < 8; ++x)
+			{
+			TUint16 pixelValue = *(TUint16*)PtrAdd(dataAddress, sizeof(TUint16) * x + dataStride * 1);
+			if(pixelValue != 0xF800)
+				{
+				TEST(EFalse);
+				break;
+				}
+			}
+		}
+	
+	TEST(KErrNone == image1.Unmap());
+	CleanupStack::PopAndDestroy(2, &image);
+	
+	//test MapReadWrite
+	info.iCpuAccess = ESgCpuAccessReadWrite;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	mapResult = image.MapReadWrite(dataAddress1, dataStride);
+	TEST(KErrNone == mapResult);
+	
+	if(KErrNone == mapResult)
+		{
+		//modify the image, set first line to blue
+		for(TInt x = 0; x < 8; ++x)
+			{
+			*(TUint16*)PtrAdd(dataAddress1, sizeof(TUint16) * x) = 0x1F;
+			}
+		
+		//check the modification
+		for(TInt x = 0; x < 8; ++x)
+			{
+			TUint16 pixelValue = *(TUint16*)PtrAdd(dataAddress1, sizeof(TUint16) * x);
+			if(pixelValue != 0x1F)
+				{
+				TEST(EFalse);
+				break;
+				}
+			}
+		}
+	
+	TEST(KErrNone == image.Unmap());	
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0010
+@SYMTestCaseDesc		Opens a handle to an image in both the current process and another process.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Open(const TSgDrawableId&)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure image can be opened in both a second thread in the current 
+						process and another process.
+@SYMTestActions			Initialise the graphics resource component. Create a shareable image and
+						a non-shareable image. Open() the image in the second thread in the current 
+						process and in another process.
+						Check various image attributes.
+@SYMTestExpectedResults	The function must return KErrNone in both cases.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestOpenImageL()
+	{	
+	TestOpenDriverL();
+	
+	//shareable image
+	RSgImage image1;
+	TSgImageInfo info1;
+	info1.iSizeInPixels = TSize(8, 8);
+	info1.iUsage = ESgUsageDirectGdiSource;
+	info1.iPixelFormat = EUidPixelFormatRGB_565;
+	info1.iCpuAccess = ESgCpuAccessReadWrite;
+	info1.iShareable = ETrue;
+	CheckErrorL(KErrNone, image1.Create(info1, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image1);
+	
+	//non-shareable image
+	RSgImage image2;
+	TSgImageInfo info2;
+	info2.iSizeInPixels = TSize(8, 8);
+	info2.iUsage = ESgUsageDirectGdiSource;
+	info2.iPixelFormat = EUidPixelFormatRGB_565;
+	info2.iCpuAccess = ESgCpuAccessReadWrite;
+	info2.iShareable = EFalse;	
+	CheckErrorL(KErrNone, image2.Create(info2, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image2);
+	
+	const TSgDrawableId id1 = image1.Id();
+	const TSgDrawableId id2 = image2.Id();	
+	
+	//opening image in the current thread
+	RSgImage image3;
+	TEST(KErrNone == image3.Open(id1));
+	image3.Close();
+	TEST(KErrNone == image3.Open(id2));
+	image3.Close();
+	
+	//opening image in a second thread in the current process
+	TSgresTestInfo threadInfo = {id1, info1, 0, ESgresSecondThreadOpenImage};
+	TInt testResult = CreateSecondThreadAndDoTestL(threadInfo);	
+	// Test the results from the second thread
+	User::LeaveIfError(testResult);
+	TEST(testResult & EFirstTestPassed);
+	TEST(testResult & ESecondTestPassed);
+	TEST(testResult & EThirdTestPassed);
+	TEST(testResult & EFourthTestPassed);
+	TEST(testResult & EFifthTestPassed);
+	
+	threadInfo.iDrawableId = id2;
+	threadInfo.iImageInfo = info2;
+	testResult = CreateSecondThreadAndDoTestL(threadInfo);	
+	// Test the results from the second thread
+	User::LeaveIfError(testResult);
+	TEST(testResult & EFirstTestPassed);
+	TEST(testResult & ESecondTestPassed);
+	TEST(testResult & EThirdTestPassed);
+	TEST(testResult & EFourthTestPassed);
+	TEST(testResult & EFifthTestPassed);
+		
+	//opening image in a second process	
+	TSgresTestInfo processInfo = {id1, info1, 0, ESgresSecondProcessOpenImage};
+	testResult = CreateSecondProcessAndDoTestL(KSecondProcess, processInfo);	
+	User::LeaveIfError(testResult);
+	TEST(testResult & EFirstTestPassed);	
+	TEST(testResult & ESecondTestPassed);
+	TEST(testResult & EThirdTestPassed);
+	TEST(testResult & EFourthTestPassed);
+
+	CleanupStack::PopAndDestroy(2, &image1);
+	TestCloseDriver();
+	}
+
+class MFake
+	{
+public:
+	enum { EInterfaceUid = 0x88888888 };
+	};
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0011
+@SYMTestCaseDesc		Opens a handle to an image with mode flags.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Open(const TSgDrawableId&, TUint32)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure image can be opened with mode flags.
+@SYMTestActions			Initialise the graphics resource component. Create an image and
+						call Open() on the image with flag ESgDoNotRestrictUsage. Call
+						GetInfo() on the opened image and check the usage bit. Declare another
+						image object and call Open() on it with the Id of the previously
+						opened handle and without mode flags. Call GetInfo() on this image
+						and check the usage bit.
+@SYMTestExpectedResults	Both infos should contain all the possible usages supported by
+ 						the underlying implementation.						
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestOpenImageInternalL()
+	{
+	TestOpenDriverL();
+	
+	//shareable image
+	RSgImage shareableImage;
+	TSgImageInfo shareableInfo;
+	shareableInfo.iSizeInPixels = TSize(8, 8);
+	shareableInfo.iUsage = ESgUsageDirectGdiSource;
+	shareableInfo.iPixelFormat = EUidPixelFormatRGB_565;
+	shareableInfo.iCpuAccess = ESgCpuAccessReadWrite;
+	shareableInfo.iShareable = ETrue;	
+	CheckErrorL(KErrNone, shareableImage.Create(shareableInfo, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(shareableImage);
+		
+	RSgImage image1;
+	CheckErrorL(KErrNone, image1.Open(shareableImage.Id(), ESgDoNotRestrictUsage), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image1);
+	TSgImageInfo info1;
+	image1.GetInfo(info1);	
+	TEST(ESgUsageDirectGdiSource | info1.iUsage);
+	TEST(ESgUsageCompositionSource | info1.iUsage);
+	TEST(ESgUsageOpenGlesTexture2D | info1.iUsage);
+	TEST(ESgUsageOpenGles2Texture2D | info1.iUsage);
+	TEST(ESgUsageOpenVgImage | info1.iUsage);
+	
+	RSgImage image2;
+	CheckErrorL(KErrNone, image2.Open(image1.Id()), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image2);
+	TSgImageInfo info2;
+	image2.GetInfo(info2);
+	TEST(ESgUsageDirectGdiSource | info2.iUsage);
+	TEST(ESgUsageCompositionSource | info2.iUsage);
+	TEST(ESgUsageOpenGlesTexture2D | info2.iUsage);
+	TEST(ESgUsageOpenGles2Texture2D | info2.iUsage);
+	TEST(ESgUsageOpenVgImage | info2.iUsage);
+	
+	//non-shareable image
+	RSgImage nonshareableImage;
+	TSgImageInfo nonshareableInfo;
+	nonshareableInfo.iSizeInPixels = TSize(8, 8);
+	nonshareableInfo.iUsage = ESgUsageDirectGdiSource;
+	nonshareableInfo.iPixelFormat = EUidPixelFormatRGB_565;
+	nonshareableInfo.iCpuAccess = ESgCpuAccessReadWrite;
+	nonshareableInfo.iShareable = EFalse;	
+	CheckErrorL(KErrNone, nonshareableImage.Create(nonshareableInfo, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(nonshareableImage);
+	
+	RSgImage image3;
+	CheckErrorL(KErrNone, image3.Open(nonshareableImage.Id(), ESgDoNotRestrictUsage), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image3);
+	TSgImageInfo info3;
+	image3.GetInfo(info3);	
+	TEST(ESgUsageDirectGdiSource | info3.iUsage);
+	TEST(ESgUsageCompositionSource | info3.iUsage);
+	TEST(ESgUsageOpenGlesTexture2D | info3.iUsage);
+	TEST(ESgUsageOpenGles2Texture2D | info3.iUsage);
+	TEST(ESgUsageOpenVgImage | info3.iUsage);
+	
+	RSgImage image4;
+	CheckErrorL(KErrNone, image4.Open(image3.Id()), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image4);
+	TSgImageInfo info4;
+	image4.GetInfo(info4);
+	TEST(ESgUsageDirectGdiSource | info4.iUsage);
+	TEST(ESgUsageCompositionSource | info4.iUsage);
+	TEST(ESgUsageOpenGlesTexture2D | info4.iUsage);
+	TEST(ESgUsageOpenGles2Texture2D | info4.iUsage);
+	TEST(ESgUsageOpenVgImage | info4.iUsage);
+	
+	CleanupStack::PopAndDestroy(6, &shareableImage);
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0044
+@SYMTestCaseDesc		Gets the interfaces implemented by CSgImageImpl class.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Create(const TSgImageInfo&, const TAny*, TInt)\n 
+						RSgImage::GetInterface()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure the extension interfaces supported by RSgImage can be
+						returned. 
+@SYMTestActions			Initialise the graphics resource component. Create an image. Call
+						GetInterface() to return the MSgImage_Sw and MSgImage_Chunk interfaces.
+						Perform various operations on the interfaces. Declare a fake interface
+						MFake and call GetInterface() on the image handle.
+@SYMTestExpectedResults	The operations on the MSgImage_Sw and MSgImage_Chunk interfaces should
+						succeed. Trying to get the MFake interface should return KErrExtensionNotSupported.
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestGetInterfaceL()
+	{
+	TestOpenDriverL();
+	
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iUsage = ESgUsageDirectGdiSource;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iCpuAccess = ESgCpuAccessReadWrite;
+	info.iShareable = ETrue;
+	
+	RSgImage image;	
+	MSgImage_Sw* swInterface = NULL;
+	TEST(KErrBadHandle == image.GetInterface(swInterface));
+	
+	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	
+	// check TSgDrawableId is not NULL
+	TSgDrawableId id = image.Id();
+	TEST(KSgNullDrawableId != id);
+	
+	TAny* dataAddress1 = NULL;
+	TInt dataStride1 = 0;
+	TInt result1 = image.GetInterface(swInterface);
+	TEST(KErrNone == result1);
+	if(KErrNone == result1)
+		{		
+		// Fill the image with 0xF0
+		TInt sizeInBytes = 8 * 8 * 2;
+		TESTL(swInterface->BeginDataAccess(ESgCpuAccessNone) == KErrArgument);
+		TEST(swInterface->BeginDataAccess(ESgCpuAccessWriteOnly) == KErrNone);
+		dataAddress1 = swInterface->DataAddress();
+		dataStride1 = swInterface->DataStride();
+		Mem::Fill(dataAddress1, sizeInBytes, 0xF0);
+		TEST(swInterface->EndDataAccess() == KErrNone);
+		
+		//Map the image as read only and check if the previous operation is successful
+		const TAny* dataAddressRead;
+		TInt dataStride2;	
+		TInt mapResult = image.MapReadOnly(dataAddressRead, dataStride2);
+		TEST(KErrNone == mapResult);
+		TEST(dataAddress1 == dataAddressRead);
+		TEST(dataStride1 == dataStride2);
+		if(KErrNone == mapResult)
+			{
+			for (TInt y = 0; y < 8; ++y)
+				for (TInt x = 0; x < 8; ++x)
+					{
+					TUint16 pixelValue = *(TUint16*)PtrAdd(dataAddressRead, sizeof(TUint16) * x + dataStride2 * y);
+					if (pixelValue != 0xF0F0)
+						{
+						TEST(EFalse);
+						break;
+						}
+					}
+			}
+		TEST(KErrNone == image.Unmap());
+		}
+	
+	MSgImage_Chunk* smChunk = NULL;
+	TInt result2 = image.GetInterface(smChunk);
+	TEST(KErrNone == result2);
+	if(KErrNone == result2)
+		{
+		TAny* address = PtrAdd(smChunk->DataChunk().Base(), smChunk->DataOffset());
+		TInt datastride = smChunk->DataStride();
+		if(KErrNone == result1)
+			{
+			TEST(address == dataAddress1);
+			TEST(datastride == dataStride1);
+			}
+		}
+	
+	//fake interface
+	MFake* smFake = NULL;
+	TEST(KErrExtensionNotSupported == image.GetInterface(smFake));
+	
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0024
+@SYMTestCaseDesc		Gets supported pixel formats with invalid parameters.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::GetPixelFormats(const TSgImageInfo&, TUidPixelFormat*, TInt&)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure the correct error messages are returned when user tries to
+						call GetPixelFormats() with invalid parameters.
+@SYMTestActions			Initialise the graphics resource component. Call RSgImage::GetPixelFormats with:\n
+						\t 1. invalid TSgImageInfo object, it could be any combinations of the following:\n
+						\t \t negative width or height\n
+						\t \t mutability incompatible with the specified CPU access and usage\n
+						\t \t screen id < -1\n
+						\t \t usage flag ESgUsageScreenSource with screen id -1\n
+						\t 2. invalid aCount
+@SYMTestExpectedResults	The function should return KErrArgument in both cases.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestGetPixelFormatsInvalidL()
+	{
+	TSgImageInfo info1;
+	TInt count = 0;
+	
+	TestOpenDriverL();
+	//negative width
+	info1.iSizeInPixels = TSize(-100, 100);
+	TEST(KErrArgument == RSgImage::GetPixelFormats(info1, NULL, count));
+	
+	//negative height
+	TSgImageInfo info2;
+	info2.iSizeInPixels = TSize(100, -100);
+	TEST(KErrArgument == RSgImage::GetPixelFormats(info2, NULL, count));
+	
+	//invalid or non-existent screen id
+	TSgImageInfo info5;
+	info5.iSizeInPixels = TSize(8, 8);
+	info5.iUsage = ESgUsageScreenSource;
+	info5.iCpuAccess = ESgCpuAccessReadWrite;
+	info5.iScreenId = -2;
+	TEST(KErrArgument == RSgImage::GetPixelFormats(info5, NULL, count));
+	info5.iScreenId = 100;
+	TEST(KErrNone == RSgImage::GetPixelFormats(info5, NULL, count));
+	TEST(count == 0);
+	
+	//usage flag ESgUsageScreenSource with screen id -1
+	TSgImageInfo info6;
+	info6.iSizeInPixels = TSize(8, 8);
+	info6.iScreenId = -1;
+	info6.iUsage = ESgUsageScreenSource;
+	TEST(KErrArgument == RSgImage::GetPixelFormats(info6, NULL, count));
+	
+	//negative aCount
+	TSgImageInfo info7;
+	info7.iCpuAccess = ESgCpuAccessNone;
+	info7.iShareable = EFalse;
+	info7.iSizeInPixels = TSize(10, 10);
+	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(info7, NULL, count), (TText8*)__FILE__, __LINE__);
+	
+	if(count > 0)
+		{
+		TUidPixelFormat* pixelFormatArray = new(ELeave) TUidPixelFormat[count];
+		if(!pixelFormatArray)
+			{
+			User::Leave(KErrNoMemory);
+			}
+		CleanupStack::PushL(pixelFormatArray);
+		count = -100;
+		TEST(KErrArgument == RSgImage::GetPixelFormats(info7, pixelFormatArray, count));
+		
+		CleanupStack::PopAndDestroy(pixelFormatArray);
+		}
+	
+	//reset the array used by the GetPixelFormats function to prevent memory leaks
+	TSgImageInfo info8;
+	info8.iSizeInPixels = TSize(10, 10);
+	info8.iCpuAccess = ESgCpuAccessReadWrite;
+	info8.iUsage = ESgUsageDirectGdiSource;
+	info8.iShareable = EFalse;
+	info8.iScreenId = 100;
+	TEST(KErrNone == RSgImage::GetPixelFormats(info8, NULL, count));
+	TEST(count == 0);
+	
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0025
+@SYMTestCaseDesc		Opens an image with different invalid parameters.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Open(const TSgDrawableId&)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To check correct error messages are returned when opening image with 
+						different invalid parameters.
+@SYMTestActions			Initialise the graphics resource component. Construct an RSgImage object. 
+						Call the Open() function in both the current process and another process with:\n
+						\t 1. a non-null RSgImage handle\n
+						\t 2. null drawable id\n
+						\t 3. fake drawable id\n
+						\t 4. a non-sharable RSgImage handle
+						Do the same tests in a second thread and a second process.
+@SYMTestExpectedResults	The function should return:\n
+						\t 1. KErrInUse\n
+						\t 2. KErrArgument\n
+						\t 3. KErrNotFound\n
+						\t 4. KErrNone in the same process and KErrPermissionDenied or KErrNotFound in the second process
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestOpenImageInvalidL()
+	{	
+	TestOpenDriverL();
+	//create a non-sharable image
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iUsage = ESgUsageDirectGdiTarget;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iShareable = EFalse;
+	
+	RSgImage image;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	const TSgDrawableId id = image.Id();
+	
+	//same thread
+	//  non-empty handle
+	RSgImage image1;
+	CreateImageL(image1);
+	CleanupClosePushL(image1);
+	TEST(KErrInUse == image1.Open(id));
+	image1.Close();
+	
+	//  null drawable id
+	CheckErrorL(KErrArgument, image1.Open(KSgNullDrawableId), (TText8*)__FILE__, __LINE__);
+	image1.Close();
+	
+	//  non-existing drawable id
+	TSgDrawableId fakeid = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
+	CheckErrorL(KErrNotFound, image1.Open(fakeid), (TText8*)__FILE__, __LINE__);
+	image1.Close();
+	
+	//  open a non-sharable image
+	TEST(KErrNone == image1.Open(id));
+	image1.Close();
+	
+	//different thread in the same process
+	TSgresTestInfo threadInfo = {id, info, 0, ESgresSecondThreadOpenImageInvalid};
+	TInt testResult = CreateSecondThreadAndDoTestL(threadInfo);
+	User::LeaveIfError(testResult);
+	// Test the results from the second thread
+	TEST(testResult & EFirstTestPassed);
+	TEST(testResult & ESecondTestPassed);
+	TEST(testResult & EThirdTestPassed);
+	TEST(testResult & EFourthTestPassed);
+	TEST(testResult & EFifthTestPassed);
+	
+	//different process	
+	TSgresTestInfo processInfo = {id, info, 0, ESgresSecondProcessOpenImageInvalid};
+	testResult = CreateSecondProcessAndDoTestL(KSecondProcess, processInfo);	
+	User::LeaveIfError(testResult);
+	TEST(testResult & EFirstTestPassed);	
+	TEST(testResult & ESecondTestPassed);
+	TEST(testResult & EThirdTestPassed);
+	TEST(testResult & EFourthTestPassed);	
+	TEST(testResult & EFifthTestPassed);
+		
+	CleanupStack::PopAndDestroy(2);
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0026
+@SYMTestCaseDesc		Closes an image multiple times.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Close()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To check calling Close() multiple times after Open() does not cause
+						errors or panics.
+@SYMTestActions			Initialise the graphics resource component. Create an image and then
+						call Close() three times on it.
+@SYMTestExpectedResults	The function should not cause any errors or panics.
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestCloseImageManyTimesL()
+	{
+	TestOpenDriverL();
+	RSgImage image;
+	CreateImageL(image);
+	
+	image.Close();
+	image.Close();
+	image.Close();
+	
+	TestCloseDriver();
+	}
+
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0027
+@SYMTestCaseDesc		Closes an image object without opening it.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Close ()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To check Close() does nothing if the image is not already opened.
+@SYMTestActions			Initialise the graphics resource component. Declare an RSgImage object and
+						call Close() on it.
+@SYMTestExpectedResults	The function should not cause any errors or panics.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestCloseImageWithoutOpenL()
+	{	
+	TestOpenDriverL();
+	RSgImage image;
+	image.Close();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0028
+@SYMTestCaseDesc		Creates an image with various invalid parameters.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9192
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Create(const TSgImageInfo&, const TAny*, TInt)\n 
+						RSgImage::Create(const TSgImageInfo, const RSgImage&)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To check the function returns the correct error messages when the parameters
+						are invalid.
+@SYMTestActions			Initialise the graphics resource component. Construct a TSgImageInfo object 
+						and Initialise the all the member variables with random values. Call the appropriate 
+						Create() function with:\n
+						\t 1. invalid TSgImageInfo\n
+						\t 2. unsupported TSgImageInfo\n
+						\t 3. the creating RSgImage handle is not null\n
+						\t 4. the aSgImage handle is null\n
+						\t 5. the size and pixel format in TSgImageInfo is not the same as that of aSgImage\n
+						\t 6. number of iUserAttributes is more than KMaxHint (8)\n
+@SYMTestExpectedResults	The function should return\n
+						\t 1. KErrArgument\n
+						\t 2. KErrNotSupported\n
+						\t 3. KErrInUse\n
+						\t 4. KErrArgument\n
+						\t 5. KErrNotSupported\n
+						\t 6. KErrOverflow\n
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestCreateImageInvalidL()
+	{
+	TestOpenDriverL();
+	RSgImage image;
+	
+	//invalid info 1 - invalid size
+	TSgImageInfo info1;
+	info1.iSizeInPixels = TSize(-100, 100);
+	TEST(KErrArgument == image.Create(info1, NULL, 0));
+	
+	//invalid info 2 - const image with writable cpu access flag
+	info1.iUsage = ESgUsageDirectGdiSource;
+	info1.iCpuAccess = ESgCpuAccessReadWrite;
+	TEST(KErrArgument == image.Create(info1, NULL, 0));
+	
+	//invalid info 3 - the image is used as a screen source but screen id is set to -1
+	info1.iUsage = ESgUsageScreenSource;
+	info1.iScreenId = KSgScreenIdAny;
+	TEST(KErrArgument == image.Create(info1, NULL, 0));
+	
+	//invalid info 4 - incorrect user attribute count
+	info1.iScreenId = KSgScreenIdMain;
+	TSgUserAttribute KTestAttributes[] = {{0x00008888, 1}, {0x00009999, 2}};
+	info1.iUserAttributes = KTestAttributes;
+	info1.iUserAttributeCount = 0;
+	TEST(KErrArgument == image.Create(info1, NULL, 0));
+	
+	//unsupported info 1 - unsupported pixel format
+	TSgImageInfo info2;
+	info2.iSizeInPixels = TSize(10, 10);
+	info2.iUsage = ESgUsageDirectGdiTarget;
+	info2.iPixelFormat = EUidPixelFormatAP_88;
+	TEST(KErrNotSupported == image.Create(info2, NULL, 0));
+
+	//unsupported info 2 - usage set to screen source and size is not the same as screen size
+	info2.iUsage = ESgUsageScreenSource|ESgUsageDirectGdiTarget;
+	info2.iSizeInPixels = TSize(9999, 8888);
+	TEST(KErrNotSupported == image.Create(info2, NULL, 0));
+
+#ifdef __WINS__
+	TSize screenSize;
+	if(HAL::Get(info2.iScreenId, HALData::EDisplayXPixels, screenSize.iWidth) == KErrNone
+		&& HAL::Get(info2.iScreenId, HALData::EDisplayYPixels, screenSize.iHeight) == KErrNone)
+		{
+		info2.iUsage = ESgUsageScreenSource;
+		info2.iScreenId = KSgScreenIdMain;
+		info2.iCpuAccess = ESgCpuAccessReadWrite;
+		info2.iSizeInPixels = TSize(screenSize.iWidth + 10, screenSize.iHeight);
+		TEST(KErrNotSupported == image.Create(info2, NULL, 0));
+		
+		info2.iSizeInPixels = TSize(screenSize.iWidth, screenSize.iHeight + 10);
+		TEST(KErrNotSupported == image.Create(info2, NULL, 0));
+		
+		info2.iSizeInPixels = TSize(screenSize.iHeight, screenSize.iWidth + 10);
+		TEST(KErrNotSupported == image.Create(info2, NULL, 0));
+		}	
+#endif
+	
+	//non-null handle
+	CreateImageL(image);
+	CleanupClosePushL(image);
+	TSgImageInfo info3;
+	info3.iSizeInPixels = TSize(8, 8);
+	info3.iUsage = ESgUsageDirectGdiSource;
+	info3.iPixelFormat = EUidPixelFormatRGB_565;
+	info3.iCpuAccess = ESgCpuAccessReadWrite;
+	TInt ret = image.Create(info3, NULL, 0);	
+	TEST(KErrInUse == ret);
+	
+	//non-null handle: create from an existing image
+	RSgImage image1;
+	CreateImageL(image1);
+	CleanupClosePushL(image1);
+	TEST(KErrInUse == image1.Create(info3, image));
+	CleanupStack::PopAndDestroy();
+	
+	//null existing image handle
+	RSgImage image2;
+	TEST(image2.IsNull());
+	TEST(KErrArgument == image1.Create(info3, image2));
+		
+	//the size and pixel format in TSgImageInfo is not the same as that of aSgImage
+	TSgImageInfo info4;
+	info4.iSizeInPixels = TSize(100, 100);
+	info4.iUsage = ESgUsageDirectGdiSource;
+	info4.iCpuAccess = ESgCpuAccessReadWrite;
+	TEST(KErrNotSupported == image1.Create(info4, image));
+	
+	info4.iSizeInPixels = info3.iSizeInPixels;
+	info4.iPixelFormat = EUidPixelFormatXRGB_8888;
+	TEST(KErrNotSupported == image1.Create(info4, image));
+	
+	//number of iUserAttributes more than KMaxHint(8)
+	TSgImageInfo info5;
+	info5.iSizeInPixels = TSize(100, 100);
+	info5.iPixelFormat = EUidPixelFormatRGB_565;
+	info5.iCpuAccess = ESgCpuAccessNone;
+	info5.iUsage = ESgUsageDirectGdiTarget;
+	info5.iShareable = ETrue;
+	TSgUserAttribute testAttributes[] = {{0x00008888, 1}, {0x00009999, 2}};
+	info5.iUserAttributes = testAttributes;
+	info5.iUserAttributeCount = 100;	
+	CheckErrorL(KErrOverflow, image1.Create(info5, NULL, 0), (TText8*)__FILE__, __LINE__);
+	
+	CleanupStack::PopAndDestroy(&image);
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0039
+@SYMTestCaseDesc		Calls GetInfo() on an invalid image.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::GetInfo(TSgImageInfo&)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To check the correct error is returned when the client tries to get 
+						information on an invalid image.
+@SYMTestActions			Initialise the graphics resource component. Call GetInfo on an image:\n
+						\t 1. that is not initialised\n
+						\t 2. TSgImageInfo has different user attributes Ids from the existing Ids.
+@SYMTestExpectedResults	The function should return:\n
+						\t 1. KErrBadHandle\n
+						\t 2. KErrNotFound or KErrArgument
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestGetInfoInvalidImageL()
+	{
+	TestOpenDriverL();	
+	RSgImage image;
+	TSgImageInfo info;
+	
+	//uninitialised image
+	TEST(KErrBadHandle == image.GetInfo(info));
+	
+	//TSgImageInfo has different user attributes Ids from the existing Ids.
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iSizeInPixels = TSize(100, 100);
+	info.iUsage = ESgUsageDirectGdiTarget;
+	TSgUserAttribute testAttributes[] = {{0x00008888, 1}, {0x00009999, 2}};
+	info.iUserAttributes = testAttributes;
+	info.iUserAttributeCount = 2;
+	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	TSgImageInfo info2;
+	TSgUserAttribute testAttributes2[1];
+	info2.iUserAttributes = testAttributes2;
+	info2.iUserAttributes[0].iUid = TUid::Uid(0x11111111);
+	info2.iUserAttributeCount = 1;
+	TInt result = image.GetInfo(info2);
+	TEST(KErrNotFound == result || KErrArgument == result);
+	TEST(!CompareInfos(info, info2));
+	
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0030
+@SYMTestCaseDesc		Maps an image under various invalid conditions. 
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9193
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::MapReadOnly(const TAny*&, TInt&) const\n 
+						RSgImage::MapWriteOnly(TAny*&, TInt&)\n 
+						RSgImage::MapReadWrite(TAny*&, TInt&)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To check the correct error messages are returned when different map
+						functions are called under various invalid conditions.
+@SYMTestActions			Initialise the graphics resource component. \n
+						\t 1. call any map function on an uninitialised RSgImage\n
+						\t 2. call any map function twice\n
+						\t 3. call MapReadOnly() on an RSgImage created without CPU access
+						flag ESgCpuAccessReadOnly or ESgCpuAccessReadWrite\n
+						\t 4. call MapWriteOnly() on an RSgImage created without CPU access
+						flag ESgCpuAccessWriteOnly or ESgCpuAccessReadWrite\n
+						\t 5. call MapReadWrite() on an RSgImage created without CPU access
+						flag ESgCpuAccessReadWrite\n
+						\t 6. call any map function in a second process
+@SYMTestExpectedResults	The function should return:\n
+						\t 1. KErrBadHandle\n
+						\t 2. KErrInUse\n
+						\t 3. KErrAccessDenied\n
+						\t 4. KErrAccessDenied\n
+						\t 5. KErrAccessDenied\n
+						\t 6. KErrPermissionDenied
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestMapImageInvalidL()
+	{
+	TestOpenDriverL();
+	RSgImage image;
+	const TAny* dataAddressRead;
+	TAny* dataAddressWrite;
+	TInt dataStride;
+	
+	//an uninitialised image
+	TEST(KErrBadHandle == image.MapReadOnly(dataAddressRead, dataStride));
+	TEST(KErrBadHandle == image.MapWriteOnly(dataAddressWrite, dataStride));
+	TEST(KErrBadHandle == image.MapReadWrite(dataAddressWrite, dataStride));
+	
+	//map twice
+	RSgImage image1;
+	CreateImageL(image1);
+	CleanupClosePushL(image1);
+	TEST(KErrNone == image1.MapReadOnly(dataAddressRead, dataStride));
+	TEST(KErrInUse == image1.MapReadOnly(dataAddressRead, dataStride));
+	TEST(KErrNone == image1.Unmap());
+	
+	TEST(KErrNone == image1.MapWriteOnly(dataAddressWrite, dataStride));
+	TEST(KErrInUse == image1.MapWriteOnly(dataAddressWrite, dataStride));
+	TEST(KErrNone == image1.Unmap());
+	
+	TEST(KErrNone == image1.MapReadWrite(dataAddressWrite, dataStride));
+	TEST(KErrInUse == image1.MapReadWrite(dataAddressWrite, dataStride));
+	TEST(KErrNone == image1.Unmap());
+	
+	CleanupStack::PopAndDestroy();	
+	
+	//  Initialise image
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iUsage = ESgUsageDirectGdiSource;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iCpuAccess = ESgCpuAccessReadWrite;
+	info.iShareable = ETrue;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	TEST(KErrNone == image.MapReadWrite(dataAddressWrite, dataStride)); //first time should pass
+	TEST(KErrInUse == image.MapReadWrite(dataAddressWrite, dataStride)); //second time should fail
+	TEST(KErrNone == image.Unmap());
+	image.Close();
+	
+	//call MapReadOnly() on an RSgImage created without CPU access
+	//flag ESgCpuAccessReadOnly or ESgCpuAccessReadWrite
+	info.iCpuAccess = ESgCpuAccessNone;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	TEST(KErrAccessDenied == image.MapReadOnly(dataAddressRead, dataStride));
+	image.Close();
+	
+	info.iCpuAccess = ESgCpuAccessWriteOnly;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	TEST(KErrAccessDenied == image.MapReadOnly(dataAddressRead, dataStride));
+	image.Close();
+	
+	//call MapWriteOnly() on an RSgImage created without CPU access
+	//flag ESgCpuAccessWriteOnly or ESgCpuAccessReadWrite
+	info.iCpuAccess = ESgCpuAccessNone;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	TEST(KErrAccessDenied == image.MapWriteOnly(dataAddressWrite, dataStride));
+	image.Close();
+	
+	info.iCpuAccess = ESgCpuAccessReadOnly;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	TEST(KErrAccessDenied == image.MapWriteOnly(dataAddressWrite, dataStride));
+	image.Close();
+	
+	//call MapReadWrite() on an RSgImage created without CPU access
+	//flag ESgCpuAccessReadWrite
+	info.iCpuAccess = ESgCpuAccessNone;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	TEST(KErrAccessDenied == image.MapReadWrite(dataAddressWrite, dataStride));
+	image.Close();
+	
+	info.iCpuAccess = ESgCpuAccessReadOnly;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	TEST(KErrAccessDenied == image.MapReadWrite(dataAddressWrite, dataStride));
+	image.Close();
+	
+	info.iCpuAccess = ESgCpuAccessWriteOnly;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	TEST(KErrAccessDenied == image.MapReadWrite(dataAddressWrite, dataStride));
+	image.Close();
+	
+	info.iCpuAccess = ESgCpuAccessReadWrite;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	
+	//call map in a second thread in the current process - should succeed
+	TSgresTestInfo threadInfo = {image.Id(), info, 0, ESgresSecondThreadMapImage};	
+	TInt testResult = CreateSecondThreadAndDoTestL(threadInfo);
+	User::LeaveIfError(testResult);
+	TEST(testResult & EFirstTestPassed);
+	TEST(testResult & ESecondTestPassed);
+	TEST(testResult & EThirdTestPassed);
+	TEST(testResult & EFourthTestPassed);
+	TEST(testResult & EFifthTestPassed);
+	TEST(testResult & ESixthTestPassed);
+	TEST(testResult & ESeventhTestPassed);
+	
+	//call map in a non-owner process
+	TSgresTestInfo processInfo = {image.Id(), info, 0, ESgresSecondProcessMapImage};
+	testResult = CreateSecondProcessAndDoTestL(KSecondProcess, processInfo);	
+	User::LeaveIfError(testResult);	
+	TEST(testResult & EFirstTestPassed);
+	TEST(testResult & ESecondTestPassed);
+	TEST(testResult & EThirdTestPassed);
+	TEST(testResult & EFourthTestPassed);
+	TEST(testResult & EFifthTestPassed);
+	
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0031
+@SYMTestCaseDesc		Unmaps an image under various invalid conditions.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9193
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::MapReadOnly(const TAny*&, TInt&) const\n 
+						RSgImage::MapWriteOnly(TAny*&, TInt&)\n 
+						RSgImage::MapReadWrite(TAny*&, TInt&)\n 
+						RSgImage::Unmap()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To check the correct error messages are returned when the Unmap()
+						function is called under various invalid conditions.
+@SYMTestActions			Initialise the graphics resource component.\n
+						\t 1. call Unmap() on an uninitialised image object\n
+						\t 2. create an image with CPU access flag ESgCpuAccessNone and then unmap it\n
+						\t 3. call Unmap() on an image that was not mapped.\n
+						\t 4. call Unmap() on a mapped image in a second thread in the same process.\n
+						\t 5. call Unmap() on an image in a non-owner process
+@SYMTestExpectedResults	The function should return:\n
+						\t 1. KErrBadHandle\n
+						\t 2. KErrGeneral\n
+						\t 3. KErrGeneral\n
+						\t 4. KErrNone\n
+						\t 5. KErrGeneral
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageGeneric::TestUnmapImageInvalidL()
+	{
+	TestOpenDriverL();
+	RSgImage image;
+	
+	//unitialized image
+	TEST(KErrBadHandle == image.Unmap());
+	
+	//create an image
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iUsage = ESgUsageDirectGdiSource;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iShareable = ETrue;
+	info.iCpuAccess = ESgCpuAccessReadWrite;
+	const TAny* dataAddressRead;
+	TInt dataStride;
+	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(image);
+	
+	//call on an unmapped image
+	TEST(KErrGeneral == image.Unmap());
+	
+	//map in the current thread and try to unmap in another thread in the current process
+	//should fail	
+	TEST(KErrNone == image.MapReadOnly(dataAddressRead, dataStride));	
+	TSgDrawableId id = image.Id();
+	TSgImageInfo imageinfo;
+	image.GetInfo(imageinfo);
+	
+	TSgresTestInfo threadInfo = {id, imageinfo, 0, ESgresSecondThreadUnmapImage};
+	TInt testResult = CreateSecondThreadAndDoTestL(threadInfo);
+	User::LeaveIfError(testResult);
+	TEST(testResult & EFirstTestPassed);
+	TEST(testResult & ESecondTestPassed);
+	
+	//image should already be unmapped
+	TEST(KErrGeneral == image.Unmap());
+	
+	//map in the current thread and try to unmap in another process
+	//should fail
+	TEST(KErrNone == image.MapReadOnly(dataAddressRead, dataStride));	
+	TSgresTestInfo processInfo = {id, imageinfo, 0, ESgresSecondProcessUnmapImage};
+	testResult = CreateSecondProcessAndDoTestL(KSecondProcess, processInfo);	
+	User::LeaveIfError(testResult);
+	TEST(testResult & EFirstTestPassed);	
+	TEST(testResult & ESecondTestPassed);
+	
+	//image should still be mapped
+	TEST(KErrNone == image.Unmap());
+	
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0048
+@SYMTestCaseDesc		RSgImage stress tests
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Create(const TSgImageInfo&, const TAny*, TInt)\n
+						RSgImage::Close() 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure creating and destroying RSgImage multiple times work well.
+@SYMTestActions			Create images 1000 times but only store KMaxImagesInArray of them 
+						at one time in an RArray. When a new image is to be added to the 
+						array, a random image from the array is removed.
+@SYMTestExpectedResults	There should be no panics or leaves.
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestStress1L()
+	{
+	TestOpenDriverL();
+	TSgImageInfo info;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iSizeInPixels = TSize(100, 100);
+	info.iUsage = ESgUsageDirectGdiTarget;
+	
+	TInt KMaxImagesInArray =40;
+	TInt64 seed = 0;
+	for (TInt count = 1000; count > 0; --count)
+		{
+		RSgImage image;
+		CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);
+		CleanupClosePushL(image);
+		iTestImages.AppendL(image);
+		CleanupStack::Pop();
+		if (iTestImages.Count() >= KMaxImagesInArray)
+			{
+			TInt i = Math::Rand(seed) % KMaxImagesInArray;
+			iTestImages[i].Close();
+			iTestImages.Remove(i);
+			}
+		}
+	TInt count = iTestImages.Count();
+	for(TInt i=0; i<count; ++i)
+		{
+		iTestImages[i].Close();
+		}	
+	iTestImages.Reset();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0049
+@SYMTestCaseDesc		RSgImage multiple threads open and close stress tests
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImage::Open(const TSgDrawableId&)\n
+						RSgImage::Close() 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure opening and destroying RSgImage multiple times and randomly
+						in other threads work well.
+@SYMTestActions			Create an image in the main thread. In a loop of 1000 times, randomly select
+						one of the five threads and either open or close the image depending on the 
+						state of the thread.
+@SYMTestExpectedResults	There should be no panics or leaves.
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestStress2L()
+	{
+	TestOpenDriverL();
+	RSgImage image;
+	CreateImageL(image);
+	CleanupClosePushL(image);
+	const TSgDrawableId id = image.Id();
+	
+	TSgImageInfo info;
+	TEST(KErrNone == image.GetInfo(info));
+	TSgresTestInfo threadInfo = {id, info, 0, ESgresMultipleThreadStressTest, EFalse};
+	
+	//create a semaphore
+	RSemaphore sem;
+	User::LeaveIfError(sem.CreateGlobal(KSecondThreadSemaphore, 0, EOwnerThread));
+	CleanupClosePushL(sem);
+	
+	//create threads
+	const TInt KNoOfThreads = 5;
+	RArray<RThread> threads;
+	_LIT(KMultipleThreadName, "Multiple Threads Stress Test Thread ");
+	for (TInt i = 0; i < KNoOfThreads; ++i)
+		{
+		TBuf<50> threadName(KMultipleThreadName);
+		threadName.AppendNum(i);
+		RThread thread;
+		User::LeaveIfError(thread.Create(threadName, SecondThreadStart, KDefaultStackSize, &User::Heap(), &threadInfo));
+		thread.SetPriority(EPriorityLess);
+		threads.AppendL(thread);
+		}
+	// run threads
+	for (TInt i = 0; i < KNoOfThreads; ++i)
+		{
+		threads[i].Resume();
+		}
+	// wait for the threads to terminate processing
+	for (TInt i = 0; i < KNoOfThreads; ++i)
+		{
+		sem.Wait();
+		}
+	for (TInt i = 0; i < KNoOfThreads; ++i)
+		{
+		threads[i].Close();
+		}
+	CleanupStack::PopAndDestroy(2); // image, sem
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0051
+@SYMTestCaseDesc		Calls RSgImage::GetInterface() with an invalid image handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::GetInterface(TUid, TAny*&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling GetInterface() with an invalid image handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Call GetInterface() on the second
+						handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 2(ESgPanicBadDrawableHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageGetInterfaceInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageGetInterfaceInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageGetInterfaceInvalidHandleLThread");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 2, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0052
+@SYMTestCaseDesc		Calls RSgImage::GetInterface() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::GetInterface(TUid, TAny*&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling GetInterface() with a non-null handle and an uninitialised driver will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Close the graphics resource driver.
+						Call GetInterface() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageGetInterfaceNoDriverL()
+	{	
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageGetInterfaceNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageGetInterfaceNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0053
+@SYMTestCaseDesc		Calls RSgImage::Close() with an invalid image handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::Close()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Close() with an invalid image handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Call Close() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 2(ESgPanicBadDrawableHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageCloseInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCloseInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCloseInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 2, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0054
+@SYMTestCaseDesc		Calls RSgImage::Close() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::Close()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Close() with a non-null handle and an uninitialised driver will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Close the graphics resource driver.
+						Call Close() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageCloseNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCloseNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCloseNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0055
+@SYMTestCaseDesc		Calls RSgImage::Id() with an invalid image handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::Id()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Id() with an invalid image handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Call Id() on the second
+						handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 2(ESgPanicBadDrawableHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageIdInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageIdInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageIdInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 2, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0056
+@SYMTestCaseDesc		Calls RSgImage::Id() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::Id()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Id() with a non-null handle and an uninitialised driver will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Close the graphics resource driver.
+						Call Id() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageIdNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageIdNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageIdNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0057
+@SYMTestCaseDesc		Calls RSgImage::Create() with an invalid image handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9192
+@SYMFssID				RSgImage::Create(const TSgImageInfo&, const RSgImage&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Create() with an invalid image handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Call Create() on the second
+						handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 2(ESgPanicBadDrawableHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageCreateInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCreateInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCreateInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 3, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0058
+@SYMTestCaseDesc		Calls RSgImage::GetInfo() with an invalid image handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::GetInfo(TSgImageInfo&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling GetInfo() with an invalid image handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Call GetInfo() on the second
+						handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 2(ESgPanicBadDrawableHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageGetInfoInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageGetInfoInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageGetInfoInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 3, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0059
+@SYMTestCaseDesc		Calls RSgImage::GetInfo() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				SgImage::GetInfo(TSgImageInfo&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling GetInfo() with a non-null handle and an uninitialised driver will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Close the graphics resource driver.
+						Call GetInfo() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageGetInfoNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageGetInfoNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageGetInfoNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0060
+@SYMTestCaseDesc		Calls RSgImage::MapReadOnly with an invalid image handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9193
+@SYMFssID				RSgImage::MapReadOnly(const TAny*&, TInt&) const\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling MapReadOnly() with an invalid image handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Call MapReadOnly() on the second
+						handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 2(ESgPanicBadDrawableHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageMapReadOnlyInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageMapReadOnlyInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageMapReadOnlyInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 3, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0061
+@SYMTestCaseDesc		Calls RSgImage::MapReadOnly with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9193
+@SYMFssID				RSgImage::MapReadOnly(const TAny*&, TInt&) const\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling MapReadOnly() with a non-null handle and an uninitialised driver will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Close the graphics resource driver.
+						Call MapReadOnly() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageMapReadOnlyNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageMapReadOnlyNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageMapReadOnlyNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0062
+@SYMTestCaseDesc		Calls RSgImage::MapWriteOnly() with an invalid image handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9193
+@SYMFssID				RSgImage::MapWriteOnly(TAny*&, TInt&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling MapWriteOnly() with an invalid image handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Call MapWriteOnly() on the second
+						handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 2(ESgPanicBadDrawableHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageMapWriteOnlyInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageMapWriteOnlyInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageMapWriteOnlyInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 3, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0063
+@SYMTestCaseDesc		Calls RSgImage::MapWriteOnly() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9193
+@SYMFssID				RSgImage::MapWriteOnly(TAny*&, TInt&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling MapWriteOnly() with a non-null handle and an uninitialised driver will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Close the graphics resource driver.
+						Call MapWriteOnly() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageMapWriteOnlyNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageMapWriteOnlyNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageMapWriteOnlyNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0064
+@SYMTestCaseDesc		Calls RSgImage::MapReadWrite() with an invalid image handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9193
+@SYMFssID				RSgImage::MapReadWrite(TAny*&, TInt&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling MapReadWrite() with an invalid image handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Call MapReadWrite() on the second
+						handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 2(ESgPanicBadDrawableHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageMapReadWriteInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageMapReadWriteInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageMapReadWriteInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 3, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0065
+@SYMTestCaseDesc		Calls RSgImage::MapReadWrite() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9193
+@SYMFssID				RSgImage::MapReadWrite(TAny*&, TInt&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling MapReadWrite() with a non-null handle and an uninitialised driver will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Close the graphics resource driver.
+						Call MapReadWrite() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageMapReadWriteNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageMapReadWriteNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageMapReadWriteNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0066
+@SYMTestCaseDesc		Calls RSgImage::Unmap() with an invalid image handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMREQ					REQ9193
+@SYMFssID				RSgImage::Unmap()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Unmap() with an invalid image handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Call Unmap() on the second
+						handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 2(ESgPanicBadDrawableHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageUnmapInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageUnmapInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageUnmapInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 3, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0067
+@SYMTestCaseDesc		Calls RSgImage::Unmap() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::Unmap()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Unmap() with a non-null handle and an uninitialised driver will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image in a second thread. 
+						Declare another image and assign it to the current image handle. Close the current
+						image so the second image handle becomes invalid. Close the graphics resource driver.
+						Call Unmap() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageUnmapNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageUnmapNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageUnmapNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0082
+@SYMTestCaseDesc		Calls RSgImage::Open() when the driver was not initialised.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::Open(const TSgDrawableId&, TUint32)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling RSgImage::Open() with an uninitialised driver will cause a panic.
+@SYMTestActions			Do not Initialise the graphics resource component and call RSgImage::Open() in a second thread.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageOpenNoDriver1L()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageOpenNoDriver1, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestPanicImageOpenNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0083
+@SYMTestCaseDesc		Creates an image from memory when the driver was not initialised.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::Create(const TSgImageInfo&, const TAny*, TInt)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling RSgImage::Create() with an uninitialised driver will cause a panic.
+@SYMTestActions			Do not Initialise the graphics resource component and call RSgImage::Open() in a second thread.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageCreateNoDriver1L()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCreateNoDriver1, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestPanicImageCreateNoDriver1L");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0084
+@SYMTestCaseDesc		Creates an image from an existing image when the driver was not initialised.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::Create(const TSgImageInfo&, const RSgImage&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling RSgImage::Create() with an uninitialised driver will cause a panic.
+@SYMTestActions			Do not Initialise the graphics resource component and call RSgImage::Open() in a second thread.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageCreateNoDriver2L()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCreateNoDriver2, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestPanicImageCreateNoDriver2L");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0085
+@SYMTestCaseDesc		Calls RSgImage::GetPixelFormats() when the driver was not initialised.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::GetPixelFormats(const TSgImageInfo&, TUidPixelFormat*, TInt&) \n
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling RSgImage::GetPixelFormats() with an uninitialised driver will cause a panic.
+@SYMTestActions			Do not Initialise the graphics resource component and call RSgImage::GetPixelFormats() in a second thread.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageGetPixelFormatsNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageGetPixelFormatsNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestPanicImageGetPixelFormatsNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0093
+@SYMTestCaseDesc		Calls RSgImage::Open() with mode flags when the driver was not initialised.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::Open(const TSgDrawableId&, TUint32)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling RSgImage::Open() with an uninitialised driver will cause a panic.
+@SYMTestActions			Do not Initialise the graphics resource component and call RSgImage::Open() in a second thread.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageOpenNoDriver2L()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageOpenNoDriver2, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestPanicImageOpenNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0088
+@SYMTestCaseDesc		Calls RSgImage::DrawableType() when the driver was not initialised.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::DrawableType()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling RSgImage::DrawableType() with an uninitialised driver will cause a panic.
+@SYMTestActions			Do not Initialise the graphics resource component and call RSgImage::DrawableType() in a second thread.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageDrawableTypeNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageDrawableTypeInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestPanicImageOpenNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 2, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0089
+@SYMTestCaseDesc		Calls RSgImage::DrawableType() with an invalid image handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ8809
+@SYMREQ					REQ9175
+@SYMFssID				RSgImage::DrawableType()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling RSgImage::DrawableType() with an uninitialised driver will cause a panic.
+@SYMTestActions			Do not Initialise the graphics resource component and call RSgImage::DrawableType() in a second thread.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES SGRES 2(ESgPanicBadDrawableHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageGeneric::TestPanicImageDrawableTypeInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageDrawableTypeNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestPanicImageOpenNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+void CTSgImageGeneric::DoMemoryTestsL()
+	{
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestGetPixelFormatsL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestCreateImageUninitializedL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestCreateImageL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestCreateImageFromExistingImageL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestGetImageInfoL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestGetImageDrawableIdL(); 
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestMapImageL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestOpenImageL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestGetInterfaceL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestGetPixelFormatsInvalidL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestOpenImageInvalidL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestCloseImageManyTimesL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestCloseImageWithoutOpenL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestCreateImageInvalidL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestGetInfoInvalidImageL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestMapImageInvalidL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestUnmapImageInvalidL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	}