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