1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @test

    19  @internalComponent - Internal Symbian test code 

    20 */

    21 

    22 #include "tsgimagegeneric.h"

    23 #include <hal.h>

    24 #include <e32math.h>

    25 

    26 CTSgImageGeneric::CTSgImageGeneric()

    27 	{

    28 	INFO_PRINTF1(_L("Graphics resource component test - RSgImage Generic Tests.\r\n"));

    29 	}

    30 

    31 CTSgImageGeneric::~CTSgImageGeneric()

    32 	{

    33 	TInt count = iTestImages.Count();

    34 	for(TInt i=0; i<count; ++i)

    35 		{

    36 		iTestImages[i].Close();

    37 		}	

    38 	iTestImages.Reset();

    39 	}

    40 

    41 /** 

    42 Overrides of base class pure virtual

    43 Our implementation only gets called if the base class doTestStepPreambleL() did

    44 not leave. That being the case, the current test result value will be EPass.

    45 @leave Gets system wide error code

    46 @return TVerdict code

    47 */

    48 TVerdict CTSgImageGeneric::doTestStepL()

    49 	{

    50 	SetTestStepID(_L("GRAPHICS-RESOURCE-0003"));

    51 	INFO_PRINTF1(_L("Getting pixel formats supported on all platforms.\r\n"));

    52 	TestGetPixelFormatsL();

    53 	RecordTestResultL();	

    54 

    55 	SetTestStepID(_L("GRAPHICS-RESOURCE-0004"));

    56 	INFO_PRINTF1(_L("Create an uninitialised image.\r\n"));

    57 	TestCreateImageUninitializedL();

    58 	RecordTestResultL();

    59 		

    60 	SetTestStepID(_L("GRAPHICS-RESOURCE-0005"));

    61 	INFO_PRINTF1(_L("Create an image from a block of memory.\r\n"));

    62 	TestCreateImageL();

    63 	RecordTestResultL();

    64 	

    65 	SetTestStepID(_L("GRAPHICS-RESOURCE-0006"));

    66 	INFO_PRINTF1(_L("Create an image from an existing image.\r\n"));

    67 	TestCreateImageFromExistingImageL();

    68 	RecordTestResultL();

    69 		

    70 	SetTestStepID(_L("GRAPHICS-RESOURCE-0007"));

    71 	INFO_PRINTF1(_L("Getting information about the image.\r\n"));

    72 	TestGetImageInfoL();

    73 	RecordTestResultL();

    74 		

    75 	SetTestStepID(_L("GRAPHICS-RESOURCE-0008"));

    76 	INFO_PRINTF1(_L("Retrieving drawable id of an image.\r\n"));

    77 	TestGetImageDrawableIdL();

    78 	RecordTestResultL();

    79 		

    80 	SetTestStepID(_L("GRAPHICS-RESOURCE-0009"));

    81 	INFO_PRINTF1(_L("Mapping and unmapping an image from its creator process.\r\n"));

    82 	TestMapImageL();

    83 	RecordTestResultL();

    84 		

    85 	SetTestStepID(_L("GRAPHICS-RESOURCE-0010"));

    86 	INFO_PRINTF1(_L("Opening a handle to an image in both the current process and another process.\r\n"));

    87 	TestOpenImageL();

    88 	RecordTestResultL();

    89 	

    90 	SetTestStepID(_L("GRAPHICS-RESOURCE-0011"));

    91 	INFO_PRINTF1(_L("Opening a handle to an image with an open mode.\r\n"));

    92 	TestOpenImageInternalL();

    93 	RecordTestResultL();

    94 	

    95 	SetTestStepID(_L("GRAPHICS-RESOURCE-0044"));

    96 	INFO_PRINTF1(_L("Getting the available interfaces from an image.\r\n"));	

    97 	TestGetInterfaceL();

    98 	RecordTestResultL();

    99 

   100 	SetTestStepID(_L("GRAPHICS-RESOURCE-0024"));

   101 	INFO_PRINTF1(_L("Getting supported pixel formats with invalid parameters.\r\n"));

   102 	TestGetPixelFormatsInvalidL();

   103 	RecordTestResultL();

   104 

   105 	SetTestStepID(_L("GRAPHICS-RESOURCE-0025"));

   106 	INFO_PRINTF1(_L("Opening an image with different invalid parameters.\r\n"));

   107 	TestOpenImageInvalidL();

   108 	RecordTestResultL();

   109 

   110 	SetTestStepID(_L("GRAPHICS-RESOURCE-0026"));

   111 	INFO_PRINTF1(_L("Closing the handle to an image object multiple times.\r\n"));

   112 	TestCloseImageManyTimesL();

   113 	RecordTestResultL();

   114 

   115 	SetTestStepID(_L("GRAPHICS-RESOURCE-0027"));

   116 	INFO_PRINTF1(_L("Closing the handle to an image object without opening it.\r\n"));

   117 	TestCloseImageWithoutOpenL();

   118 	RecordTestResultL();

   119 

   120 	SetTestStepID(_L("GRAPHICS-RESOURCE-0028"));

   121 	INFO_PRINTF1(_L("Creating an image with various invalid parameters.\r\n"));

   122 	TestCreateImageInvalidL();

   123 	RecordTestResultL();

   124 

   125 	SetTestStepID(_L("GRAPHICS-RESOURCE-0039"));

   126 	INFO_PRINTF1(_L("Getting information about an invalid image.\r\n"));

   127 	TestGetInfoInvalidImageL();

   128 	RecordTestResultL();

   129 

   130 	SetTestStepID(_L("GRAPHICS-RESOURCE-0030"));

   131 	INFO_PRINTF1(_L("Mapping an image under various invalid conditions. \r\n"));

   132 	TestMapImageInvalidL();

   133 	RecordTestResultL();

   134 

   135 	SetTestStepID(_L("GRAPHICS-RESOURCE-0031"));

   136 	INFO_PRINTF1(_L("Unmapping an image under various invalid conditions.\r\n"));

   137 	TestUnmapImageInvalidL();

   138 	RecordTestResultL();

   139 	

   140 	SetTestStepID(_L("GRAPHICS-RESOURCE-0048"));

   141 	INFO_PRINTF1(_L("RSgImage generic stress test.\r\n"));

   142 	TestStress1L();

   143 	RecordTestResultL();

   144 	

   145 	SetTestStepID(_L("GRAPHICS-RESOURCE-0049"));

   146 	INFO_PRINTF1(_L("RSgImage generic multi-thread stress test.\r\n"));

   147 	TestStress2L();

   148 	RecordTestResultL();

   149 

   150 #ifdef _DEBUG

   151 /**

   152 @SYMTestCaseID			GRAPHICS-RESOURCE-0095

   153 */

   154 	SetTestStepID(_L("GRAPHICS-RESOURCE-0095"));

   155 	INFO_PRINTF1(_L("RSgImage generic Out of memory test.\r\n"));

   156 	TestOOM();

   157 	RecordTestResultL();

   158 	

   159 	SetTestStepID(_L("GRAPHICS-RESOURCE-0052"));

   160 	INFO_PRINTF1(_L("RSgImage generic panic test - GetInterface() with invalid image handle\r\n"));

   161 	TestPanicImageGetInterfaceInvalidHandleL();

   162 	RecordTestResultL();

   163 	

   164 	SetTestStepID(_L("GRAPHICS-RESOURCE-0052"));

   165 	INFO_PRINTF1(_L("RSgImage generic panic test - GetInterface() with non null image handle and uninitialised driver\r\n"));

   166 	TestPanicImageGetInterfaceNoDriverL();

   167 	RecordTestResultL();

   168 	

   169 	SetTestStepID(_L("GRAPHICS-RESOURCE-0053"));

   170 	INFO_PRINTF1(_L("RSgImage generic panic test - Close() with invalid image handle\r\n"));

   171 	TestPanicImageCloseInvalidHandleL();

   172 	RecordTestResultL();

   173 	

   174 	SetTestStepID(_L("GRAPHICS-RESOURCE-0054"));

   175 	INFO_PRINTF1(_L("RSgImage generic panic test - Close() with non null image handle and uninitialised driver\r\n"));

   176 	TestPanicImageCloseNoDriverL();

   177 	RecordTestResultL();

   178 	

   179 	SetTestStepID(_L("GRAPHICS-RESOURCE-0055"));

   180 	INFO_PRINTF1(_L("RSgImage generic panic test - Id() with invalid image handle\r\n"));

   181 	TestPanicImageIdInvalidHandleL();

   182 	RecordTestResultL();

   183 	

   184 	SetTestStepID(_L("GRAPHICS-RESOURCE-0056"));

   185 	INFO_PRINTF1(_L("RSgImage generic panic test - Id() with non null image handle and uninitialised driver\r\n"));

   186 	TestPanicImageIdNoDriverL();

   187 	RecordTestResultL();

   188 	

   189 	SetTestStepID(_L("GRAPHICS-RESOURCE-0057"));

   190 	INFO_PRINTF1(_L("RSgImage generic panic test - Create() with invalid image handle\r\n"));

   191 	TestPanicImageCreateInvalidHandleL();

   192 	RecordTestResultL();

   193 	

   194 	SetTestStepID(_L("GRAPHICS-RESOURCE-0058"));

   195 	INFO_PRINTF1(_L("RSgImage generic panic test - GetInfo() with invalid image handle\r\n"));

   196 	TestPanicImageGetInfoInvalidHandleL();

   197 	RecordTestResultL();

   198 	

   199 	SetTestStepID(_L("GRAPHICS-RESOURCE-0059"));

   200 	INFO_PRINTF1(_L("RSgImage generic panic test - GetInfo() with non null image handle and uninitialised driver\r\n"));

   201 	TestPanicImageGetInfoNoDriverL();

   202 	RecordTestResultL();

   203 	

   204 	SetTestStepID(_L("GRAPHICS-RESOURCE-0060"));

   205 	INFO_PRINTF1(_L("RSgImage generic panic test - MapReadOnly() with invalid image handle\r\n"));

   206 	TestPanicImageMapReadOnlyInvalidHandleL();

   207 	RecordTestResultL();

   208 	

   209 	SetTestStepID(_L("GRAPHICS-RESOURCE-0061"));

   210 	INFO_PRINTF1(_L("RSgImage generic panic test - MapReadOnly() with non null image handle and uninitialised driver\r\n"));

   211 	TestPanicImageMapReadOnlyNoDriverL();

   212 	RecordTestResultL();

   213 	

   214 	SetTestStepID(_L("GRAPHICS-RESOURCE-0062"));

   215 	INFO_PRINTF1(_L("RSgImage generic panic test - MapWriteOnly() with invalid image handle\r\n"));

   216 	TestPanicImageMapWriteOnlyInvalidHandleL();

   217 	RecordTestResultL();

   218 	

   219 	SetTestStepID(_L("GRAPHICS-RESOURCE-0063"));

   220 	INFO_PRINTF1(_L("RSgImage generic panic test - MapWriteOnly() with non null image handle and uninitialised driver\r\n"));

   221 	TestPanicImageMapWriteOnlyNoDriverL();

   222 	RecordTestResultL();

   223 	

   224 	SetTestStepID(_L("GRAPHICS-RESOURCE-0064"));

   225 	INFO_PRINTF1(_L("RSgImage generic panic test - MapReadWrite() with invalid image handle\r\n"));

   226 	TestPanicImageMapReadWriteInvalidHandleL();

   227 	RecordTestResultL();

   228 	

   229 	SetTestStepID(_L("GRAPHICS-RESOURCE-0065"));

   230 	INFO_PRINTF1(_L("RSgImage generic panic test - MapReadWrite() with non null image handle and uninitialised driver\r\n"));

   231 	TestPanicImageMapReadWriteNoDriverL();

   232 	RecordTestResultL();

   233 

   234 	SetTestStepID(_L("GRAPHICS-RESOURCE-0066"));

   235 	INFO_PRINTF1(_L("RSgImage generic panic test - Unmap() with invalid image handle\r\n"));

   236 	TestPanicImageUnmapInvalidHandleL();

   237 	RecordTestResultL();

   238 

   239 	SetTestStepID(_L("GRAPHICS-RESOURCE-0067"));

   240 	INFO_PRINTF1(_L("RSgImage generic panic test - Unmap() with non null image handle and uninitialised driver\r\n"));

   241 	TestPanicImageUnmapNoDriverL();

   242 	RecordTestResultL();

   243 	

   244 	SetTestStepID(_L("GRAPHICS-RESOURCE-0082"));

   245 	INFO_PRINTF1(_L("RSgImage generic panic test - Open() with an uninitialised driver\r\n"));

   246 	TestPanicImageOpenNoDriver1L();

   247 	RecordTestResultL();

   248 	

   249 	SetTestStepID(_L("GRAPHICS-RESOURCE-0093"));

   250 	INFO_PRINTF1(_L("RSgImage generic panic test - Open() with a mode flag with an uninitialised driver\r\n"));

   251 	TestPanicImageOpenNoDriver2L();

   252 	RecordTestResultL();

   253 	

   254 	SetTestStepID(_L("GRAPHICS-RESOURCE-0083"));

   255 	INFO_PRINTF1(_L("RSgImage generic panic test - Create() from memory with an uninitialised driver\r\n"));

   256 	TestPanicImageCreateNoDriver1L();

   257 	RecordTestResultL();

   258 	

   259 	SetTestStepID(_L("GRAPHICS-RESOURCE-0084"));

   260 	INFO_PRINTF1(_L("RSgImage generic panic test - Create() from existing image with an uninitialised driver\r\n"));

   261 	TestPanicImageCreateNoDriver2L();

   262 	RecordTestResultL();

   263 	

   264 	SetTestStepID(_L("GRAPHICS-RESOURCE-0085"));

   265 	INFO_PRINTF1(_L("RSgImage generic panic test - GetPixelFormats() with an uninitialised driver\r\n"));	

   266 	TestPanicImageGetPixelFormatsNoDriverL();

   267 	RecordTestResultL();

   268 	

   269 	SetTestStepID(_L("GRAPHICS-RESOURCE-0088"));

   270 	INFO_PRINTF1(_L("RSgImage generic panic test - DrawableType() with an uninitialised driver\r\n"));	

   271 	TestPanicImageDrawableTypeNoDriverL();

   272 	RecordTestResultL();

   273 	

   274 	SetTestStepID(_L("GRAPHICS-RESOURCE-0089"));

   275 	INFO_PRINTF1(_L("RSgImage generic panic test - DrawableType() with invalid image handle\r\n"));	

   276 	TestPanicImageDrawableTypeInvalidHandleL();

   277 	RecordTestResultL();

   278 #else

   279 	INFO_PRINTF1(_L("Warning: Skipping the panic tests in release build. \r\n"));

   280 #endif	

   281 	return TestStepResult();

   282 	}

   283 

   284 /**

   285 @SYMTestCaseID			GRAPHICS-RESOURCE-0003

   286 @SYMTestCaseDesc		Gets supported pixel formats on all platforms.

   287 @SYMPREQ				PREQ39

   288 @SYMREQ					REQ8809

   289 @SYMREQ					REQ9175

   290 @SYMREQ					REQ9224 

   291 @SYMREQ					REQ9233  

   292 @SYMREQ					REQ9234

   293 @SYMFssID				RSgImage::GetPixelFormats(const TSgImageInfo&, TUidPixelFormat*, TInt&)

   294 @SYMTestPriority		Critical

   295 @SYMTestType			Unit Test

   296 @SYMTestPurpose			To ensure all the available pixel formats are returned 

   297 						in the array and the actual number of pixel formats in

   298 						the input/output aCount parameter.

   299 @SYMTestActions			Initialise the graphics resource component. Construct a

   300 						TSgImageInfo object and Initialise the member variables.

   301 						Construct a TInt array of size\n

   302 						\t 1. NULL\n						

   303 						\t 2. greater than the number of supported pixel formats\n

   304 						\t 3. equal to the number of supported pixel formats\n

   305 						\t 4. less than the number of supported pixel formats

   306 @SYMTestExpectedResults	The function must return\n

   307 						\t 1. KErrNone\n

   308 						\t 2. KErrNone\n

   309 						\t 3. KErrNone\n

   310 						\t 4. KErrOverFlow\n

   311 						The supported pixel formats are populated into the array

   312 						and aCount stores the actual number of supported pixel formats.

   313 						The returned pixel formats should cover the pixel formats

   314 						in the image compatibility table that works on all platforms.

   315 @SYMTestStatus			Implemented 

   316  */

   317 void CTSgImageGeneric::TestGetPixelFormatsL()

   318 	{

   319 	TestOpenDriverL();

   320 	TSgImageInfo info;

   321 	info.iSizeInPixels = TSize(10, 10);

   322 	info.iCpuAccess = ESgCpuAccessNone;

   323 	info.iUsage = ESgUsageDirectGdiSource;

   324 	info.iShareable = EFalse;

   325 	info.iScreenId = 0;

   326 		

   327 	TInt numPixelFormats = 0;

   328 	//NULL array

   329 	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(info, NULL, numPixelFormats), (TText8*)__FILE__, __LINE__);

   330 	TEST(numPixelFormats > 1);

   331 	

   332 	//array length bigger than available pixel formats

   333 	TInt count = numPixelFormats + 10;

   334 	TUidPixelFormat* pixelFormatArray = new(ELeave) TUidPixelFormat[count];

   335 	CleanupArrayDeletePushL(pixelFormatArray);

   336 	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(info, pixelFormatArray, count), (TText8*)__FILE__, __LINE__);

   337 	TEST(count == numPixelFormats);

   338 	

   339 	info.iScreenId = -1;

   340 	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(info, pixelFormatArray, count), (TText8*)__FILE__, __LINE__);

   341 	TEST(count == numPixelFormats);

   342 	

   343 	info.iScreenId = 0;	

   344 	CleanupStack::PopAndDestroy(pixelFormatArray);

   345 	//array length is equal to the supported pixel formats

   346 	count = numPixelFormats;

   347 	pixelFormatArray = new(ELeave) TUidPixelFormat[count];

   348 	CleanupArrayDeletePushL(pixelFormatArray);

   349 	

   350 	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(info, pixelFormatArray, count), (TText8*)__FILE__, __LINE__);

   351 	TEST(count == numPixelFormats);

   352 	

   353 	CleanupStack::PopAndDestroy(pixelFormatArray);

   354 	//array length is smaller than the supported pixel formats

   355 	count = numPixelFormats - 1;

   356 	pixelFormatArray = new(ELeave) TUidPixelFormat[count];

   357 	CleanupArrayDeletePushL(pixelFormatArray);

   358 	TEST(KErrOverflow == RSgImage::GetPixelFormats(info, pixelFormatArray, count));

   359 	TEST(count == numPixelFormats);

   360 	CleanupStack::PopAndDestroy(pixelFormatArray);

   361 	

   362 	//check all the pixel formats returned are in the common compatibility guarantees table

   363 	TestGetPixelFormatCompatibilityGuaranteesL();

   364 	

   365 	//reset the array used by the GetPixelFormats function to prevent memory leaks

   366 	info.iCpuAccess = ESgCpuAccessReadWrite;

   367 	info.iScreenId = 100;

   368 	TEST(KErrNone == RSgImage::GetPixelFormats(info, NULL, count));

   369 	TEST(count == 0);

   370 	

   371 	TestCloseDriver();

   372 	}

   373 

   374 /**

   375 @SYMTestCaseID			GRAPHICS-RESOURCE-0004

   376 @SYMTestCaseDesc		Creates an uninitialised image.

   377 @SYMPREQ				PREQ39

   378 @SYMREQ					REQ8809

   379 @SYMREQ					REQ9175

   380 @SYMREQ					REQ9224 

   381 @SYMREQ					REQ9233  

   382 @SYMREQ					REQ9234

   383 @SYMFssID				RSgImage::Create(const TSgImageInfo&, const TAny*, TInt)\n 

   384 						RSgImage::IsNull()

   385 @SYMTestPriority		Critical

   386 @SYMTestType			Unit Test

   387 @SYMTestPurpose			To ensure an uninitialised image can be created.

   388 @SYMTestActions			Initialise the graphics resource component. Construct well-defined 

   389 						TSgImageInfo objects that work on all platforms. Create an image 

   390 						with a NULL base address for each of the TSgImageInfo object.

   391 @SYMTestExpectedResults	The function should return KErrNone in all cases. The created images

   392 						are uninitialised.

   393 @SYMTestStatus			Implemented 

   394  */	

   395 void CTSgImageGeneric::TestCreateImageUninitializedL()

   396 	{	

   397 	TestOpenDriverL();

   398 	TSgImageInfo info;

   399 	info.iSizeInPixels = TSize(100, 100);

   400 	info.iUsage = ESgUsageDirectGdiTarget;

   401 	info.iPixelFormat = EUidPixelFormatRGB_565;

   402 	

   403 	RSgImage image;	

   404 	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);

   405 	CleanupClosePushL(image);

   406 	

   407 	CleanupStack::PopAndDestroy();

   408 	TestCloseDriver();

   409 	}

   410 

   411 

   412 /**

   413 @SYMTestCaseID			GRAPHICS-RESOURCE-0005

   414 @SYMTestCaseDesc		Creates an image from a block of memory.

   415 @SYMPREQ				PREQ39

   416 @SYMREQ					REQ8809

   417 @SYMREQ					REQ9175

   418 @SYMREQ					REQ9224 

   419 @SYMREQ					REQ9233  

   420 @SYMREQ					REQ9234

   421 @SYMFssID				RSgImage::Create(const TSgImageInfo&, const TAny*, TInt)\n 

   422 						RSgImage::IsNull()

   423 @SYMTestPriority		Critical

   424 @SYMTestType			Unit Test

   425 @SYMTestPurpose			To ensure images can be created from a block of memory.

   426 @SYMTestActions			Initialise the graphics resource component. Construct well-defined 

   427 						TSgImageInfo objects that work on all platforms. Create a block of

   428 						memory with or without initialised data. Then create an image with 

   429 						the starting address of that memory.

   430 @SYMTestExpectedResults	The function should return KErrNone in all cases. The user data starting

   431 						at address aDataAddress will be populated into the new image.

   432 @SYMTestStatus			Implemented 

   433  */	

   434 void CTSgImageGeneric::TestCreateImageL()

   435 	{	

   436 	TestOpenDriverL();

   437 	TSgImageInfo info;

   438 	info.iSizeInPixels = TSize(8, 8);

   439 	info.iPixelFormat = EUidPixelFormatRGB_565;

   440 	info.iUsage = ESgUsageDirectGdiSource;

   441 	info.iShareable = ETrue;

   442 	

   443 	RSgImage image;

   444 	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);

   445 	CleanupClosePushL(image);

   446 	CleanupStack::PopAndDestroy();	

   447 #ifdef __WINS__	

   448 	//create an image with usage set to screen source

   449 	TSize screenSize;

   450 	if(HAL::Get(info.iScreenId, HALData::EDisplayXPixels, screenSize.iWidth) == KErrNone

   451 		&& HAL::Get(info.iScreenId, HALData::EDisplayYPixels, screenSize.iHeight) == KErrNone)

   452 		{

   453 		info.iUsage = ESgUsageScreenSource;

   454 		info.iScreenId = KSgScreenIdMain;

   455 		info.iSizeInPixels = TSize(screenSize.iWidth, screenSize.iHeight);

   456 		CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);

   457 		CleanupClosePushL(image);

   458 		CleanupStack::PopAndDestroy();

   459 		

   460 		info.iSizeInPixels = TSize(screenSize.iHeight, screenSize.iWidth);

   461 		CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);

   462 		CleanupClosePushL(image);

   463 		CleanupStack::PopAndDestroy();

   464 		}

   465 #endif	

   466 	//create an image with some user attributes

   467 	TSgUserAttribute testAttributes[] = {{0x00008888, 1}, {0x00009999, 2}};

   468 	info.iUserAttributes = testAttributes;

   469 	info.iUserAttributeCount = 2;

   470 	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);

   471 	CleanupClosePushL(image);

   472 	CleanupStack::PopAndDestroy();

   473 	

   474 	TestCloseDriver();

   475 	}

   476 

   477 /**

   478 @SYMTestCaseID			GRAPHICS-RESOURCE-0006

   479 @SYMTestCaseDesc		Creates an image from an existing image.

   480 @SYMPREQ				PREQ39

   481 @SYMREQ					REQ8809

   482 @SYMREQ					REQ9175

   483 @SYMREQ					REQ9192

   484 @SYMREQ					REQ9224 

   485 @SYMREQ					REQ9233  

   486 @SYMREQ					REQ9234

   487 @SYMFssID				RSgImage::Create(const TSgImageInfo&, const RSgImage&)

   488 @SYMTestPriority		Critical

   489 @SYMTestType			Unit Test

   490 @SYMTestPurpose			To ensure images can be created from existing images.

   491 @SYMTestActions			Initialise the graphics resource component. Create an image. Create another

   492 						image with the attributes of this image as the TSgImageInfo.

   493 @SYMTestExpectedResults	The function should return KErrNone. The new image should be identical to

   494 						the old one. 

   495 @SYMTestStatus			Implemented 

   496  */	

   497 void CTSgImageGeneric::TestCreateImageFromExistingImageL()

   498 	{

   499 	RSgImage image1;

   500 	RSgImage image2;

   501 	TSgImageInfo info;

   502 	

   503 	TestOpenDriverL();		

   504 	CreateImageL(image1);

   505 	CleanupClosePushL(image1);

   506 	TEST(KErrNone == image1.GetInfo(info));

   507 	CheckErrorL(KErrNone, image2.Create(info, image1), (TText8*)__FILE__, __LINE__);

   508 	CleanupClosePushL(image2);

   509 	TSgImageInfo info2;

   510 	TEST(KErrNone == image2.GetInfo(info2));

   511 	TEST(CompareInfos(info, info2));

   512 	CleanupStack::PopAndDestroy(2);

   513 	TestCloseDriver();

   514 	}

   515 

   516 

   517 /**

   518 @SYMTestCaseID			GRAPHICS-RESOURCE-0007

   519 @SYMTestCaseDesc		Calls GetInfo on an image.

   520 @SYMPREQ				PREQ39

   521 @SYMREQ					REQ8809

   522 @SYMREQ					REQ9175

   523 @SYMREQ					REQ9224 

   524 @SYMREQ					REQ9233  

   525 @SYMREQ					REQ9234

   526 @SYMFssID				RSgImage::GetInfo(TSgImageInfo&)

   527 @SYMTestPriority		Critical

   528 @SYMTestType			Unit Test

   529 @SYMTestPurpose			To ensure the information about the image is correct.

   530 @SYMTestActions			Initialise the graphics resource component. Construct a TSgImageInfo object

   531 						and Initialise all the member variables. Create images without and with

   532 						user attributes. Call GetInfo() and compare the resulting TSgImageInfo objects 

   533 						with the previous ones.

   534 @SYMTestExpectedResults	The function should return KErrNone. Information about the image object

   535 						is stored in the aInfo parameter. The retrieved TSgImageInfo objects should be 

   536 						identical to the original ones.

   537 @SYMTestStatus			Implemented 

   538  */	

   539 void CTSgImageGeneric::TestGetImageInfoL()

   540 	{

   541 	TestOpenDriverL();

   542 	TSgImageInfo info;

   543 	info.iPixelFormat = EUidPixelFormatRGB_565;

   544 	info.iSizeInPixels = TSize(100, 100);

   545 	info.iUsage = ESgUsageDirectGdiTarget;

   546 	

   547 	RSgImage image;

   548 	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);

   549 	CleanupClosePushL(image);

   550 	

   551 	TSgImageInfo info2;

   552 	TEST(KErrNone == image.GetInfo(info2));

   553 	TEST(CompareInfos(info, info2));

   554 	CleanupStack::PopAndDestroy();

   555 	

   556 	//get info of image with user attributes

   557 	TSgUserAttribute testAttributes[] = {{0x00008888, 1}, {0x00009999, 2}};

   558 	info.iUserAttributes = testAttributes;

   559 	info.iUserAttributeCount = 2;

   560 	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);

   561 	CleanupClosePushL(image);

   562 	TSgImageInfo info3;

   563 	TSgUserAttribute testAttributes2[2];

   564 	testAttributes2[0].iUid = TUid::Uid(0x00008888);

   565 	testAttributes2[1].iUid = TUid::Uid(0x00009999);

   566 	info3.iUserAttributes = testAttributes2;

   567 	info3.iUserAttributeCount = 2;

   568 	TEST(KErrNone == image.GetInfo(info3));

   569 	TEST(CompareInfos(info, info3));	

   570 	CleanupStack::PopAndDestroy();

   571 	

   572 	info.iShareable = ETrue;

   573 	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);

   574 	CleanupClosePushL(image);

   575 	TEST(KErrNone == image.GetInfo(info3));

   576 	TEST(CompareInfos(info, info3));

   577 	CleanupStack::PopAndDestroy();

   578 	

   579 	TestCloseDriver();

   580 	}

   581 

   582 /**

   583 @SYMTestCaseID			GRAPHICS-RESOURCE-0008

   584 @SYMTestCaseDesc		Retrieves drawable id and drawable type of an image.

   585 @SYMPREQ				PREQ39

   586 @SYMREQ					REQ8809

   587 @SYMREQ					REQ9175

   588 @SYMREQ					REQ9224 

   589 @SYMREQ					REQ9233  

   590 @SYMREQ					REQ9234

   591 @SYMFssID				RSgImage::Id()\n

   592 						RSgImage::DrawableType()

   593 @SYMTestPriority		Critical

   594 @SYMTestType			Unit Test

   595 @SYMTestPurpose			To ensure the globally unique drawable id of the image can be retrieved.

   596 @SYMTestActions			Initialise the graphics resource component. Create an image. Call

   597 						Id() to retrieve its drawable id.

   598 @SYMTestExpectedResults	A valid drawable id should be successfully returned.

   599 @SYMTestStatus			Implemented 

   600  */	

   601 void CTSgImageGeneric::TestGetImageDrawableIdL()

   602 	{	

   603 	RSgImage image;

   604 	TEST(KNullUid == image.DrawableType());

   605 	TSgDrawableId id = image.Id();

   606 	TEST(id == KSgNullDrawableId);

   607 	TestOpenDriverL();	

   608 	CreateImageL(image);

   609 	CleanupClosePushL(image);

   610 	id = image.Id();

   611 	TEST(id != KSgNullDrawableId);	

   612 	TEST(KSgImageTypeUid == image.DrawableType());

   613 

   614 	CleanupStack::PopAndDestroy();

   615 	TestCloseDriver();

   616 	}

   617 

   618 /**

   619 @SYMTestCaseID			GRAPHICS-RESOURCE-0009

   620 @SYMTestCaseDesc		Maps and unmaps an image from its creator process.

   621 @SYMPREQ				PREQ39

   622 @SYMREQ					REQ8809

   623 @SYMREQ					REQ9175

   624 @SYMREQ					REQ9193

   625 @SYMREQ					REQ9224 

   626 @SYMREQ					REQ9233  

   627 @SYMREQ					REQ9234

   628 @SYMFssID				RSgImage::MapReadOnly(const TAny*&, TInt&) const\n

   629  						RSgImage::MapWriteOnly(TAny*&, TInt&)\n 

   630 						RSgImage::MapReadWrite(TAny*&, TInt&)\n 

   631 						RSgImage::Unmap()

   632 						by its creator process.

   633 @SYMTestPriority		Critical

   634 @SYMTestType			Unit Test

   635 @SYMTestPurpose			To ensure an image can be successfully mapped and unmapped

   636 @SYMTestActions			Initialise the graphics resource component. Create mappable images

   637 						with different TSgImageInfo values. Call different map functions the Unmap()

   638 						function on each of them.

   639 @SYMTestExpectedResults	All the functions should return KErrNone.

   640 @SYMTestStatus			Implemented 

   641  */	

   642 void CTSgImageGeneric::TestMapImageL()

   643 	{

   644 	TestOpenDriverL();

   645 	RSgImage image;

   646 	TSgImageInfo info;

   647 	info.iSizeInPixels = TSize(8, 8);

   648 	info.iPixelFormat = EUidPixelFormatRGB_565;

   649 	info.iUsage = ESgUsageDirectGdiSource;

   650 	info.iCpuAccess = ESgCpuAccessReadOnly;

   651 	

   652 	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);

   653 	CleanupClosePushL(image);

   654 	

   655 	//test MapReadOnly

   656 	const TAny* dataAddress;

   657 	TInt dataStride;	

   658 	TInt mapResult = image.MapReadOnly(dataAddress, dataStride);

   659 	TEST(KErrNone == mapResult);

   660 	if(KErrNone == mapResult)

   661 		{

   662 		for (TInt y = 0; y < 8; ++y)

   663 			for (TInt x = 0; x < 8; ++x)

   664 				{

   665 				TUint16 pixelValue = *(TUint16*)PtrAdd(dataAddress, sizeof(TUint16) * x + dataStride * y);

   666 				if (pixelValue != 0x7E0)

   667 					{

   668 					TEST(EFalse);

   669 					break;

   670 					}

   671 				}

   672 		}

   673 	TEST(KErrNone == image.Unmap());

   674 	CleanupStack::PopAndDestroy(&image);

   675 	

   676 	//test MapWriteOnly

   677 	TAny* dataAddress1;

   678 	

   679 	info.iCpuAccess = ESgCpuAccessWriteOnly;

   680 	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);

   681 	CleanupClosePushL(image);

   682 	mapResult = image.MapWriteOnly(dataAddress1, dataStride);

   683 	TEST(KErrNone == mapResult);

   684 	//change the second line to red

   685 	if(KErrNone == mapResult)

   686 		{

   687 		for(TInt x = 0; x < 8; ++x)

   688 			{

   689 			*(TUint16*)PtrAdd(dataAddress1, sizeof(TUint16) * x + dataStride * 1) = 0xF800;

   690 			}

   691 		}

   692 	TEST(KErrNone == image.Unmap());

   693 	

   694 	//check if the modification is successful	

   695 	//create another image from the existing one and map it as read only

   696 	info.iCpuAccess = ESgCpuAccessReadOnly;

   697 	RSgImage image1;

   698 	CheckErrorL(KErrNone, image1.Create(info, image), (TText8*)__FILE__, __LINE__);

   699 	CleanupClosePushL(image1);

   700 	mapResult = image1.MapReadOnly(dataAddress, dataStride);

   701 	TEST(mapResult == KErrNone);

   702 	if(mapResult == KErrNone)

   703 		{

   704 		for(TInt x = 0; x < 8; ++x)

   705 			{

   706 			TUint16 pixelValue = *(TUint16*)PtrAdd(dataAddress, sizeof(TUint16) * x + dataStride * 1);

   707 			if(pixelValue != 0xF800)

   708 				{

   709 				TEST(EFalse);

   710 				break;

   711 				}

   712 			}

   713 		}

   714 	

   715 	TEST(KErrNone == image1.Unmap());

   716 	CleanupStack::PopAndDestroy(2, &image);

   717 	

   718 	//test MapReadWrite

   719 	info.iCpuAccess = ESgCpuAccessReadWrite;

   720 	CheckErrorL(KErrNone, image.Create(info, KImageData, 16), (TText8*)__FILE__, __LINE__);

   721 	CleanupClosePushL(image);

   722 	mapResult = image.MapReadWrite(dataAddress1, dataStride);

   723 	TEST(KErrNone == mapResult);

   724 	

   725 	if(KErrNone == mapResult)

   726 		{

   727 		//modify the image, set first line to blue

   728 		for(TInt x = 0; x < 8; ++x)

   729 			{

   730 			*(TUint16*)PtrAdd(dataAddress1, sizeof(TUint16) * x) = 0x1F;

   731 			}

   732 		

   733 		//check the modification

   734 		for(TInt x = 0; x < 8; ++x)

   735 			{

   736 			TUint16 pixelValue = *(TUint16*)PtrAdd(dataAddress1, sizeof(TUint16) * x);

   737 			if(pixelValue != 0x1F)

   738 				{

   739 				TEST(EFalse);

   740 				break;

   741 				}

   742 			}

   743 		}

   744 	

   745 	TEST(KErrNone == image.Unmap());	

   746 	CleanupStack::PopAndDestroy();

   747 	TestCloseDriver();

   748 	}

   749 

   750 /**

   751 @SYMTestCaseID			GRAPHICS-RESOURCE-0010

   752 @SYMTestCaseDesc		Opens a handle to an image in both the current process and another process.

   753 @SYMPREQ				PREQ39

   754 @SYMREQ					REQ8809

   755 @SYMREQ					REQ9175

   756 @SYMREQ					REQ9224 

   757 @SYMREQ					REQ9233  

   758 @SYMREQ					REQ9234

   759 @SYMFssID				RSgImage::Open(const TSgDrawableId&)

   760 @SYMTestPriority		Critical

   761 @SYMTestType			Unit Test

   762 @SYMTestPurpose			To ensure image can be opened in both a second thread in the current 

   763 						process and another process.

   764 @SYMTestActions			Initialise the graphics resource component. Create a shareable image and

   765 						a non-shareable image. Open() the image in the second thread in the current 

   766 						process and in another process.

   767 						Check various image attributes.

   768 @SYMTestExpectedResults	The function must return KErrNone in both cases.

   769 @SYMTestStatus			Implemented 

   770  */	

   771 void CTSgImageGeneric::TestOpenImageL()

   772 	{	

   773 	TestOpenDriverL();

   774 	

   775 	//shareable image

   776 	RSgImage image1;

   777 	TSgImageInfo info1;

   778 	info1.iSizeInPixels = TSize(8, 8);

   779 	info1.iUsage = ESgUsageDirectGdiSource;

   780 	info1.iPixelFormat = EUidPixelFormatRGB_565;

   781 	info1.iCpuAccess = ESgCpuAccessReadWrite;

   782 	info1.iShareable = ETrue;

   783 	CheckErrorL(KErrNone, image1.Create(info1, KImageData, 16), (TText8*)__FILE__, __LINE__);

   784 	CleanupClosePushL(image1);

   785 	

   786 	//non-shareable image

   787 	RSgImage image2;

   788 	TSgImageInfo info2;

   789 	info2.iSizeInPixels = TSize(8, 8);

   790 	info2.iUsage = ESgUsageDirectGdiSource;

   791 	info2.iPixelFormat = EUidPixelFormatRGB_565;

   792 	info2.iCpuAccess = ESgCpuAccessReadWrite;

   793 	info2.iShareable = EFalse;	

   794 	CheckErrorL(KErrNone, image2.Create(info2, KImageData, 16), (TText8*)__FILE__, __LINE__);

   795 	CleanupClosePushL(image2);

   796 	

   797 	const TSgDrawableId id1 = image1.Id();

   798 	const TSgDrawableId id2 = image2.Id();	

   799 	

   800 	//opening image in the current thread

   801 	RSgImage image3;

   802 	TEST(KErrNone == image3.Open(id1));

   803 	image3.Close();

   804 	TEST(KErrNone == image3.Open(id2));

   805 	image3.Close();

   806 	

   807 	//opening image in a second thread in the current process

   808 	TSgresTestInfo threadInfo = {id1, info1, 0, ESgresSecondThreadOpenImage};

   809 	TInt testResult = CreateSecondThreadAndDoTestL(threadInfo);	

   810 	// Test the results from the second thread

   811 	User::LeaveIfError(testResult);

   812 	TEST(testResult & EFirstTestPassed);

   813 	TEST(testResult & ESecondTestPassed);

   814 	TEST(testResult & EThirdTestPassed);

   815 	TEST(testResult & EFourthTestPassed);

   816 	TEST(testResult & EFifthTestPassed);

   817 	

   818 	threadInfo.iDrawableId = id2;

   819 	threadInfo.iImageInfo = info2;

   820 	testResult = CreateSecondThreadAndDoTestL(threadInfo);	

   821 	// Test the results from the second thread

   822 	User::LeaveIfError(testResult);

   823 	TEST(testResult & EFirstTestPassed);

   824 	TEST(testResult & ESecondTestPassed);

   825 	TEST(testResult & EThirdTestPassed);

   826 	TEST(testResult & EFourthTestPassed);

   827 	TEST(testResult & EFifthTestPassed);

   828 		

   829 	//opening image in a second process	

   830 	TSgresTestInfo processInfo = {id1, info1, 0, ESgresSecondProcessOpenImage};

   831 	testResult = CreateSecondProcessAndDoTestL(KSecondProcess, processInfo);	

   832 	User::LeaveIfError(testResult);

   833 	TEST(testResult & EFirstTestPassed);	

   834 	TEST(testResult & ESecondTestPassed);

   835 	TEST(testResult & EThirdTestPassed);

   836 	TEST(testResult & EFourthTestPassed);

   837 

   838 	CleanupStack::PopAndDestroy(2, &image1);

   839 	TestCloseDriver();

   840 	}

   841 

   842 class MFake

   843 	{

   844 public:

   845 	enum { EInterfaceUid = 0x88888888 };

   846 	};

   847 

   848 /**

   849 @SYMTestCaseID			GRAPHICS-RESOURCE-0011

   850 @SYMTestCaseDesc		Opens a handle to an image with mode flags.

   851 @SYMPREQ				PREQ39

   852 @SYMREQ					REQ8809

   853 @SYMREQ					REQ9175

   854 @SYMREQ					REQ9224 

   855 @SYMREQ					REQ9233  

   856 @SYMREQ					REQ9234

   857 @SYMFssID				RSgImage::Open(const TSgDrawableId&, TUint32)

   858 @SYMTestPriority		Critical

   859 @SYMTestType			Unit Test

   860 @SYMTestPurpose			To ensure image can be opened with mode flags.

   861 @SYMTestActions			Initialise the graphics resource component. Create an image and

   862 						call Open() on the image with flag ESgDoNotRestrictUsage. Call

   863 						GetInfo() on the opened image and check the usage bit. Declare another

   864 						image object and call Open() on it with the Id of the previously

   865 						opened handle and without mode flags. Call GetInfo() on this image

   866 						and check the usage bit.

   867 @SYMTestExpectedResults	Both infos should contain all the possible usages supported by

   868  						the underlying implementation.						

   869 @SYMTestStatus			Implemented 

   870  */	

   871 void CTSgImageGeneric::TestOpenImageInternalL()

   872 	{

   873 	TestOpenDriverL();

   874 	

   875 	//shareable image

   876 	RSgImage shareableImage;

   877 	TSgImageInfo shareableInfo;

   878 	shareableInfo.iSizeInPixels = TSize(8, 8);

   879 	shareableInfo.iUsage = ESgUsageDirectGdiSource;

   880 	shareableInfo.iPixelFormat = EUidPixelFormatRGB_565;

   881 	shareableInfo.iCpuAccess = ESgCpuAccessReadWrite;

   882 	shareableInfo.iShareable = ETrue;	

   883 	CheckErrorL(KErrNone, shareableImage.Create(shareableInfo, KImageData, 16), (TText8*)__FILE__, __LINE__);

   884 	CleanupClosePushL(shareableImage);

   885 		

   886 	RSgImage image1;

   887 	CheckErrorL(KErrNone, image1.Open(shareableImage.Id(), ESgDoNotRestrictUsage), (TText8*)__FILE__, __LINE__);

   888 	CleanupClosePushL(image1);

   889 	TSgImageInfo info1;

   890 	image1.GetInfo(info1);	

   891 	TEST(ESgUsageDirectGdiSource | info1.iUsage);

   892 	TEST(ESgUsageCompositionSource | info1.iUsage);

   893 	TEST(ESgUsageOpenGlesTexture2D | info1.iUsage);

   894 	TEST(ESgUsageOpenGles2Texture2D | info1.iUsage);

   895 	TEST(ESgUsageOpenVgImage | info1.iUsage);

   896 	

   897 	RSgImage image2;

   898 	CheckErrorL(KErrNone, image2.Open(image1.Id()), (TText8*)__FILE__, __LINE__);

   899 	CleanupClosePushL(image2);

   900 	TSgImageInfo info2;

   901 	image2.GetInfo(info2);

   902 	TEST(ESgUsageDirectGdiSource | info2.iUsage);

   903 	TEST(ESgUsageCompositionSource | info2.iUsage);

   904 	TEST(ESgUsageOpenGlesTexture2D | info2.iUsage);

   905 	TEST(ESgUsageOpenGles2Texture2D | info2.iUsage);

   906 	TEST(ESgUsageOpenVgImage | info2.iUsage);

   907 	

   908 	//non-shareable image

   909 	RSgImage nonshareableImage;

   910 	TSgImageInfo nonshareableInfo;

   911 	nonshareableInfo.iSizeInPixels = TSize(8, 8);

   912 	nonshareableInfo.iUsage = ESgUsageDirectGdiSource;

   913 	nonshareableInfo.iPixelFormat = EUidPixelFormatRGB_565;

   914 	nonshareableInfo.iCpuAccess = ESgCpuAccessReadWrite;

   915 	nonshareableInfo.iShareable = EFalse;	

   916 	CheckErrorL(KErrNone, nonshareableImage.Create(nonshareableInfo, KImageData, 16), (TText8*)__FILE__, __LINE__);

   917 	CleanupClosePushL(nonshareableImage);

   918 	

   919 	RSgImage image3;

   920 	CheckErrorL(KErrNone, image3.Open(nonshareableImage.Id(), ESgDoNotRestrictUsage), (TText8*)__FILE__, __LINE__);

   921 	CleanupClosePushL(image3);

   922 	TSgImageInfo info3;

   923 	image3.GetInfo(info3);	

   924 	TEST(ESgUsageDirectGdiSource | info3.iUsage);

   925 	TEST(ESgUsageCompositionSource | info3.iUsage);

   926 	TEST(ESgUsageOpenGlesTexture2D | info3.iUsage);

   927 	TEST(ESgUsageOpenGles2Texture2D | info3.iUsage);

   928 	TEST(ESgUsageOpenVgImage | info3.iUsage);

   929 	

   930 	RSgImage image4;

   931 	CheckErrorL(KErrNone, image4.Open(image3.Id()), (TText8*)__FILE__, __LINE__);

   932 	CleanupClosePushL(image4);

   933 	TSgImageInfo info4;

   934 	image4.GetInfo(info4);

   935 	TEST(ESgUsageDirectGdiSource | info4.iUsage);

   936 	TEST(ESgUsageCompositionSource | info4.iUsage);

   937 	TEST(ESgUsageOpenGlesTexture2D | info4.iUsage);

   938 	TEST(ESgUsageOpenGles2Texture2D | info4.iUsage);

   939 	TEST(ESgUsageOpenVgImage | info4.iUsage);

   940 	

   941 	CleanupStack::PopAndDestroy(6, &shareableImage);

   942 	TestCloseDriver();

   943 	}

   944 

   945 /**

   946 @SYMTestCaseID			GRAPHICS-RESOURCE-0044

   947 @SYMTestCaseDesc		Gets the interfaces implemented by CSgImageImpl class.

   948 @SYMPREQ				PREQ39

   949 @SYMREQ					REQ8809

   950 @SYMREQ					REQ9175

   951 @SYMREQ					REQ9224 

   952 @SYMREQ					REQ9233  

   953 @SYMREQ					REQ9234

   954 @SYMFssID				RSgImage::Create(const TSgImageInfo&, const TAny*, TInt)\n 

   955 						RSgImage::GetInterface()

   956 @SYMTestPriority		Critical

   957 @SYMTestType			Unit Test

   958 @SYMTestPurpose			To ensure the extension interfaces supported by RSgImage can be

   959 						returned. 

   960 @SYMTestActions			Initialise the graphics resource component. Create an image. Call

   961 						GetInterface() to return the MSgImage_Sw and MSgImage_Chunk interfaces.

   962 						Perform various operations on the interfaces. Declare a fake interface

   963 						MFake and call GetInterface() on the image handle.

   964 @SYMTestExpectedResults	The operations on the MSgImage_Sw and MSgImage_Chunk interfaces should

   965 						succeed. Trying to get the MFake interface should return KErrExtensionNotSupported.

   966 @SYMTestStatus			Implemented 

   967  */

   968 void CTSgImageGeneric::TestGetInterfaceL()

   969 	{

   970 	TestOpenDriverL();

   971 	

   972 	TSgImageInfo info;

   973 	info.iSizeInPixels = TSize(8, 8);

   974 	info.iUsage = ESgUsageDirectGdiSource;

   975 	info.iPixelFormat = EUidPixelFormatRGB_565;

   976 	info.iCpuAccess = ESgCpuAccessReadWrite;

   977 	info.iShareable = ETrue;

   978 	

   979 	RSgImage image;	

   980 	MSgImage_Sw* swInterface = NULL;

   981 	TEST(KErrBadHandle == image.GetInterface(swInterface));

   982 	

   983 	CheckErrorL(KErrNone, image.Create(info, NULL, 0), (TText8*)__FILE__, __LINE__);

   984 	CleanupClosePushL(image);

   985 	

   986 	// check TSgDrawableId is not NULL

   987 	TSgDrawableId id = image.Id();

   988 	TEST(KSgNullDrawableId != id);

   989 	

   990 	TAny* dataAddress1 = NULL;

   991 	TInt dataStride1 = 0;

   992 	TInt result1 = image.GetInterface(swInterface);

   993 	TEST(KErrNone == result1);

   994 	if(KErrNone == result1)

   995 		{		

   996 		// Fill the image with 0xF0

   997 		TInt sizeInBytes = 8 * 8 * 2;

   998 		TESTL(swInterface->BeginDataAccess(ESgCpuAccessNone) == KErrArgument);

   999 		TEST(swInterface->BeginDataAccess(ESgCpuAccessWriteOnly) == KErrNone);

  1000 		dataAddress1 = swInterface->DataAddress();

  1001 		dataStride1 = swInterface->DataStride();

  1002 		Mem::Fill(dataAddress1, sizeInBytes, 0xF0);

  1003 		TEST(swInterface->EndDataAccess() == KErrNone);

  1004 		

  1005 		//Map the image as read only and check if the previous operation is successful

  1006 		const TAny* dataAddressRead;

  1007 		TInt dataStride2;	

  1008 		TInt mapResult = image.MapReadOnly(dataAddressRead, dataStride2);

  1009 		TEST(KErrNone == mapResult);

  1010 		TEST(dataAddress1 == dataAddressRead);

  1011 		TEST(dataStride1 == dataStride2);

  1012 		if(KErrNone == mapResult)

  1013 			{

  1014 			for (TInt y = 0; y < 8; ++y)

  1015 				for (TInt x = 0; x < 8; ++x)

  1016 					{

  1017 					TUint16 pixelValue = *(TUint16*)PtrAdd(dataAddressRead, sizeof(TUint16) * x + dataStride2 * y);

  1018 					if (pixelValue != 0xF0F0)

  1019 						{

  1020 						TEST(EFalse);

  1021 						break;

  1022 						}

  1023 					}

  1024 			}

  1025 		TEST(KErrNone == image.Unmap());

  1026 		}

  1027 	

  1028 	MSgImage_Chunk* smChunk = NULL;

  1029 	TInt result2 = image.GetInterface(smChunk);

  1030 	TEST(KErrNone == result2);

  1031 	if(KErrNone == result2)

  1032 		{

  1033 		TAny* address = PtrAdd(smChunk->DataChunk().Base(), smChunk->DataOffset());

  1034 		TInt datastride = smChunk->DataStride();

  1035 		if(KErrNone == result1)

  1036 			{

  1037 			TEST(address == dataAddress1);

  1038 			TEST(datastride == dataStride1);

  1039 			}

  1040 		}

  1041 	

  1042 	//fake interface

  1043 	MFake* smFake = NULL;

  1044 	TEST(KErrExtensionNotSupported == image.GetInterface(smFake));

  1045 	

  1046 	CleanupStack::PopAndDestroy();

  1047 	TestCloseDriver();

  1048 	}

  1049 

  1050 /**

  1051 @SYMTestCaseID			GRAPHICS-RESOURCE-0024

  1052 @SYMTestCaseDesc		Gets supported pixel formats with invalid parameters.

  1053 @SYMPREQ				PREQ39

  1054 @SYMREQ					REQ8809

  1055 @SYMREQ					REQ9175

  1056 @SYMREQ					REQ9224 

  1057 @SYMREQ					REQ9233  

  1058 @SYMREQ					REQ9234

  1059 @SYMFssID				RSgImage::GetPixelFormats(const TSgImageInfo&, TUidPixelFormat*, TInt&)

  1060 @SYMTestPriority		Critical

  1061 @SYMTestType			Unit Test

  1062 @SYMTestPurpose			To ensure the correct error messages are returned when user tries to

  1063 						call GetPixelFormats() with invalid parameters.

  1064 @SYMTestActions			Initialise the graphics resource component. Call RSgImage::GetPixelFormats with:\n

  1065 						\t 1. invalid TSgImageInfo object, it could be any combinations of the following:\n

  1066 						\t \t negative width or height\n

  1067 						\t \t mutability incompatible with the specified CPU access and usage\n

  1068 						\t \t screen id < -1\n

  1069 						\t \t usage flag ESgUsageScreenSource with screen id -1\n

  1070 						\t 2. invalid aCount

  1071 @SYMTestExpectedResults	The function should return KErrArgument in both cases.

  1072 @SYMTestStatus			Implemented 

  1073  */	

  1074 void CTSgImageGeneric::TestGetPixelFormatsInvalidL()

  1075 	{

  1076 	TSgImageInfo info1;

  1077 	TInt count = 0;

  1078 	

  1079 	TestOpenDriverL();

  1080 	//negative width

  1081 	info1.iSizeInPixels = TSize(-100, 100);

  1082 	TEST(KErrArgument == RSgImage::GetPixelFormats(info1, NULL, count));

  1083 	

  1084 	//negative height

  1085 	TSgImageInfo info2;

  1086 	info2.iSizeInPixels = TSize(100, -100);

  1087 	TEST(KErrArgument == RSgImage::GetPixelFormats(info2, NULL, count));

  1088 	

  1089 	//invalid or non-existent screen id

  1090 	TSgImageInfo info5;

  1091 	info5.iSizeInPixels = TSize(8, 8);

  1092 	info5.iUsage = ESgUsageScreenSource;

  1093 	info5.iCpuAccess = ESgCpuAccessReadWrite;

  1094 	info5.iScreenId = -2;

  1095 	TEST(KErrArgument == RSgImage::GetPixelFormats(info5, NULL, count));

  1096 	info5.iScreenId = 100;

  1097 	TEST(KErrNone == RSgImage::GetPixelFormats(info5, NULL, count));

  1098 	TEST(count == 0);

  1099 	

  1100 	//usage flag ESgUsageScreenSource with screen id -1

  1101 	TSgImageInfo info6;

  1102 	info6.iSizeInPixels = TSize(8, 8);

  1103 	info6.iScreenId = -1;

  1104 	info6.iUsage = ESgUsageScreenSource;

  1105 	TEST(KErrArgument == RSgImage::GetPixelFormats(info6, NULL, count));

  1106 	

  1107 	//negative aCount

  1108 	TSgImageInfo info7;

  1109 	info7.iCpuAccess = ESgCpuAccessNone;

  1110 	info7.iShareable = EFalse;

  1111 	info7.iSizeInPixels = TSize(10, 10);

  1112 	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(info7, NULL, count), (TText8*)__FILE__, __LINE__);

  1113 	

  1114 	if(count > 0)

  1115 		{

  1116 		TUidPixelFormat* pixelFormatArray = new(ELeave) TUidPixelFormat[count];

  1117 		if(!pixelFormatArray)

  1118 			{

  1119 			User::Leave(KErrNoMemory);

  1120 			}

  1121 		CleanupStack::PushL(pixelFormatArray);

  1122 		count = -100;

  1123 		TEST(KErrArgument == RSgImage::GetPixelFormats(info7, pixelFormatArray, count));

  1124 		

  1125 		CleanupStack::PopAndDestroy(pixelFormatArray);

  1126 		}

  1127 	

  1128 	//reset the array used by the GetPixelFormats function to prevent memory leaks

  1129 	TSgImageInfo info8;

  1130 	info8.iSizeInPixels = TSize(10, 10);

  1131 	info8.iCpuAccess = ESgCpuAccessReadWrite;

  1132 	info8.iUsage = ESgUsageDirectGdiSource;

  1133 	info8.iShareable = EFalse;

  1134 	info8.iScreenId = 100;

  1135 	TEST(KErrNone == RSgImage::GetPixelFormats(info8, NULL, count));