diff -r 000000000000 -r 5d03bc08d59c graphicsresourceservices/graphicsresource/test/tsgimagecollectiongeneric.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsresourceservices/graphicsresource/test/tsgimagecollectiongeneric.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1348 @@
+// 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 "tsgimagecollectiongeneric.h"
+
+CTSgImageCollectionGeneric::CTSgImageCollectionGeneric()
+	{
+	INFO_PRINTF1(_L("Graphics resource component test - RSgImageCollection Generic Tests.\r\n"));
+	}
+
+CTSgImageCollectionGeneric::~CTSgImageCollectionGeneric()
+	{
+	}
+
+/** 
+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 CTSgImageCollectionGeneric::doTestStepL()
+	{
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0015"));
+	INFO_PRINTF1(_L("Creation of image collections.\r\n"));
+	TestCreateImageCollectionL();
+	RecordTestResultL();
+		
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0016"));
+	INFO_PRINTF1(_L("Getting surface id of the image collection.\r\n"));
+	TestGetImageCollectionSurfaceIdL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0017"));
+	INFO_PRINTF1(_L("Getting the number of images in an image collection.\r\n"));
+	TestGetCollectionImageNumberL();
+	RecordTestResultL();
+		
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0018"));
+	INFO_PRINTF1(_L("Getting information about the images in an image collection.\r\n"));
+	TestGetImageInfoInCollectionL();
+	RecordTestResultL();
+		
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0019"));
+	INFO_PRINTF1(_L("Getting image at a specific location in an image collection.\r\n"));
+	TestOpenImageInCollectionL();
+	RecordTestResultL();
+		
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0020"));
+	INFO_PRINTF1(_L("Mapping / Unmapping images in a collection.\r\n"));
+	TestMapImageInCollectionL();
+	RecordTestResultL();
+		
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0021"));
+	INFO_PRINTF1(_L("Creation of multiple image collections.\r\n"));
+	TestCreateMultipleImageCollectionL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0034"));
+	INFO_PRINTF1(_L("Creation of the image collection with invalid parameters\r\n"));
+	TestCreateImageCollectionInvalidL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0035"));
+	INFO_PRINTF1(_L("Creation of multiple image collections with invalid parameters.\r\n"));
+	TestCreateMultipleImageCollectionsInvalidL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0036"));
+	INFO_PRINTF1(_L("Getting information about the images in an image collection under various invalid conditions.\r\n"));
+	TestGetImageCollectionInfoInvalidL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0037"));
+	INFO_PRINTF1(_L("Opening images from a collection under various invalid conditions.\r\n"));
+	TestOpenImageInCollectionInvalidL();
+	RecordTestResultL();
+
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0038"));
+	INFO_PRINTF1(_L("Invalid mapping/unmapping tests on individual images in a collection\r\n"));
+	TestMapUnmapImagesInCollectionInvalidL();
+	RecordTestResultL();
+	
+#ifdef _DEBUG
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0094
+*/
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0094"));
+	INFO_PRINTF1(_L("RSgImageCollection generic out of memory tests.\r\n"));
+	TestOOM();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0068"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - Close() with invalid imagecollection handle\r\n"));
+	TestPanicImageCollectionCloseInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0069"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - Close() with non null imagecollection handle and uninitialised driver\r\n"));
+	TestPanicImageCollectionCloseNoDriverL();
+    RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0070"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - SurfaceId() with invalid imagecollection handle\r\n"));
+	TestPanicImageCollectionSurfaceIdInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0071"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - SurfaceId() with non null imagecollection handle and uninitialised driver\r\n"));
+	TestPanicImageCollectionSurfaceIdNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0072"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - GetInfo() with invalid imagecollection handle\r\n"));
+	TestPanicImageCollectionGetInfoInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0073"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - GetInfo() with non null imagecollection handle and uninitialised driver\r\n"));
+	TestPanicImageCollectionGetInfoNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0074"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - Count() with invalid imagecollection handle\r\n"));
+	TestPanicImageCollectionCountInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0075"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - Count() with non null imagecollection handle and uninitialised driver\r\n"));
+	TestPanicImageCollectionCountNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0076"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - OpenImage() with invalid imagecollection handle\r\n"));
+	TestPanicImageCollectionOpenImageInvalidHandleL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0077"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - OpenImage() with non null imagecollection handle and uninitialised driver\r\n"));
+	TestPanicImageCollectionOpenImageNoDriverL();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0086"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - Create() a single image collection with an uninitialised driver\r\n"));
+	TestPanicImageCollectionCreateNoDriver1L();
+	RecordTestResultL();
+	
+	SetTestStepID(_L("GRAPHICS-RESOURCE-0086"));
+	INFO_PRINTF1(_L("RSgImageCollection generic panic test - Create() multiple image collections with an uninitialised driver\r\n"));
+	TestPanicImageCollectionCreateNoDriver2L();
+	RecordTestResultL();
+#else
+	INFO_PRINTF1(_L("Warning: Skipping the panic tests. \r\n"));
+#endif	
+	return TestStepResult();
+	}
+
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0015
+@SYMTestCaseDesc		Creates an image collection.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234 
+@SYMFssID				RSgImageCollection::Create(const TSgImageInfo&, TInt)\n 
+						RSgImageCollection::Close()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure the image collection can be created.
+@SYMTestActions			Initialise the graphics resource component. Construct a TSgImageInfo object
+						and Initialise all the member variables. Call Create() on the RSgImageCollection
+						with the image info and number of images.
+@SYMTestExpectedResults	The function should return KErrNone and memory for the image objects
+						are successfully allocated.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageCollectionGeneric::TestCreateImageCollectionL()
+	{	
+	TestOpenDriverL();	
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iUsage = ESgUsageDirectGdiTarget;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	
+	RSgImageCollection collection;
+	TEST(collection.IsNull());
+	
+	CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	TEST(!collection.IsNull());
+	TEST(1 == SgDriver::ResourceCount());
+	
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0016
+@SYMTestCaseDesc		Gets the surface id of the image collection.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9215
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImageCollection::SurfaceId()\n
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure the surface id of the image collection can be retrieved successfully.
+@SYMTestActions			Initialise the graphics resource component. Create an image collection and call
+						SurfaceId() on it.
+@SYMTestExpectedResults	A non-null surface id should be returned.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageCollectionGeneric::TestGetImageCollectionSurfaceIdL()
+	{
+	const TSurfaceId KNullSurfaceId = {0, 0, 0, 0};
+	RSgImageCollection collection;
+	TSurfaceId surfaceid = collection.SurfaceId();
+	TEST(surfaceid == KNullSurfaceId);
+	TestOpenDriverL();	
+	CreateImageCollectionL(collection);
+	CleanupClosePushL(collection);	
+	surfaceid = collection.SurfaceId();
+	TEST(!surfaceid.IsNull());
+
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0017
+@SYMTestCaseDesc		Gets the number of images in an image collection.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImageCollection::Count())\n
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure the function returns the correct number of images.
+@SYMTestActions			Initialise the graphics resource component. Declare an image collection. Call Count().
+						Create an image collection. Call Count() again.
+@SYMTestExpectedResults	First call should return zero. Second call should return the same value 
+						as the one passed to the function at creation time.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageCollectionGeneric::TestGetCollectionImageNumberL()
+	{	
+	RSgImageCollection collection;
+	TInt number = collection.Count();
+	TEST(0 == number);
+	TestOpenDriverL();	
+	CreateImageCollectionL(collection);
+	CleanupClosePushL(collection);	
+	number = collection.Count();
+	TEST(KNumImagesInCollection == number);
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0018
+@SYMTestCaseDesc		Calls GetInfo() on an image collection.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImageCollection::GetInfo(TSgImageInfo&)\n
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure the information about the images in a collection can be correctly returned.
+@SYMTestActions			Initialise the graphics resource component. Construct a TSgImageInfo object and
+						Initialise all the member variables. Create an image collection. Call GetInfo() and
+						compare the returned TSgImageInfo object with the original one.
+@SYMTestExpectedResults	The function should return KErrNone and the returned information should be the
+						same as the old one.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageCollectionGeneric::TestGetImageInfoInCollectionL()
+	{
+	TestOpenDriverL();
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iUsage = ESgUsageDirectGdiTarget;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	
+	RSgImageCollection collection;
+	CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	TEST(!collection.IsNull());
+	
+	TSgImageInfo info2;
+	TEST(KErrNone == collection.GetInfo(info2));
+	TEST(CompareInfos(info, info2));
+	CleanupStack::PopAndDestroy();
+	
+	//get info with user attributes
+	TSgUserAttribute testAttributes[2] = {{0x00008888, 1}, {0x00009999, 2}};
+	info.iUserAttributes = testAttributes;
+	info.iUserAttributeCount = 2;
+	CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	TSgImageInfo info3;
+	TSgUserAttribute testAttributes2[2] = {{0x00008888, 0}, {0x00009999, 0}};
+	info3.iUserAttributes = testAttributes2;
+	info3.iUserAttributeCount = 2;
+	TEST(KErrNone == collection.GetInfo(info3));
+	TEST(CompareInfos(info, info3));
+	CleanupStack::PopAndDestroy();	
+	
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0019
+@SYMTestCaseDesc		Gets image at a specific location in an image collection.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImageCollection::OpenImage()\n
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure an image at a specific location can be returned.
+@SYMTestActions			Initialise the graphics resource component. Create the image collection. Call OpenImage() to 
+						return all the images in order. 
+@SYMTestExpectedResults	All the images are returned successfully.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageCollectionGeneric::TestOpenImageInCollectionL()
+	{	
+	TestOpenDriverL();
+	RSgImageCollection collection;
+	CreateImageCollectionL(collection);
+	CleanupClosePushL(collection);
+	
+	TSgImageInfo info1;
+	collection.GetInfo(info1);
+	
+	for(TInt i=0; i<KNumImagesInCollection; ++i)
+		{
+		RSgImage image;
+		CheckErrorL(KErrNone, collection.OpenImage(i, image), (TText8*)__FILE__, __LINE__);
+		TSgImageInfo info2;
+		CheckErrorL(KErrNone, image.GetInfo(info2), (TText8*)__FILE__, __LINE__);
+		TEST(CompareInfos(info1, info2));
+		image.Close();
+		}
+	
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0020
+@SYMTestCaseDesc		Maps and unmaps images in a collection.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9193
+@SYMREQ					REQ9219
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImageCollection::OpenImage()\n 
+						RSgImage::MapReadOnly(const TAny*&, TInt&) const\n
+ 						RSgImage::MapWriteOnly(TAny*&, TInt&)\n 
+						RSgImage::MapReadWrite(TAny*&, TInt&)\n 
+						RSgImage::Unmap ()\n
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure individual images in an image collection can be mapped and unmapped.
+@SYMTestActions			Initialise the graphics resource component. Create the image collection. Use the 
+						index operator to return all the images. Call MapXXX() and Unmap() functions on each 
+						of them.
+@SYMTestExpectedResults	All the functions should return KErrNone.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageCollectionGeneric::TestMapImageInCollectionL()
+	{
+	TestOpenDriverL();
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iUsage = ESgUsageDirectGdiSource;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iCpuAccess = ESgCpuAccessReadWrite;
+	
+	RSgImageCollection collection;
+	CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	TEST(!collection.IsNull());
+	
+	TAny* dataAddress;
+	TInt dataStride;
+	
+	for(TInt i=0; i<collection.Count(); ++i)
+		{
+		RSgImage image;
+		CheckErrorL(KErrNone, collection.OpenImage(i, image), (TText8*)__FILE__, __LINE__);
+		TSgImageInfo imageInfo;
+		CheckErrorL(KErrNone, image.GetInfo(imageInfo), (TText8*)__FILE__, __LINE__);
+		
+		//test MapReadWrite
+		TInt mapResult = image.MapReadWrite(dataAddress, dataStride);
+		TEST(KErrNone == mapResult);
+		
+		if(KErrNone == mapResult)
+			{
+			//modify the image, set first line to blue
+			for(TInt x = 0; x < imageInfo.iSizeInPixels.iWidth; ++x)
+				{
+				*(TUint16*)PtrAdd(dataAddress, sizeof(TUint16) * x) = 0x1F;
+				}
+			
+			//check the modification
+			for(TInt x = 0; x < imageInfo.iSizeInPixels.iWidth; ++x)
+				{
+				TUint16 pixelValue = *(TUint16*)PtrAdd(dataAddress, sizeof(TUint16) * x);
+				if(pixelValue != 0x1F)
+					{
+					TEST(EFalse);
+					break;
+					}
+				}
+			}		
+		TEST(KErrNone == image.Unmap());	
+		image.Close();		
+		}
+	
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0021
+@SYMTestCaseDesc		Creates multiple image collections.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImageCollection::Create(const TSgImageInfo&, TInt, RSgImageCollection*, TInt) \n
+						RSgImageCollection::Close()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure multiple image collections can be created using the factory function.
+@SYMTestActions			Initialise the graphics resource component. Construct multiple TSgImageInfo objects
+						and Initialise all the member variables. Call the static Create() function.
+@SYMTestExpectedResults	The function should return KErrNone and memory for the image objects
+						are successfully allocated.
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageCollectionGeneric::TestCreateMultipleImageCollectionL()
+	{
+	TestOpenDriverL();
+	
+	TSgImageInfo infos[3];
+	infos[0].iCpuAccess = ESgCpuAccessReadWrite;
+	infos[0].iPixelFormat = EUidPixelFormatXRGB_8888;
+	infos[0].iSizeInPixels = TSize(50, 50);
+	infos[0].iUsage = ESgUsageDirectGdiSource;
+	
+	infos[1].iCpuAccess = ESgCpuAccessNone;
+	infos[1].iPixelFormat = EUidPixelFormatRGB_565;
+	infos[1].iSizeInPixels = TSize(120, 120);
+	infos[1].iUsage = ESgUsageDirectGdiTarget|ESgUsageCompositionSource;
+	
+	infos[2].iCpuAccess = ESgCpuAccessNone;
+	infos[2].iPixelFormat = EUidPixelFormatARGB_8888_PRE;
+	infos[2].iSizeInPixels = TSize(200, 200);
+	infos[2].iUsage = ESgUsageDirectGdiTarget|ESgUsageCompositionSource;
+	
+	RSgImageCollection collections[3];
+	CheckErrorL(KErrNone, RSgImageCollection::Create(infos, KNumImagesInCollection, collections, 3), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collections[0]);
+	CleanupClosePushL(collections[1]);
+	CleanupClosePushL(collections[2]);
+	
+	for(TInt i=0; i<3; ++i)
+		{
+		RSgImageCollection& collection = collections[i];
+		TEST(!collection.IsNull());
+		
+		TSurfaceId surfaceid = collection.SurfaceId();
+		TEST(!surfaceid.IsNull());
+		
+		TSgImageInfo info;
+		TEST(KErrNone == collection.GetInfo(info));
+		TSgImageInfo oldInfo = infos[i];
+		
+		TEST(CompareInfos(oldInfo, info));
+		
+		TInt imagecount = collection.Count();
+		TEST(imagecount == KNumImagesInCollection);
+
+		for (TInt j = 0; j < KNumImagesInCollection; ++j)
+			{
+			RSgImage image;
+			CheckErrorL(KErrNone, collection.OpenImage(j, image), (TText8*)__FILE__, __LINE__);
+			TEST(KErrNone == image.GetInfo(info));
+			TEST(CompareInfos(oldInfo, info));
+			image.Close();
+			}
+		}
+	
+	CleanupStack::PopAndDestroy(3);
+	TestCloseDriver();
+	}
+
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0034
+@SYMTestCaseDesc		Creates an image collection with invalid parameters
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImageCollection::Create(const TSgImageInfo, TInt)\n
+						RSgImageCollection::Close()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To check for different creation errors.
+@SYMTestActions			Initialise the graphics resource component. Call Create():\n
+ 						\t 1. on a non-null RSgImageCollection object\n
+ 						\t 2. with an invalid TSgImageInfo\n
+ 						\t 3. with a negative or zero image count\n
+						\t 4. with an unsupported TSgImageInfo\n
+						\t 5. with an TSgImageInfo with a size info bigger than the system memory\n
+						\t 6. with number of iUserAttributes more than KMaxHint(8)\n
+@SYMTestExpectedResults	The function should return\n
+						\t 1. KErrInUse\n
+						\t 2. KErrArgument\n
+						\t 3. KErrArgument\n
+						\t 4. KErrNotSupported\n
+						\t 5. KErrNoMemory\n
+						\t 6. KErrOverflow
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageCollectionGeneric::TestCreateImageCollectionInvalidL()
+	{
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iUsage = ESgUsageDirectGdiSource;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iCpuAccess = ESgCpuAccessReadWrite;
+	
+	RSgImageCollection collection;
+	TestOpenDriverL();
+	//non-empty handle
+	CreateImageCollectionL(collection);
+	CleanupClosePushL(collection);
+	TEST(KErrInUse == collection.Create(info, KNumImagesInCollection));
+	collection.Close();
+	
+	//invalid TSgImageInfo
+	TSgImageInfo info1;
+	info1.iSizeInPixels = TSize(-100, 100);
+	info1.iPixelFormat = EUidPixelFormatRGB_565;
+	info1.iCpuAccess = ESgCpuAccessReadWrite;
+	
+	TEST(KErrArgument == collection.Create(info1, KNumImagesInCollection));
+	collection.Close();
+	
+	//negative or zero image count
+	
+	TEST(KErrArgument == collection.Create(info, 0));
+	collection.Close();
+	
+	TEST(KErrArgument == collection.Create(info, -1));
+	collection.Close();
+	
+	//unsupported TSgImageInfo
+	TSgImageInfo info2;
+	info2.iCpuAccess = ESgCpuAccessReadWrite;
+	info2.iPixelFormat = EUidPixelFormatAP_88;
+	info2.iSizeInPixels = TSize(10, 10);
+	info2.iUsage = ESgUsageDirectGdiSource;
+	
+	TEST(KErrNotSupported == collection.Create(info2, KNumImagesInCollection));
+	collection.Close();
+	
+	//number of iUserAttributes more than KMaxHint(8)
+	TSgImageInfo info3;
+	info3.iSizeInPixels = TSize(100, 100);
+	info3.iPixelFormat = EUidPixelFormatRGB_565;
+	info3.iCpuAccess = ESgCpuAccessNone;
+	info3.iUsage = ESgUsageDirectGdiTarget;
+	info3.iUserAttributes = new TSgUserAttribute[100];
+	CleanupArrayDeletePushL(info3.iUserAttributes);
+	info3.iUserAttributeCount = 100;
+	TInt ret = collection.Create(info3, KNumImagesInCollection);
+	if(iRunningOomTests)
+		{
+		TEST(KErrNoMemory == ret || KErrOverflow == ret);
+		}
+	else
+		{
+		TEST(KErrOverflow == ret);
+		}
+	
+	CleanupStack::PopAndDestroy(2);
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0035
+@SYMTestCaseDesc		Creates multiple image collections with invalid parameters.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9217
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImageCollection::Create(const TSgImageInfo[], TInt, RSgImageCollection[], TInt)\n
+						RSgImageCollection::Close()
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To check for different creation errors when creating multiple image collections.
+@SYMTestActions			Initialise the graphics resource component. Call the static Create():\n
+						\t 1. on an array of RSgImageCollection objects with at least one non-null 
+						RSgImageCollection object\n
+						\t 2. with an array of TSgImageInfo objects with at least one invalid TSgImageInfo\n
+						\t 3. with a negative or zero image count\n
+						\t 4. with a negative or zero image collection count\n
+						\t 5. with an array of TSgImageInfo objects with at least one unsupported TSgImageInfo\n
+						\t 6. with an array of TSgImageInfo objects with at least one requesting immutable images\n
+@SYMTestExpectedResults	The function should return\n
+						\t 1. KErrInUse\n
+						\t 2. KErrArgument\n
+						\t 3. KErrArgument\n
+						\t 4. KErrArgument\n
+						\t 5. KErrNotSupported\n
+						\t 6. KErrNotSupported
+@SYMTestStatus			Partially Implemented 
+ */
+void CTSgImageCollectionGeneric::TestCreateMultipleImageCollectionsInvalidL()
+	{
+	//TSgImageInfo array
+	TSgImageInfo info1;
+	info1.iCpuAccess = ESgCpuAccessNone;
+	info1.iPixelFormat = EUidPixelFormatXRGB_8888;
+	info1.iSizeInPixels = TSize(50, 50);
+	info1.iUsage = ESgUsageDirectGdiSource;
+	
+	TSgImageInfo info2;
+	info2.iCpuAccess = ESgCpuAccessReadOnly;
+	info2.iPixelFormat = EUidPixelFormatRGB_565;
+	info2.iSizeInPixels = TSize(120, 120);
+	info2.iUsage = ESgUsageScreenSource;
+	
+	TSgImageInfo info3;
+	info3.iCpuAccess = ESgCpuAccessReadWrite;
+	info3.iPixelFormat = EUidPixelFormatARGB_8888_PRE;
+	info3.iSizeInPixels = TSize(200, 200);
+	info3.iUsage = ESgUsageDirectGdiTarget;
+	
+	TSgImageInfo infos[] = {info1, info2, info3};
+	
+	//RSgImageCollection array
+	const TInt numberOfCollections = 3;
+	RSgImageCollection collections[numberOfCollections];
+	
+	TestOpenDriverL();
+	//create with one of the image info being invalid
+	infos[0].iSizeInPixels = TSize(-50, 50);
+	TEST(KErrArgument == RSgImageCollection::Create(infos, KNumImagesInCollection, collections, numberOfCollections));
+	//reset
+	infos[0].iSizeInPixels = TSize(50, 50);
+	
+	//create with one of the image collection array element being non-null
+	CreateImageCollectionL(collections[0]);
+	CleanupClosePushL(collections[0]);
+	TEST(KErrInUse == RSgImageCollection::Create(infos, KNumImagesInCollection, collections, numberOfCollections));
+	//rest
+	CleanupStack::PopAndDestroy();
+	
+	//create with a negative or zero image count
+	TEST(KErrArgument == RSgImageCollection::Create(infos, 0, collections, numberOfCollections));
+	TEST(KErrArgument == RSgImageCollection::Create(infos, -1, collections, numberOfCollections));
+	
+	//create with a negative or zero image collection count
+	TEST(KErrArgument == RSgImageCollection::Create(infos, KNumImagesInCollection, collections, 0));
+	TEST(KErrArgument == RSgImageCollection::Create(infos, KNumImagesInCollection, collections, -1));
+	
+	//create with one of the image info being unsupported
+	infos[0].iPixelFormat = EUidPixelFormatAP_88;
+	TEST(KErrNotSupported == RSgImageCollection::Create(infos, KNumImagesInCollection, collections, numberOfCollections));
+	//reset
+	infos[0].iPixelFormat = EUidPixelFormatXRGB_8888;
+	
+	//create with some of the image info objects specifying constant images
+	TEST(KErrNotSupported == RSgImageCollection::Create(infos, KNumImagesInCollection, collections, numberOfCollections));
+	
+	//close all collections
+	for(TInt i=0; i<numberOfCollections; ++i)
+		{
+		collections[i].Close();
+		}
+	
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0036
+@SYMTestCaseDesc		Calls GetInfo() on an image collection under various invalid conditions.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImageCollection::GetInfo(TSgImageInfo&)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To check the correct error messages are returned when GetInfo() is called 
+						under various invalid conditions.
+@SYMTestActions			Initialise the graphics resource component. Call GetInfo() on an image collection\n
+						\t 1. that is uninitialised\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 CTSgImageCollectionGeneric::TestGetImageCollectionInfoInvalidL()
+	{
+	TestOpenDriverL();
+	//uninitialised collection
+	RSgImageCollection collection;
+	TSgImageInfo info;
+	TEST(KErrBadHandle == collection.GetInfo(info));
+	
+	//TSgImageInfo has different user attributes Ids from the existing Ids.
+	info.iSizeInPixels = TSize(8, 8);
+	info.iUsage = ESgUsageDirectGdiTarget;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	TSgUserAttribute testAttributes[] = {{0x00008888, 1}, {0x00009999, 2}};
+	info.iUserAttributes = testAttributes;
+	info.iUserAttributeCount = 2;
+	CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	TSgImageInfo info3;
+	TSgUserAttribute testAttributes2[1];
+	info3.iUserAttributes = testAttributes2;
+	info3.iUserAttributes[0].iUid = TUid::Uid(0x11111111);
+	info3.iUserAttributeCount = 1;
+	TInt result = collection.GetInfo(info3);
+	TEST(KErrNotFound == result || KErrArgument == result);
+	CleanupStack::PopAndDestroy();	
+	
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0037
+@SYMTestCaseDesc		Opens images from a collection under various invalid conditions.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				RSgImageCollection::OpenImage(TInt aIndex, RSgImage& aImage)
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure correct error messages are returned when client tries to 
+						open an image inside an image collection under various invalid conditions.
+@SYMTestActions			Initialise the graphics resource component. Call OpenImage():\n
+						\t 1. on an uninitialised image collection\n
+						\t 2. with a negative index\n
+						\t 3. with an index that is bigger than the number of images in the collection\n
+						\t 4. with non-null aImage\n
+@SYMTestExpectedResults	The function should return:\n
+						\t 1. KErrBadHandle\n
+						\t 2. KErrArgument\n
+						\t 3. KErrArgument\n
+						\t 4. KErrInUse\n
+@SYMTestStatus			Implemented 
+ */	
+void CTSgImageCollectionGeneric::TestOpenImageInCollectionInvalidL()
+	{
+	TestOpenDriverL();
+	RSgImageCollection collection;
+	RSgImage image;
+	
+	//uninitialised image collection
+	TEST(KErrBadHandle == collection.OpenImage(0, image));
+	
+	CreateImageCollectionL(collection);	
+	CleanupClosePushL(collection);
+	//with a negative index
+	TEST(KErrArgument == collection.OpenImage(-1, image));
+	image.Close();
+	
+	//with an index that is bigger than the number of images in the collection
+	TInt invalidIndex = collection.Count();
+	TEST(KErrArgument == collection.OpenImage(invalidIndex, image));
+	image.Close();
+	
+	//with non-null aImage handle
+	CreateImageL(image);
+	CleanupClosePushL(image);
+	TEST(KErrInUse == collection.OpenImage(0, image));
+	CleanupStack::PopAndDestroy(&image);
+	
+	CleanupStack::PopAndDestroy();
+	TestCloseDriver();
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0038
+@SYMTestCaseDesc		Invalid map/unmap tests on individual images in a collection
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9193
+@SYMREQ					REQ9214
+@SYMREQ					REQ9224 
+@SYMREQ					REQ9233  
+@SYMREQ					REQ9234
+@SYMFssID				SgImageCollection::OpenImage(TInt aIndex, RSgImage& aImage)\n
+						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 images in an image collection can map/unmap the same way as standalone images.
+@SYMTestActions			Initialise the graphics resource component. Initialise an image collection. Get individual 
+						images from the collection and perform various negative map/unmap tests on them.
+@SYMTestExpectedResults	The functions should behave in the same way as the tests defined previously for stand alone images.
+@SYMTestStatus			Defined 
+ */	
+void CTSgImageCollectionGeneric::TestMapUnmapImagesInCollectionInvalidL()
+	{
+	TestOpenDriverL();
+	
+	//create a collection
+	TSgImageInfo info;
+	info.iSizeInPixels = TSize(8, 8);
+	info.iUsage = ESgUsageDirectGdiSource;
+	info.iPixelFormat = EUidPixelFormatRGB_565;
+	info.iCpuAccess = ESgCpuAccessReadWrite;
+	info.iShareable = ETrue;
+	RSgImageCollection collection;
+	CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	
+	const TAny* dataAddressRead;
+	TAny* dataAddressWrite;
+	TInt dataStride;
+	
+	//map twice
+	for(TInt i=0; i<KNumImagesInCollection; ++i)
+		{
+		RSgImage image;
+		TEST(KErrNone == collection.OpenImage(i, image));
+		TEST(KErrNone == image.MapReadOnly(dataAddressRead, dataStride));
+		TEST(KErrInUse == image.MapReadOnly(dataAddressRead, dataStride));
+		TEST(KErrNone == image.Unmap());
+		
+		TEST(KErrNone == image.MapWriteOnly(dataAddressWrite, dataStride));
+		TEST(KErrInUse == image.MapWriteOnly(dataAddressWrite, dataStride));
+		TEST(KErrNone == image.Unmap());
+		
+		TEST(KErrNone == image.MapReadWrite(dataAddressWrite, dataStride));
+		TEST(KErrInUse == image.MapReadWrite(dataAddressWrite, dataStride));
+		TEST(KErrNone == image.Unmap());
+		image.Close();
+		}
+	CleanupStack::PopAndDestroy();
+	
+	//call MapReadOnly() on the images in a collection created without CPU access
+	//flag ESgCpuAccessReadOnly or ESgCpuAccessReadWrite
+	info.iUsage = ESgUsageDirectGdiTarget;
+	info.iCpuAccess = ESgCpuAccessNone;
+	CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	for(TInt i=0; i<KNumImagesInCollection; ++i)
+		{
+		RSgImage image;
+		TEST(KErrNone == collection.OpenImage(i, image));
+		TEST(KErrAccessDenied == image.MapReadOnly(dataAddressRead, dataStride));
+		image.Close();
+		}
+	CleanupStack::PopAndDestroy();	
+	
+	info.iUsage = ESgUsageDirectGdiSource;
+	info.iCpuAccess = ESgCpuAccessWriteOnly;
+	CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	for(TInt i=0; i<KNumImagesInCollection; ++i)
+		{
+		RSgImage image;
+		TEST(KErrNone == collection.OpenImage(i, image));
+		TEST(KErrAccessDenied == image.MapReadOnly(dataAddressRead, dataStride));
+		image.Close();
+		}
+	CleanupStack::PopAndDestroy();	
+	
+	//call MapWriteOnly() on the images in a collection created without CPU access
+	//flag ESgCpuAccessWriteOnly or ESgCpuAccessReadWrite
+	info.iUsage = ESgUsageDirectGdiTarget;
+	info.iCpuAccess = ESgCpuAccessNone;
+	CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	for(TInt i=0; i<KNumImagesInCollection; ++i)
+		{
+		RSgImage image;
+		TEST(KErrNone == collection.OpenImage(i, image));
+		TEST(KErrAccessDenied == image.MapWriteOnly(dataAddressWrite, dataStride));
+		image.Close();
+		}
+	CleanupStack::PopAndDestroy();
+	
+	info.iCpuAccess = ESgCpuAccessReadOnly;
+	TInt err = collection.Create(info, KNumImagesInCollection);
+	if(KErrNotSupported != err)
+		{
+		User::LeaveIfError(err);
+		CleanupClosePushL(collection);
+		for(TInt i=0; i<KNumImagesInCollection; ++i)
+			{
+			RSgImage image;
+			TEST(KErrNone == collection.OpenImage(i, image));
+			TEST(KErrAccessDenied == image.MapWriteOnly(dataAddressWrite, dataStride));
+			image.Close();
+			}
+		CleanupStack::PopAndDestroy();
+		}	
+	else
+		{
+		INFO_PRINTF1(_L("Warning: skipping test MapWriteOnly() on read-only collection.\r\n"));
+		}
+	
+	//call MapReadWrite() on the images in a collection created without CPU access
+	//flag ESgCpuAccessReadWrite
+	info.iCpuAccess = ESgCpuAccessNone;
+	CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	for(TInt i=0; i<KNumImagesInCollection; ++i)
+		{
+		RSgImage image;
+		TEST(KErrNone == collection.OpenImage(i, image));
+		TEST(KErrAccessDenied == image.MapReadWrite(dataAddressWrite, dataStride));
+		image.Close();
+		}
+	CleanupStack::PopAndDestroy();
+
+	info.iCpuAccess = ESgCpuAccessReadOnly;
+    err = collection.Create(info, KNumImagesInCollection);
+    if(KErrNotSupported != err)
+    	{
+    	CleanupClosePushL(collection);
+    	for(TInt i=0; i<KNumImagesInCollection; ++i)
+    		{
+    		RSgImage image;
+    		TEST(KErrNone == collection.OpenImage(i, image));
+    		TEST(KErrAccessDenied == image.MapReadWrite(dataAddressWrite, dataStride));
+    		image.Close();
+    		}
+    	CleanupStack::PopAndDestroy();
+    	}
+    else
+    	{
+    	INFO_PRINTF1(_L("Warning: skipping test MapReadWrite() on read-only collection.\r\n"));
+    	}
+	
+    info.iUsage = ESgUsageDirectGdiSource;
+    info.iCpuAccess = ESgCpuAccessWriteOnly;
+    CheckErrorL(KErrNone, collection.Create(info, KNumImagesInCollection), (TText8*)__FILE__, __LINE__);
+	CleanupClosePushL(collection);
+	for(TInt i=0; i<KNumImagesInCollection; ++i)
+		{
+		RSgImage image;
+		TEST(KErrNone == collection.OpenImage(i, image));
+		TEST(KErrAccessDenied == image.MapReadWrite(dataAddressWrite, dataStride));
+		image.Close();
+		}
+	CleanupStack::PopAndDestroy();
+
+	TestCloseDriver();
+	}
+
+void CTSgImageCollectionGeneric::DoMemoryTestsL()
+	{
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestCreateImageCollectionL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestGetImageCollectionSurfaceIdL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestGetCollectionImageNumberL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestGetImageInfoInCollectionL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestOpenImageInCollectionL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestMapImageInCollectionL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestCreateMultipleImageCollectionL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestCreateImageCollectionInvalidL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestCreateMultipleImageCollectionsInvalidL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestGetImageCollectionInfoInvalidL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestOpenImageInCollectionInvalidL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	
+	__UHEAP_MARK; SgDriver::AllocMarkStart();
+	TestMapUnmapImagesInCollectionInvalidL();
+	__UHEAP_MARKEND; SgDriver::AllocMarkEnd(0);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0068
+@SYMTestCaseDesc		Calls RSgImageCollection::Close() with an invalid image collection handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::Close()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Close() with an invalid image collection handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image collection in a second thread. 
+						Declare another image collection and assign it to the current image collection handle. Close 
+						the current image collection so the second image collection handle becomes invalid. Call 
+						Close() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 4(ESgPanicBadImageCollectionHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageCollectionGeneric::TestPanicImageCollectionCloseInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionCloseInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCollectionCloseInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 4, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0069
+@SYMTestCaseDesc		Calls RSgImageCollection::Close() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::Close()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Close() with an invalid image collection handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image collection in a second thread. 
+						Declare another image collection and assign it to the current image collection handle. Close 
+						the current image collection so the second image collection 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 CTSgImageCollectionGeneric::TestPanicImageCollectionCloseNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionCloseNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCollectionCloseNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0070
+@SYMTestCaseDesc		Calls RSgImageCollection::SurfaceId() with an invalid image collection handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::SurfaceId()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling SurfaceId() with an invalid image collection handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image collection in a second thread. 
+						Declare another image collection and assign it to the current image collection handle. Close 
+						the current image collection so the second image collection handle becomes invalid. Call 
+						SurfaceId() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 4(ESgPanicBadImageCollectionHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageCollectionGeneric::TestPanicImageCollectionSurfaceIdInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionSurfaceIdInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCollectionSurfaceIdInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 4, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0071
+@SYMTestCaseDesc		Calls RSgImageCollection::SurfaceId() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::SurfaceId()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling SurfaceId() with an invalid image collection handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image collection in a second thread. 
+						Declare another image collection and assign it to the current image collection handle. Close 
+						the current image collection so the second image collection handle becomes invalid. Close the 
+						graphics resource driver. Call SurfaceId() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageCollectionGeneric::TestPanicImageCollectionSurfaceIdNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionSurfaceIdNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCollectionSurfaceIdNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0072
+@SYMTestCaseDesc		Calls RSgImageCollection::GetInfo() with an invalid image collection handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::GetInfo(TSgImageInfo&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling GetInfo() with an invalid image collection handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image collection in a second thread. 
+						Declare another image collection and assign it to the current image collection handle. Close 
+						the current image collection so the second image collection handle becomes invalid. Call 
+						GetInfo() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 4(ESgPanicBadImageCollectionHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageCollectionGeneric::TestPanicImageCollectionGetInfoInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionGetInfoInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCollectionGetInfoInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 4, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0073
+@SYMTestCaseDesc		Calls RSgImageCollection::GetInfo() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::GetInfo(TSgImageInfo&)\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling GetInfo() with an invalid image collection handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image collection in a second thread. 
+						Declare another image collection and assign it to the current image collection handle. Close 
+						the current image collection so the second image collection 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 CTSgImageCollectionGeneric::TestPanicImageCollectionGetInfoNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionGetInfoNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCollectionGetInfoNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0074
+@SYMTestCaseDesc		Calls RSgImageCollection::Count() with an invalid image collection handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::Count()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Count() with an invalid image collection handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image collection in a second thread. 
+						Declare another image collection and assign it to the current image collection handle. Close 
+						the current image collection so the second image collection handle becomes invalid. Call 
+						Count() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 4(ESgPanicBadImageCollectionHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageCollectionGeneric::TestPanicImageCollectionCountInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionCountInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCollectionCountInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 4, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0075
+@SYMTestCaseDesc		Calls RSgImageCollection::Count() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::Count()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling Count() with an invalid image collection handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image collection in a second thread. 
+						Declare another image collection and assign it to the current image collection handle. Close 
+						the current image collection so the second image collection handle becomes invalid. Close the 
+						graphics resource driver. Call Count() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageCollectionGeneric::TestPanicImageCollectionCountNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionCountNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCollectionCountNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0076
+@SYMTestCaseDesc		Calls RSgImageCollection::OpenImage() with an invalid image collection handle
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::OpenImage()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling OpenImage() with an invalid image collection handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image collection in a second thread. 
+						Declare another image collection and assign it to the current image collection handle. Close 
+						the current image collection so the second image collection handle becomes invalid. Call 
+						OpenImage() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 4(ESgPanicBadImageCollectionHandle).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageCollectionGeneric::TestPanicImageCollectionOpenImageInvalidHandleL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionOpenImageInvalidHandle, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCollectionOpenImageInvalidHandleL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 4, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0077
+@SYMTestCaseDesc		Calls RSgImageCollection::OpenImage() with a non-null handle and an uninitialised driver
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::OpenImage()\n 
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling OpenImage() with an invalid image collection handle will cause a panic.
+@SYMTestActions			Initialise the graphics resource component and create an image collection in a second thread. 
+						Declare another image collection and assign it to the current image collection handle. Close 
+						the current image collection so the second image collection handle becomes invalid. Close the 
+						graphics resource driver. Call OpenImage() on the second handle.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageCollectionGeneric::TestPanicImageCollectionOpenImageNoDriverL()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionOpenImageNoDriver, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestImageCollectionOpenImageNoDriverL");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0086
+@SYMTestCaseDesc		Creates an image collection when the driver was not initialised.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::Create(const TSgImageInfo, TInt)\n
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling RSgImageCollection::Create() with an uninitialised driver will cause a panic.
+@SYMTestActions			Do not Initialise the graphics resource component and call RSgImageCollection::Create() in a second thread.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageCollectionGeneric::TestPanicImageCollectionCreateNoDriver1L()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionCreateNoDriver1, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestPanicImageCollectionCreateNoDriver1L");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}
+
+/**
+@SYMTestCaseID			GRAPHICS-RESOURCE-0087
+@SYMTestCaseDesc		Creates multiple image collections when the driver was not initialised.
+@SYMPREQ				PREQ39
+@SYMREQ					REQ9214
+@SYMFssID				RSgImageCollection::Create(const TSgImageInfo[], TInt, RSgImageCollection[], TInt)\n
+@SYMTestPriority		Critical
+@SYMTestType			Unit Test
+@SYMTestPurpose			To ensure calling RSgImageCollection::Create() with an uninitialised driver will cause a panic.
+@SYMTestActions			Do not Initialise the graphics resource component and call RSgImageCollection::Create() in a second thread.
+@SYMTestExpectedResults The function should panic in the second thread with panic code SGRES 5 (ESgPanicNoDriver).
+@SYMTestStatus			Implemented 
+ */
+void CTSgImageCollectionGeneric::TestPanicImageCollectionCreateNoDriver2L()
+	{
+	TSgImageInfo info;
+	TSgresTestInfo threadInfo = {KSgNullDrawableId, info, 0, ESgresSecondThreadPanicImageCollectionCreateNoDriver2, ETrue};
+ 	TExitCategoryName exitCategoryName(KSgTestGenericPanicCategory);
+	_LIT(KTestName, "TestPanicImageCollectionCreateNoDriver2L");
+ 	CreateSecondThreadAndCheckPanicL(threadInfo, 5, exitCategoryName, KTestName);
+	}