// 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);

 	}