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