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 // Surface manager test code

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @test

    21  @internalComponent - Internal Symbian test code

    22 */

    23 

    24 #include "tsurfacemanager.h"

    25 #include <e32base.h>

    26 #include <e32cons.h>

    27 #include <e32test.h>

    28 #include <e32std.h>

    29 #include <e32cmn.h>	  

    30 #include <hal.h>

    31 #include <e32def_private.h>

    32 

    33 const TInt KCountLimit = 10000;

    34 

    35 CTSurfaceManager::CTSurfaceManager(CTestStep* aStep):

    36 	CTGraphicsBase(aStep)

    37 	{

    38 	}

    39 

    40 void CTSurfaceManager::ReAllocHintsArrayL(TUint aNumberOfHints)

    41 	{

    42 	if (iHintsArray)

    43 		{

    44 		User::Free(iHintsArray);

    45 		iHintsArray=NULL;

    46 		}

    47 	iHintsArray=static_cast<RSurfaceManager::THintPair*>(

    48 			User::AllocL(aNumberOfHints * sizeof(RSurfaceManager::THintPair)));

    49 	}

    50 

    51 CTSurfaceManager::~CTSurfaceManager()

    52 	{

    53 	if (iHintsArray)

    54 		{

    55 		User::Free(iHintsArray);

    56 		}

    57 	}

    58 

    59 void CTSurfaceManager::RunTestCaseL(TInt aCurTestCase)

    60 	{

    61 	TInt procHandles1  =0;

    62 	TInt threadHandles1=0;

    63 	RThread().HandleCount(procHandles1, threadHandles1);

    64 	((CTSurfaceManagerStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

    65 

    66 	switch(aCurTestCase)

    67 		{

    68 /**

    69 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0001

    70 @SYMPREQ				PREQ 1879,PREQ1007

    71 @SYMREQ					REQ8222,REQ8223

    72 @SYMTestPriority		High 

    73 @SYMTestCaseDesc		For each alignment conditions, create a Surface in a new shared chunk.

    74  						All the attributes are correct, no rounding is required. 						

    75 @SYMTestStatus			Implemented

    76 @SYMTestActions			For each alignment conditions, call CreateSurface() then SurfaceInfo().  

    77 @SYMTestExpectedResults If the return value is KErrNone , it has suceeded  

    78 */

    79 	case 1:

    80 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0001"));

    81 		TestCreateSurfaceNewChunk1L();

    82 		break;

    83 /**

    84 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0002-0001

    85 @SYMPREQ				PREQ 1879,PREQ1007

    86 @SYMREQ					REQ8222,REQ8223

    87 @SYMTestPriority		High 

    88 @SYMTestCaseDesc		For each alignment conditions, create a Surface in a new shared chunk.

    89  						Rounding is required for iOffsetToFirstBuffer and iOffsetBetweenBuffers. 						

    90 @SYMTestStatus			Implemented

    91 @SYMTestActions			Call CreateSurface(), SurfaceInfo()

    92 @SYMTestExpectedResults If the return value is KErrNone , it has suceeded  

    93 */

    94 	case 2:

    95 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0002-0001"));

    96 		TestCreateSurfaceNewChunk2L();

    97 		break;

    98 /**

    99 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0002-0002

   100 @SYMPREQ				PREQ 1879,PREQ1007

   101 @SYMREQ					REQ8222,REQ8223

   102 @SYMTestPriority		High 

   103 @SYMTestCaseDesc		This test creates a surface in an exisiting shared chunk

   104 						Find a valid shared chunk handle returned by a device driver. 

   105 						Create a surface in this existing shared chunk

   106 						Map the surface in the current process to get a new shared chunk handle						

   107 @SYMTestStatus			Implemented

   108 @SYMTestActions			Call CreateSurface(), MapSurface(), SurfaceInfo(). 

   109 @SYMTestExpectedResults If the return value is KErrNone , it has suceeded  

   110 */

   111 	case 3:

   112 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0002-0002"));

   113 		TestCreateSurfaceExisitingChunkL();

   114 		break;

   115 /**

   116 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0003

   117 @SYMPREQ				PREQ 1879,PREQ1007

   118 @SYMREQ					REQ8222,REQ8223

   119 @SYMTestPriority		High 

   120 @SYMTestCaseDesc		This test creates a surface with distinct creation attributes in an 

   121 						exisiting shared chunk that already contains a surface.

   122 						Create a surface in a new shared chunk with valid creation attributes.

   123 						Map the surface in the current process to get the first chunk handle.

   124 						Create another surface (different attributes) in this existing chunk.

   125 						Check that two surfaceIDs are different.

   126 						Map the second surface in the current process to get the second chunk handle.

   127 						Check that two chunk handles are different but refer to the same shared chunk.

   128 						Write a number in the first buffer of the Second surface and read it from the first Surface (the surfaces share the chunk). 					

   129 @SYMTestStatus			Implemented

   130 @SYMTestActions			Call CreateSurface(), MapSurface() and SurfaceInfo().

   131 @SYMTestExpectedResults If the return value is KErrNone , it has suceeded  

   132 */

   133 	case 4:

   134 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0003"));

   135 		TestCreateSurfaceExisitingChunk2L();

   136 		break;

   137 /**

   138 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0004

   139 @SYMPREQ				PREQ 1879,PREQ1007

   140 @SYMREQ					REQ8222,REQ8223

   141 @SYMTestPriority		High 

   142 @SYMTestCaseDesc		This test creates a surface with identical creation attributes in an 

   143 						exisiting shared chunk that already contains a surface.					

   144 @SYMTestStatus			Implemented

   145 @SYMTestActions			Call CreateSurface(), MapSurface() and SurfaceInfo().

   146 @SYMTestExpectedResults If the return value is KErrNone , it has suceeded  

   147 */

   148 	case 5:

   149         ((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0004"));

   150 		TestCreateSurfaceExisitingChunk3L();

   151 		break;

   152 /**

   153 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0005

   154 @SYMPREQ				PREQ 1879,PREQ1007

   155 @SYMREQ					REQ8222,REQ8223

   156 @SYMTestPriority		High 

   157 @SYMTestCaseDesc		This test creates a surface with rotated orientations in an exisiting 

   158 						shared chunk that already contains a surface at the same address.						

   159 @SYMTestStatus			Implemented

   160 @SYMTestActions			Call CreateSurface(), MapSurface() and SurfaceInfo().

   161 @SYMTestExpectedResults If the return value is KErrNone , it has suceeded  

   162 */

   163 	case 6:

   164 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0005"));

   165 		TestCreateSurfaceExisitingChunk4L();

   166 		break;

   167 /**

   168 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0006

   169 @SYMPREQ				PREQ 1879,PREQ1007

   170 @SYMREQ					REQ8222,REQ8223

   171 @SYMTestPriority		High 

   172 @SYMTestCaseDesc		This test creates surfaces with Hint pairs (between 0 and the maximum allowed)

   173 @SYMTestStatus			Implemented

   174 @SYMTestActions			Call GetSurfaceManagerAttrib(), CreateSurface(), SurfaceInfo(). 

   175 @SYMTestExpectedResults One surface can hold maximum of 8 hint pairs

   176 */

   177 	case 7:

   178 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0006"));

   179 		TestCreateSurfaceAssociatedWithHintPairsL(); 

   180 		break;

   181 		

   182 		/**

   183 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0007

   184 @SYMPREQ				PREQ 1879,PREQ1007

   185 @SYMREQ					REQ8222,REQ8223

   186 @SYMTestPriority		High 

   187 @SYMTestCaseDesc		This test creates surfaces with all type of alignment in contiguous 

   188 						or fragmented memory.						

   189 @SYMTestStatus			Implemented

   190 @SYMTestActions			Call CreateSurface(). 

   191 @SYMTestExpectedResults If the return value is KErrNone , it has suceeded

   192 */

   193 	case 8:

   194 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0007"));

   195 		TestCreateSurfaceAlignmentsMemoryTypeL(); 

   196 		break;

   197 		

   198 /**

   199 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0008

   200 @SYMPREQ				PREQ 1879,PREQ1007

   201 @SYMREQ					REQ8222,REQ8223

   202 @SYMTestPriority		High 

   203 @SYMTestCaseDesc		This test creates a surface and opens the surface

   204 @SYMTestStatus			Implemented

   205 @SYMTestActions			Call CreateSurface() and OpenSurface() 

   206 @SYMTestExpectedResults If the return value is KErrNone , it has suceeded

   207 */

   208 	case 9:

   209 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0008"));

   210 		TestOpenSurfaceL();

   211 		break;

   212 /**

   213 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0009

   214 @SYMPREQ				PREQ 1879,PREQ1007

   215 @SYMREQ					REQ8222,REQ8223

   216 @SYMTestPriority		High 

   217 @SYMTestCaseDesc	 	This tests CloseSurface (correctly) decrements reference count

   218 						Create a surface (set the reference count to 1)

   219 						Get the SurfaceInfo for the Surface. (don't alter the ref count)

   220 						Close the Surface (ref count =0)

   221 					    Open the Surface (Since the ref count is 0, OpenSurface should fail)					    

   222 @SYMTestStatus			Implemented

   223 @SYMTestActions			Call CreateSurface(), CloseSurface(), OpenSurface() 

   224 @SYMTestExpectedResults CloseSurface returns KErrNone, OpenSurface returns KErrArgument

   225 */

   226 	case 10:

   227         ((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0009"));

   228 		TestClosingSurfaceDecrementsReferenceCountL();

   229 		break;

   230 /**

   231 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0010

   232 @SYMPREQ				PREQ 1879,PREQ1007

   233 @SYMREQ					REQ8222,REQ8223

   234 @SYMTestPriority		High 

   235 @SYMTestCaseDesc	 	Test that the new CreateSurface()API create the surface and set its reference count to one

   236 						Create a surface in a new shared chunk with valid creation attributes. 

   237 						Map the surface in the current process to get the chunk handle.

   238 						Create a new surface in the existing shared chunk with valid creation attributes (ref count is set to 1).

   239 						Close the second surface (decrement the ref count to 0, the surface is deleted)

   240 						Close the second surface again

   241 						Check the return value is KErrArgument as the second surface is already deleted.						

   242 @SYMTestStatus			Implemented

   243 @SYMTestActions			Call CreateSurface(), MapSurface(), CloseSurface(), OpenSurface() 

   244 @SYMTestExpectedResults The new surface can be created successfully on the existing shared chunk, and the reference count is set to one. 

   245 */

   246 	case 11:

   247 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0010"));

   248 		TestCreateSurfaceSetReferenceCountL();

   249 		break;

   250 		/**

   251 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0011

   252 @SYMPREQ				PREQ 1879,PREQ1007

   253 @SYMREQ					REQ8222,REQ8223

   254 @SYMTestPriority		High 

   255 @SYMTestCaseDesc		Check reading from buffers

   256 						Set the ‘iBuffers’ of TSurfaceCreationAttributes to two.

   257 						Create the Surface in the new shared chunk with valid creation attributes

   258 						Map the Surface in the current process to get the shared chunk handle

   259 						Get the address of the pixel data and write a number to that.

   260 						Check that you can read what was written previously.						

   261 @SYMTestStatus			Implemented

   262 @SYMTestActions			Call CreateSurface() and MapSurface()  

   263 @SYMTestExpectedResults Upon success, the buffer can be written with valid values

   264 */

   265 	case 12:

   266 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0011"));

   267 		TestWriteToTwoBuffersL();

   268 		break;

   269 /**

   270 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0012

   271 @SYMPREQ				PREQ 1879,PREQ1007

   272 @SYMREQ					REQ8222,REQ8223

   273 @SYMTestPriority		High 

   274 @SYMTestCaseDesc		This test gets SurfaceInfo of a Surface without mapping it

   275 						Store the attributes used to create the Surface.

   276 						Create a surface in a new shared chunk with those valid attributes

   277 						Call SurfaceInfo to get the attributes of the new Surface.

   278 						Check if the values are equal to the stored ones. 						

   279 @SYMTestStatus			Implemented

   280 @SYMTestActions			Call CreateSurface(), SurfaceInfo() 

   281 @SYMTestExpectedResults Upon success,the return values are equal to the stored values

   282 */

   283 	case 13:

   284 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0012"));

   285 		TestQuerySurfaceInfoWithoutMappingL();

   286 		break;

   287 /**

   288 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0013

   289 @SYMPREQ				PREQ 1879,PREQ1007

   290 @SYMREQ					REQ8222,REQ8223

   291 @SYMTestPriority		High 

   292 @SYMTestCaseDesc		This test queries SurfaceInfo after mapping it in a memory space

   293 						Store the attributes used to create the Surface.

   294 						Create a surface 

   295 						Map the surface

   296 						Call SurfaceInfo to get the attributes of the Surface

   297 						Check if the values are equal to the stored ones.						

   298 @SYMTestStatus			Implemented

   299 @SYMTestActions			Call CreateSurface(), MapSurface(), SurfaceInfo() 

   300 @SYMTestExpectedResults Upon success,the values are equal to the stored values.

   301 */

   302 	case 14:

   303 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0013"));

   304 		TestQuerySurfaceInfoAfterMappingL();

   305 		break;

   306 /**

   307 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0014

   308 @SYMPREQ				PREQ 1879,PREQ1007

   309 @SYMREQ					REQ8222,REQ8223

   310 @SYMTestPriority		High 

   311 @SYMTestCaseDesc		This tests the MapSurface method

   312 						Create a surface in a new shared chunk with valid attributes

   313 						Map the surface in the current process to get the chunk handle

   314 						Check that it returns KerrNone						

   315 @SYMTestStatus			Implemented

   316 @SYMTestActions			Call CreateSurface(), MapSurface()

   317 @SYMTestExpectedResults Upon success,the return value is KErrNone

   318 */

   319 	case 15:

   320 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0014"));

   321 		TestMapSurfaceL();

   322 		break;

   323 /**

   324 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0015

   325 @SYMPREQ				PREQ 1879,PREQ1007

   326 @SYMREQ					REQ8222,REQ8223

   327 @SYMTestPriority		High 

   328 @SYMTestCaseDesc		This tests the CloseSurface method

   329 						Create a surface in a new shared chunk with valid attributes

   330 						Close the Surface 

   331 						Check that this returns KErrNone

   332 						Call OpenSurface using the SurfaceID and check it returns KErrArgument as the surface is already deleted.						

   333 @SYMTestStatus			Implemented

   334 @SYMTestActions			Call CreateSurface(), CloseSurface(), OpenSurface()

   335 @SYMTestExpectedResults After closing the surface, Open the same surface again will cause a failure and return value is not KErrNone

   336 */

   337 	case 16:

   338 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0015"));

   339 		TestClosingSurfaceL();

   340 		break;

   341 /**

   342 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0016

   343 @SYMPREQ				PREQ 1879,PREQ1007

   344 @SYMREQ					REQ8222,REQ8223

   345 @SYMTestPriority		High 

   346 @SYMTestCaseDesc	 	This test checks the shared Chunk gets deleted after the surface and handle are both closed

   347 						Create a surface in a new shared chunk with valid attributes

   348 						Map the Surface in the current process to get the chunk handle

   349 						Close the Surface 

   350 						Check that KErrNone is returned

   351 						Call RChunk::Base() to check the chunk is not yet deleted, as the handle is still open

   352 						Close the chunk handle						

   353 @SYMTestStatus			Implemented

   354 @SYMTestActions			Call CreateSurface(), CloseSurface(), MapSurface() 

   355 @SYMTestExpectedResults CloseSurface returns KErrNone, OpenSurface returns KErrArgument

   356 */

   357 	case 17:

   358 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0016"));

   359 		TestSharedChunkClosedL();

   360 		break;

   361 

   362 	case 18:

   363 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

   364 		// Obsolete since cr1649 (it was testing the capabilities of the Surface Manager driver)

   365 		break;

   366 /**

   367 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0018

   368 @SYMPREQ				PREQ 1879,PREQ1007

   369 @SYMREQ					REQ8222,REQ8223

   370 @SYMTestPriority		High 

   371 @SYMTestCaseDesc	 	This test creates multiple channels to surface manager LDD in one process and accesses them individually

   372 						Open one channel called SurfaceManager1 to the surface manager LDD 

   373 						Create SurfaceID using SurfaceManager1 (ref count is set to 1)

   374 						Then Open another channel called SurfaceManager2 to LDD in the same process

   375 						Open SurfaceID using SurfaceManager2 (ref count is incremented to 2)

   376 						Close SurfaceManager1 

   377 						Call SurfaceInfo on SurfaceID and check it returns KErrNone, as SurfaceID is still open

   378 						Call CloseSurface on SurfaceID twice and then call SurfaceInfo to check it returns KErrArgument, as the surface is deleted after being closed twice.

   379 						Creating another surface using Surfacemanager2 and check that returns KErrNone too as SurfaceManager2 is still open. 

   380 @SYMTestStatus			Implemented

   381 @SYMTestActions			Call CreateSurface(), OpenSurface(), SurfaceInfo(),CloseSurface()

   382 @SYMTestExpectedResults If multiple connections are created to the driver, closing one surface manager channel will not affect other channels and the surfaces opened in the process. 

   383 */

   384 	case 19:

   385 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0018"));

   386 		TestMultipleChannelsL();

   387 		break;

   388 /**

   389 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0019

   390 @SYMPREQ				PREQ 1879,PREQ1007

   391 @SYMREQ					REQ8222,REQ8223

   392 @SYMTestPriority		High 

   393 @SYMTestCaseDesc	 	This test checks the behaviour of closing driver channels

   394 						Open a channel called as SurfaceManager1 to the LDD by calling RSurfaceManager::Open()

   395 						Create one surface called as SurfaceID1 using SurfaceManager1

   396 						Then open another channel called as SurfaceManager2 to the LDD

   397 						Create another surface called as SurfaceID2 using SurfaceManager2

   398 						Open SurfaceID1 using both SurfaceManager1 and SurfaceManager2

   399 						Open SurfaceID2 using both SurfaceManager1 and SurfaceManager2

   400 						Close SurfaceManager1 and SurfaceManager2

   401 						Reopen a channel to the surface manger LDD 

   402 						Call SurfaceInfo() to access both SurfaceID1 and SurfaceID2 and check both return KErrArgument, as both are deleted.

   403 @SYMTestStatus			Implemented

   404 @SYMTestActions			Call CreateSurface(), OpenSurface(), SurfaceInfo(),CloseSurface()

   405 @SYMTestExpectedResults If multiple connections are created to the driver, closing one surface manager channel will not affect other channels and the surfaces opened in the process. 

   406 */

   407 	case 20:

   408 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0019"));

   409 		TestClosingChannelsL();

   410 		break;

   411 /**

   412 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0020

   413 @SYMPREQ				PREQ 1879,PREQ1007

   414 @SYMREQ					REQ8222,REQ8223

   415 @SYMTestPriority		High 

   416 @SYMTestCaseDesc	 	Finding out the maximum number of surfaces to be created

   417 						Create a Surface till error occurs

   418 						Check the maximum number of surfaces created and the last error code

   419 @SYMTestActions			Call CreateSurface()

   420 @SYMTestExpectedResults 	The maximum number varies between platforms(emulator and h4). The last error code is KErrNoMemory.

   421 */

   422 	case 21:

   423 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0020"));

   424 		TestSurfaceLimitL();

   425 		break;

   426 /**

   427 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0021

   428 @SYMPREQ				PREQ 1879,PREQ1007

   429 @SYMREQ					REQ8222,REQ8223

   430 @SYMTestPriority		High 

   431 @SYMTestCaseDesc	 	Test the behaviour of SynchronizeCache()

   432 						Create the surface in a new shared chunk with valid creation attributes. The cache attribute is set to ECached. 

   433 						Map the surface in the current process to get the chunk handle

   434 						Synchronise the cache before the hardware writes to the buffer. Pass TSyncOperation::ESyncBeforeHandwareWrite, valid buffer number and valid surfaceID in SynchronizeCache()

   435 						Synchronise again the cache after the hardware write the buffer. Pass TSyncOperation::ESyncAfterHandwareWrite, valid buffer number and valid surfaceID in SynchronizeCache()

   436 						Synchronise again the cache before the hardware reads the buffer. Pass TSyncOperation::ESyncBeforeHardwareRead, valid buffer number and valid surfaceID in SynchronizeCache()

   437 						Check each calls return KErrNone. 

   438 						We can also visually check the result of SynchronizeCache() by investigating the MBX GCE tests.

   439 @SYMTestActions			Call CreateSurface(), SynchronizeCache()

   440 @SYMTestExpectedResults 	The surface memory is synchronised properly with cached contents. All the synchronize operation returns KErrNone.

   441 */

   442 	case 22:

   443 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0021"));

   444 		TestSynchronizeCacheL();

   445 		break;

   446 		

   447 /**

   448 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0022

   449 @SYMPREQ				PREQ 1879,PREQ1007

   450 @SYMREQ					REQ8222,REQ8223

   451 @SYMTestPriority		High 

   452 @SYMTestCaseDesc	 	Test that when two surfaces are created in the same shared chunk,

   453 						closing one surface and chunk handle will not cause the chunk to be deleted.  

   454 @SYMTestActions			Call CreateSurface(), MapSurface(), CloseSurface()

   455 @SYMTestExpectedResults 	If two surfaces are created on the same shared chunk. closing one surface and chunk handle will not cause the chunk to be deleted.

   456 */

   457 	case 23:

   458 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0022"));

   459 		TestSharedChunkClosed2L();

   460 		break;

   461 		

   462 /**

   463 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0023

   464 @SYMPREQ				PREQ 1879,PREQ1007

   465 @SYMREQ					REQ8222,REQ8223

   466 @SYMTestPriority		High 

   467 @SYMTestCaseDesc	 	Test that GetSurfaceHint() behaves properly.

   468 @SYMTestActions			Call CreateSurface(), GetSurfaceHint()

   469 @SYMTestExpectedResults 	GetSurfaceHint () returns KErrNone and retrieve THintPair value correctly

   470 */

   471 	case 24:

   472 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0023"));

   473 		TestGetSurfaceHintL();

   474 		break;

   475 

   476 /**

   477 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0024

   478 @SYMPREQ				PREQ 1879,PREQ1007

   479 @SYMREQ					REQ8222,REQ8223

   480 @SYMTestPriority		High 

   481 @SYMTestCaseDesc	 	Test that SetSurfaceHint() behaves properly

   482 @SYMTestActions			Call CreateSurface(), SetSurfaceHint()

   483 @SYMTestExpectedResults 	SetSurfaceHint () can reset value in THintPair if iMutable is ETrue.

   484 */

   485 	case 25:

   486 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0024"));

   487 		TestSetSurfaceHintL();

   488 		break;

   489 		

   490 /**

   491 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0025

   492 @SYMPREQ				PREQ 1879,PREQ1007

   493 @SYMREQ					REQ8222,REQ8223

   494 @SYMTestPriority		High 

   495 @SYMTestCaseDesc	 	Test that AddSurfaceHint() behaves properly

   496 @SYMTestActions			Call CreateSurface(), AddSurfaceHint()

   497 @SYMTestExpectedResults 	AddSurfaceHint () can add a new surface hint value for the surface.

   498 */

   499 	case 26:

   500 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0025"));

   501 		TestAddSurfaceHintL();

   502 		break;

   503 

   504 /**

   505 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0026

   506 @SYMPREQ				PREQ 1879,PREQ1007

   507 @SYMREQ					REQ8222,REQ8223

   508 @SYMTestPriority		High 

   509 @SYMTestCaseDesc	 	This test creates a surface with invalid parameters in a new shared chunk

   510 						Set invalid values for the data members of TSurfaceCreationAttributes, which is used to create a Surface.

   511 						Call CreateSurface

   512 @SYMTestStatus			Implemented

   513 @SYMTestActions			Call CreateSurface()

   514 @SYMTestExpectedResults Check that CreateSurface() returns KErrArgument

   515 */

   516 	case 27: 

   517 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0026"));

   518 		TestCreateSurfaceInvalidParamsNewChunkL();

   519 		break;

   520 /**

   521 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0027

   522 @SYMPREQ				PREQ 1879,PREQ1007

   523 @SYMREQ					REQ8222,REQ8223

   524 @SYMTestPriority		High 

   525 @SYMTestCaseDesc	 	This test creates a surface with invalid parameters in an exisiting shared chunk

   526 						Set invalid values for the data members of TSurfaceCreationAttributes, which is used to create a Surface.

   527 						Call CreateSurface and pass it the shared chunk handle.

   528 @SYMTestStatus			Implemented

   529 @SYMTestActions			Call CreateSurface()

   530 @SYMTestExpectedResults Check that CreateSurface() returns KErrArgument

   531 */

   532 	case 28: 

   533 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0027"));

   534 		TestCreateSurfaceInvalidParamsExisitingChunkL();

   535 		break;

   536 /**

   537 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0028

   538 @SYMPREQ				PREQ 1879,PREQ1007

   539 @SYMREQ					REQ8222,REQ8223

   540 @SYMTestPriority		High 

   541 @SYMTestCaseDesc	 	This test creates a surface with invalid parameters in an exisiting shared chunk which already contains a surface

   542 						Create a surface in a new shared chunk

   543 						Map the surface in the current process to get the shared chunk handle

   544 						Set invalid values for the data members of TSurfaceCreationAttributes, which is used to create a new Surface in the exising shared chunk.

   545 						Call CreateSurface and pass it the shared chunk handle.

   546 @SYMTestStatus			Implemented

   547 @SYMTestActions			Call CreateSurface()

   548 @SYMTestExpectedResults Check that CreateSurface() returns KErrArgument

   549 */

   550 	case 29: 

   551 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0028"));

   552 		TestCreateSurfaceInvalidParamsExisitingChunk2L();

   553 		break;

   554 

   555 /**

   556 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0029

   557 @SYMPREQ				PREQ 1879,PREQ1007

   558 @SYMREQ					REQ8222,REQ8223

   559 @SYMTestPriority		High 

   560 @SYMTestCaseDesc	 	Test that Hint keys can not be duplicated						

   561 @SYMTestStatus			Implemented

   562 @SYMTestActions			Call CreateSurface()

   563 @SYMTestExpectedResults Check that No duplicated Hint keys are allowed in the TSurfaceHints field

   564 */

   565 	case 30:

   566 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0029"));

   567 		TestDuplicatedHintKeyL();

   568 		break;

   569 /**

   570 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0030

   571 @SYMPREQ				PREQ 1879,PREQ1007

   572 @SYMREQ					REQ8222,REQ8223

   573 @SYMTestPriority		High 

   574 @SYMTestCaseDesc	 	This test checks that iContiguous is indeed ignored when creating the second surface on the existing shared chunk which already contains a surface						

   575 @SYMTestStatus			Implemented

   576 @SYMTestActions			Call CreateSurface(), MapSurface(), CreateSurface(), SurfaceInfo()

   577 @SYMTestExpectedResults Contiguous attribution in the surface info structure correctly reflects the Contiguous properties of the chunk used.

   578 */

   579 	case 31: 

   580 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0030"));

   581 		TestInvalidContiguousPropertyL();

   582 		break;

   583 

   584 /**

   585 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0031

   586 @SYMPREQ				PREQ 1879,PREQ1007

   587 @SYMREQ					REQ8222,REQ8223

   588 @SYMTestPriority		High 

   589 @SYMTestCaseDesc	 	This test checks that iCacheAttrib is indeed ignored when creating the second surface on the existing shared chunk which already contains a surface

   590 						

   591 @SYMTestStatus			Implemented

   592 @SYMTestActions			Call CreateSurface(), MapSurface, CreateSurface(), SurfaceInfo()

   593 @SYMTestExpectedResults Cache attribution in the surface info structure correctly reflects the caching properties of the chunk used.

   594 */

   595 	case 32: 

   596 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0031"));

   597 		TestInvalidCachePropertyL();

   598 		break;

   599 

   600 /**

   601 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0032

   602 @SYMPREQ				PREQ 1879,PREQ1007

   603 @SYMREQ					REQ8222,REQ8223

   604 @SYMTestPriority		High 

   605 @SYMTestCaseDesc	 	This test creates a Surface in an invalid chunk

   606 @SYMTestStatus			Implemented

   607 @SYMTestActions			Call CreateSurface(), Mapsurface, CloseSurface()

   608 @SYMTestExpectedResults CreateSurface should return KErrBadHandle when the chunk handle is invalid

   609 */

   610 	case 33: 

   611 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0032"));

   612 		TestInvalidSharedChunkL();

   613 		break;

   614 /**

   615 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0033

   616 @SYMPREQ				PREQ1007

   617 @SYMREQ					REQ8222,REQ8223

   618 @SYMTestPriority		High 

   619 @SYMTestCaseDesc	 	This test create enough surfaces to cause KErrNoMemory

   620 						Set surface parameters to create a reasonably large (memory) surface

   621 						Create multiple surfaces using these parameters

   622 @SYMTestStatus			Implemented

   623 @SYMTestActions			Call CreateSurface()

   624 @SYMTestExpectedResults Check that eventually that KErrNoMemory will be returned.

   625 */

   626 	case 34:

   627         ((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0033"));

   628 		TestCreateVeryLargeSurfacesL();

   629 		break;

   630 /**

   631 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0034

   632 @SYMPREQ				PREQ1007

   633 @SYMREQ					REQ8222,REQ8223

   634 @SYMTestPriority		High 

   635 @SYMTestCaseDesc	 	This tests the MapSurface method with invalid surfaceId

   636 						Create a Surface 

   637 						Change Surface ID by

   638 							1. making the Surface ID negative

   639 							2. converting the type of Surface ID to EInvalidSurface

   640 						MapSurface with new Surface ID

   641 @SYMTestStatus			Implemented

   642 @SYMTestActions			Call CreateSurface(), MapSurface()

   643 @SYMTestExpectedResults Check that the return value of MapSurface() is KErrArgument

   644 */

   645 	case 35:

   646 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0034"));

   647 		TestMapSurfaceInvalidParamsL();

   648 		break;

   649 /**

   650 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0035

   651 @SYMPREQ				PREQ1007

   652 @SYMREQ					REQ8222,REQ8223

   653 @SYMTestPriority		High 

   654 @SYMTestCaseDesc	 	This tests SurfaceInfo by passing invalid SurfaceID

   655 						Map the surface

   656 						Change the type of the SurfaceID 

   657 						Call SurfaceInfo, pass the changed SurfaceID as a parameter

   658 @SYMTestStatus			Implemented

   659 @SYMTestActions			Call CreateSurface(), SurfaceInfo()

   660 @SYMTestExpectedResults Check that the return value of SurfaceInfo() is KErrArgument.

   661 */

   662 	case 36:

   663 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0035"));

   664 		TestSurfaceInfoChangedTypeL();

   665 		break;

   666 /**

   667 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0036

   668 @SYMPREQ				PREQ1007

   669 @SYMREQ					REQ8222,REQ8223

   670 @SYMTestPriority		High 

   671 @SYMTestCaseDesc	 	This tests the Closing surface method with invalid parameters

   672 						Create a Surface 

   673 						Change Surface Id by

   674 							1. making the Surface ID negative

   675 							2. converting the type of the Surface ID to EInvalidSurface

   676 						Call CloseSurface with the new Surface ID

   677 @SYMTestStatus			Implemented

   678 @SYMTestActions			Call CreateSurface(), CloseSurface()

   679 @SYMTestExpectedResults Check that CloseSurface() returns KErrArgument

   680 */

   681 	case 37:

   682 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0036"));

   683 		TestCloseSurfaceInvalidParamsL();

   684 		break;

   685 /**

   686 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0037

   687 @SYMPREQ				PREQ1007

   688 @SYMREQ					REQ8222,REQ8223

   689 @SYMTestPriority		High 

   690 @SYMTestCaseDesc	 	Test  that SynchronizeCache() reacts properly under false conditions

   691 @SYMTestStatus			Implemented

   692 @SYMTestActions			Call CreateSurface(), SynchronizeCache(), CloseSurface()

   693 @SYMTestExpectedResults SynchronizeCache() returns KErrArgument under false conditions

   694 */

   695 	case 38:

   696 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0037"));

   697 		TestSynchronizeCacheInvalidParamsL();

   698 		break;		

   699 /**

   700 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0038

   701 @SYMPREQ				PREQ1007

   702 @SYMREQ					REQ8222,REQ8223

   703 @SYMTestPriority		High 

   704 @SYMTestCaseDesc	 	This tests closing a surface with the same ID twice

   705 						Create a Surface

   706 						Close the surface

   707 						Close the surface again

   708 @SYMTestStatus			Implemented

   709 @SYMTestActions			Call CreateSurface(), CloseSurface()

   710 @SYMTestExpectedResults Check that running CloseSurface() twice returns KErrArgument.

   711 */

   712 	case 39:

   713 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0038"));

   714 		TestCloseSurfaceSameIDTwiceL();

   715 		break;

   716 /**

   717 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0039

   718 @SYMPREQ				PREQ1007

   719 @SYMREQ					REQ8222,REQ8223

   720 @SYMTestPriority		High 

   721 @SYMTestCaseDesc	 	Testing CreateSurface in out of memory conditions (for the debug mode only)

   722 						Open the surface manager

   723 						Call CreateSurface(), inducing a kernal alloc failure on each possible kernal alloc

   724 @SYMTestStatus			Implemented

   725 @SYMTestActions			Call CreateSurface()

   726 @SYMTestExpectedResults 	Check that CreateSurface() returns KErrNoMemory.

   727 */

   728 	case 40:

   729 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

   730 	#ifdef _DEBUG

   731 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0039"));

   732 		TestCreateSurfaceOomL();

   733 	#endif

   734     	break; 	

   735 /**

   736 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0040

   737 @SYMPREQ				PREQ1007

   738 @SYMREQ					REQ8222,REQ8223

   739 @SYMTestPriority		High 

   740 @SYMTestCaseDesc	 	Testing that GetSurfaceHint()reacts properly under false conditions

   741 						Create the surface with valid creation attributes in a new shared chunk.

   742 						Find THintPair, Close the surface

   743 						Set false conditions and then call GetSurfaceHint()

   744 @SYMTestStatus			Implemented

   745 @SYMTestActions			Call CreateSurface(), GetSurfaceHint()

   746 @SYMTestExpectedResults 	Check that GetSurfaceHint()returns KErrArgument under false conditions.

   747 */ 

   748 	case 41:

   749 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0040"));

   750 		TestGetSurfaceHintInFalseConditionsL();

   751 		break;

   752 

   753 /**

   754 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0041

   755 @SYMPREQ				PREQ1007

   756 @SYMREQ					REQ8222,REQ8223

   757 @SYMTestPriority		High 

   758 @SYMTestCaseDesc	 	Testing that SetSurfaceHint()reacts properly under false conditions

   759 						Create the surface with valid creation attributes in a new shared chunk.

   760 						Set THintPair, Close the surface

   761 						Set false conditions and then call SetSurfaceHint()

   762 @SYMTestStatus			Implemented

   763 @SYMTestActions			Call CreateSurface(), SetSurfaceHint()

   764 @SYMTestExpectedResults 	Check that SetSurfaceHint()returns KErrArgument under false conditions.

   765 */ 

   766 	case 42:

   767 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0041"));

   768 		TestSetSurfaceHintInFalseConditionsL();

   769 		break;

   770 		

   771 /**

   772 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0042

   773 @SYMPREQ				PREQ1007

   774 @SYMREQ					REQ8222,REQ8223

   775 @SYMTestPriority		High 

   776 @SYMTestCaseDesc	 	Testing that AddSurfaceHint()reacts properly under false conditions

   777 						Create the surface with valid creation attributes in a new shared chunk.

   778 						Set THintPair, Close the surface

   779 						Set false conditions and then call AddSurfaceHint()

   780 @SYMTestStatus			Implemented

   781 @SYMTestActions			Call CreateSurface(), AddSurfaceHint()

   782 @SYMTestExpectedResults 	AddSurfaceHint () returns KErrArgument if the surface ID is invalid or not open in this process,

   783  							KErrAlreadyExists if duplicate hint key used, KErrOverflow if no space to add new pair.

   784 */ 

   785 	case 43:

   786 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0042"));

   787 		TestAddSurfaceHintInFalseConditionsL();

   788 		break;

   789 		

   790 /**

   791 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0043

   792 @SYMPREQ				PREQ1007

   793 @SYMREQ					REQ8222,REQ8223

   794 @SYMTestPriority		High 

   795 @SYMTestCaseDesc	 	Test  AddSurfaceHint, SetSurfaceHint and SynchronizeCache performance

   796 						Calculate the average time:

   797 							- for setting surface hints at different location

   798 							- for adding hints at different location

   799 							- for synchronizing cache 

   800 

   801 @SYMTestStatus			Implemented

   802 @SYMTestActions			Call CreateSurface(), AddSurfaceHint()and SetSurfaceHint

   803 @SYMTestExpectedResults 	Performance is reasonable

   804 */		

   805 	case 44:

   806 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0043"));

   807 		TestPerformanceOfSurfaceHintAndCacheL();

   808 		break;

   809 

   810 /**

   811 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0044

   812 @SYMPREQ				PREQ1007

   813 @SYMREQ					REQ8222,REQ8223

   814 @SYMTestPriority		High 

   815 @SYMTestCaseDesc	 	Test  CreateSurface() and CloseSurface() performance

   816 						Calculate the average time:

   817 							- for creating a surface in a new chunk

   818 							- for closing a surface

   819 							- for creating a surface in an existing chunk

   820 							

   821 @SYMTestStatus			Implemented

   822 @SYMTestActions			Call CreateSurface() and CloseSurface()

   823 @SYMTestExpectedResults 	Performance is reasonable

   824 */				

   825 	case 45:

   826         ((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0044"));

   827 		TestPerformanceOfSurfaceCreatingAndClosingL();

   828 		break;

   829 

   830 /**

   831 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0045

   832 */

   833 	case 46:

   834 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0045"));

   835 		TestZerosInHintsArrayL();

   836 		break;

   837 		

   838 /**

   839 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0082

   840 @SYMPREQ				DEF130006

   841 @SYMREQ					

   842 @SYMTestPriority		High 

   843 @SYMTestCaseDesc	 	Test that Creating Surface with chunk that has "holes" works. 

   844 @SYMTestStatus			Implemented

   845 @SYMTestActions			Call CreateSurface() with different sets of pages in the chunk. 

   846 @SYMTestExpectedResults 	Test should "pass" - this test has both positive and negative subtests. 

   847 */		

   848 	case 47:

   849 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0082"));

   850 		TestCreateSurfaceChunkWithHolesL();

   851 		break;

   852 /**

   853 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0101

   854 @SYMPREQ				cr1649

   855 @SYMREQ					

   856 @SYMTestPriority		Low 

   857 @SYMTestCaseDesc	 	Test that Creating Surface with too many hints imply an error. 

   858 @SYMTestStatus			Implemented

   859 @SYMTestActions			Call CreateSurface() with too many hints. 

   860 @SYMTestExpectedResults 	Negative test for CreateSurface. 

   861 */		

   862 	case 48:

   863 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0101"));

   864 		TestCreateSurfaceWithTooManyHintsL();

   865 		break;		

   866 	

   867 /**

   868 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0102

   869 @SYMPREQ				cr1649

   870 @SYMREQ					

   871 @SYMTestPriority		Low 

   872 @SYMTestCaseDesc	 	Test that Creating Surface that is not mappable can then not be mapped.  

   873 @SYMTestStatus			Implemented

   874 @SYMTestActions			Call CreateSurface() with attribute iMappable = EFalse, 

   875                         then call MapSurface() and check that it is not successful. 

   876                         same with GetBufferOffset

   877 @SYMTestExpectedResults 	Negative test for MapSurface and GetBufferOffset. 

   878 */

   879 	case 49:

   880 		((CTSurfaceManagerStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0102"));

   881 		TestCreateSurfaceUnMappableL();

   882 		break;

   883 		

   884 	default:		

   885         ((CTSurfaceManagerStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

   886 		((CTSurfaceManagerStep*)iStep)->CloseTMSGraphicsStep();

   887 		TestComplete();

   888 		break;

   889 		}

   890 	((CTSurfaceManagerStep*)iStep)->RecordTestResultL();

   891 	TInt procHandles2  =0;

   892 	TInt threadHandles2=0;

   893 	RThread().HandleCount(procHandles2,threadHandles2);

   894 	if (threadHandles1 != threadHandles2)

   895 		{

   896 		User::Leave(KErrGeneral);  // Thread-owned handles not closed

   897 		}

   898 

   899 	}

   900 

   901 void CTSurfaceManager::TestPerformanceOfSurfaceCreatingAndClosingL()

   902 	{

   903 	INFO_PRINTF1(_L("Testing Surface Manager Performance\r\n"));

   904 	// Open the surface manager

   905 	User::LeaveIfError(iSurfaceManager.Open());

   906     	// Store the attributes used to create the Surface

   907 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

   908 	RSurfaceManager::TSurfaceCreationAttributes& attributes = buf();

   909 	

   910 	attributes.iSize = TSize(100,100);

   911 	attributes.iBuffers = 1;				// number of buffers in the surface

   912 	attributes.iPixelFormat = EUidPixelFormatYUV_422SemiPlanar;	

   913 	attributes.iStride = 400;				// Number of bytes between start of one line and start of next

   914 	attributes.iOffsetToFirstBuffer = 9;	// way of reserving space before the surface pixel data

   915 	attributes.iAlignment = 1;			// alignment, 1,2,4,8,16,32,64 byte aligned or EPageAligned	

   916 	RSurfaceManager::THintPair hints[2];

   917 	attributes.iHintCount=2;

   918 	hints[0].Set(TUid::Uid(0x124578), 25, ETrue);

   919 	hints[1].Set(TUid::Uid(0x237755), 50, ETrue);

   920 	attributes.iSurfaceHints = hints;

   921 	attributes.iOffsetBetweenBuffers = 50009;

   922 	attributes.iContiguous = ETrue;

   923 	attributes.iCacheAttrib = RSurfaceManager::ECached;	 // Cache attributes

   924 	attributes.iMappable = ETrue;

   925 

   926 	// Create a surface

   927 	TSurfaceId surfaceId;

   928 	TUint32 timeBefore = 0;

   929 	TUint32 timeAfter = 0;

   930 	TReal measure = 0;

   931 	TReal measureTotal = 0;

   932 	TInt index = 0;

   933 

   934 	RArray<TSurfaceId> surfaceIDArray;

   935 

   936 	User::LeaveIfError(HAL::Get(HALData::EFastCounterFrequency, iFreq));

   937 	// Scenario 1: measure the average time of creating

   938 	timeBefore = User::FastCounter();

   939 	index = 0;

   940 	TInt r = KErrNone;

   941 	

   942 	do

   943 		{

   944 		TEST(KErrNone == r);

   945 		timeBefore = User::FastCounter();

   946 		r = iSurfaceManager.CreateSurface(buf, surfaceId);

   947 		timeAfter = User::FastCounter();

   948 		measure= 1000000 * ((TReal)(timeAfter - timeBefore)) / ((TReal) iFreq);

   949 //		RDebug::Print(_L("Creating a surface [LOG]: \t%d \t%f "), index, measure);

   950 		measureTotal += measure;				

   951 		surfaceIDArray.Insert(surfaceId,index++);

   952 		} while (r == KErrNone && index < 500);

   953 			

   954 	TInt numberOfSurfaces = surfaceIDArray.Count();

   955 	INFO_PRINTF2(_L("the number of surface is %d\r\n"),numberOfSurfaces);

   956 	INFO_PRINTF2(_L("the average time for creating a surface is %f\r\n"),measureTotal/numberOfSurfaces);

   957 	index = 0;	

   958 	measureTotal = 0;

   959 	while (index < numberOfSurfaces -1)

   960 		{

   961 		surfaceId = surfaceIDArray[index++];

   962 		

   963 		// to delete the first surface being created

   964 		timeBefore = User::FastCounter();

   965 		TEST(KErrNone == iSurfaceManager.CloseSurface(surfaceId));

   966 		timeAfter = User::FastCounter();

   967 			// 1000 for all the opeations, 1000000 for deletion only 

   968 		measure = 1000000 * ((TReal)(timeAfter - timeBefore)) / ((TReal) iFreq);

   969 		measureTotal += measure;

   970 //		RDebug::Print(_L("Closing the surface [LOG]: \t%d \t%f "), index, measure);

   971 		}

   972 

   973 	INFO_PRINTF2(_L("the average time for Closing a surface is %f\r\n"),measureTotal/numberOfSurfaces);

   974 

   975 	surfaceIDArray.Close();

   976 	RArray<TSurfaceId> surfaceIDArray2;

   977 

   978 	// For CreateSurface in the existing chunk

   979 	TEST(KErrNone ==iSurfaceManager.CreateSurface(buf, surfaceId)) ;

   980 	//Map the surface in the current processs

   981 	RChunk handle;

   982 	TEST(KErrNone == iSurfaceManager.MapSurface(surfaceId,handle));

   983 	

   984 	// Cache, Contiguous and Alignment attributes are ignored for the already existing chunks

   985   	RSurfaceManager::TSurfaceCreationAttributesBuf buff;

   986 	RSurfaceManager::TSurfaceCreationAttributes& attributesNew = buff();

   987 

   988 	attributesNew.iSize = TSize(480,16);

   989 	attributesNew.iBuffers = 2;				// number of buffers in the surface

   990 	attributesNew.iPixelFormat = EUidPixelFormatYUV_422Reversed;		

   991 	attributesNew.iStride = 1013;				// Number of bytes between start of one line and start of next

   992 	attributesNew.iOffsetToFirstBuffer = 0;	// way of reserving space before the surface pixel data

   993 

   994 	RSurfaceManager::THintPair hint;

   995 	attributesNew.iHintCount=1;

   996 	hint.Set(TUid::Uid(0x124545), 50, EFalse);

   997 	attributesNew.iSurfaceHints = &hint;

   998 	attributesNew.iAlignment = RSurfaceManager::EPageAligned;

   999 	attributesNew.iOffsetBetweenBuffers = 0;

  1000 	attributesNew.iMappable = ETrue;

  1001 		

  1002 	// Test create surface doesn't return an error

  1003 	TSurfaceId surfaceIdNew;

  1004 

  1005 	r = KErrNone;

  1006 	index = 0;

  1007 	measureTotal = 0;

  1008 	do

  1009 		{

  1010 		TEST(KErrNone == r);

  1011 		timeBefore = User::FastCounter();

  1012 		r = iSurfaceManager.CreateSurface(buff, surfaceIdNew, handle);

  1013 		timeAfter = User::FastCounter();

  1014 		measure= 1000000 * ((TReal)(timeAfter - timeBefore)) / ((TReal) iFreq);

  1015 //		RDebug::Print(_L("CreateSurface in the existing chunk [LOG]: \t%d \t%f "), index, measure);

  1016 		measureTotal += measure;				

  1017 		surfaceIDArray2.Insert(surfaceIdNew,index++);

  1018 		} while (r == KErrNone && index < 500);

  1019 	numberOfSurfaces = surfaceIDArray2.Count();

  1020 

  1021 	INFO_PRINTF2(_L("the average time for Creating a surface in the existing chunk is %f\r\n"),measureTotal/numberOfSurfaces);

  1022 

  1023 	index = 0;	

  1024 	while (index < numberOfSurfaces)

  1025 		{

  1026 		surfaceIdNew = surfaceIDArray2[index++];

  1027 		TEST(KErrNone == iSurfaceManager.CloseSurface(surfaceIdNew));

  1028 		}

  1029 

  1030 	handle.Close();	

  1031 	

  1032 	surfaceIDArray2.Close();

  1033 	iSurfaceManager.Close();

  1034  	}

  1035 

  1036 void CTSurfaceManager::TestPerformanceOfSurfaceHintAndCacheL()

  1037 	{

  1038 	INFO_PRINTF1(_L("Testing Surface Manager AddSurfaceHint, SetSurfaceHint, GetSurfaceHint and SynchronizeChace Performance\r\n"));

  1039 	// Open the surface manager

  1040 	User::LeaveIfError(iSurfaceManager.Open());

  1041 	// Store the attributes used to create the Surface

  1042 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

  1043 	RSurfaceManager::TSurfaceCreationAttributes& attributes = buf();

  1044 	

  1045 	TInt maxHintsPerSurface;

  1046 	iSurfaceManager.GetSurfaceManagerAttrib(RSurfaceManager::EMaxNumberOfHints,maxHintsPerSurface);

  1047 	// For SetSurfaceHint extreme search(binary search takes longest to locate the search if it is at the end)

  1048 	//Small surfaces

  1049 	RArray<TInt32> uidArray;

  1050 	TInt i;

  1051 	for (TInt i=0;i<maxHintsPerSurface-1;++i)

  1052 		{

  1053 		uidArray.Append(0x237750+i);

  1054 		}

  1055 	uidArray.Append(0x237778);

  1056 	

  1057 	attributes.iSize = TSize(1,1);

  1058 	attributes.iBuffers = 1;

  1059 	attributes.iPixelFormat = EUidPixelFormatYUV_422SemiPlanar; // 2bpp

  1060 	attributes.iStride = 1;

  1061 	attributes.iOffsetToFirstBuffer = 1;

  1062 	attributes.iAlignment = RSurfaceManager::EPageAligned;

  1063 	//Add 16 surface hints 

  1064 	ReAllocHintsArrayL(maxHintsPerSurface);

  1065 	attributes.iHintCount=maxHintsPerSurface;

  1066 	for (i = 0; i<attributes.iHintCount; ++i)

  1067 		{

  1068 		iHintsArray[i].Set(TUid::Uid(uidArray[i]), 25, ETrue);

  1069 		}

  1070 	attributes.iSurfaceHints=iHintsArray;

  1071 	

  1072 	attributes.iOffsetBetweenBuffers = 0;

  1073 	attributes.iContiguous = ETrue;

  1074 	attributes.iCacheAttrib = RSurfaceManager::ECached;	 // Cache attributes

  1075 	attributes.iMappable = ETrue;

  1076 	

  1077 	// Create a surface

  1078 	TSurfaceId surfaceId;

  1079 	TInt	freq;

  1080 	User::LeaveIfError(HAL::Get(HALData::EFastCounterFrequency, freq));

  1081 	TEST(KErrNone == iSurfaceManager.CreateSurface(buf, surfaceId));	

  1082 	TUint32 timeBefore =0;

  1083 	TUint32 timeAfter= 0;

  1084 

  1085 	TReal measure1=0;

  1086 	TReal measureTotal = 0;

  1087 	const TInt numberOfCalculation = 500;

  1088 

  1089 	RSurfaceManager::THintPair hintPair;

  1090 	RSurfaceManager::THintPair hintPair2;

  1091 	// Measure the average time of setting surface hints at different location

  1092 	for (i = 0; i<maxHintsPerSurface; ++i)

  1093 		{

  1094 		measure1 = 0;

  1095 		for (TInt j = 0; j<numberOfCalculation; j++)

  1096 			{

  1097 			hintPair.iKey.iUid = uidArray[i]; 

  1098 			hintPair.iValue = 300;

  1099 			hintPair.iMutable = ETrue;

  1100 			timeBefore = User::FastCounter();

  1101 			TEST(KErrNone == iSurfaceManager.SetSurfaceHint(surfaceId, hintPair));

  1102 			timeAfter = User::FastCounter();

  1103 			measure1 += 1000 * ((TReal)(timeAfter-timeBefore)) / ((TReal) freq);

  1104 			hintPair2.iKey.iUid = uidArray[i];

  1105 			TEST(KErrNone == iSurfaceManager.GetSurfaceHint(surfaceId, hintPair2));

  1106 			TEST(hintPair2.iValue == 300);

  1107 			TEST(hintPair2.iMutable == 1);

  1108 			}

  1109 //		RDebug::Print(_L("[LOG]: \t%d \t%f "), i, measure1/numberOfCalculation);

  1110 		measureTotal +=measure1;

  1111 		}

  1112 	INFO_PRINTF2(_L("the average time for SetSurfaceHint is %f\r\n"),measureTotal/8);

  1113 

  1114 	RDebug::Print(_L("SetSurfaceHint Test finished"));

  1115 	iSurfaceManager.CloseSurface(surfaceId);	

  1116 // For AddSurfaceHint	

  1117 	RSurfaceManager::TSurfaceCreationAttributesBuf bufNew;

  1118 	RSurfaceManager::TSurfaceCreationAttributes& attributesNew = bufNew();

  1119 	attributesNew.iSize = TSize(1,1);

  1120 	attributesNew.iBuffers = 1;

  1121 	attributesNew.iPixelFormat = EUidPixelFormatYUV_422SemiPlanar; // 2bpp

  1122 	attributesNew.iStride = 1;

  1123 	attributesNew.iOffsetToFirstBuffer = 1;

  1124 	attributesNew.iAlignment = RSurfaceManager::EPageAligned;

  1125 	attributesNew.iOffsetBetweenBuffers = 0;

  1126 	attributesNew.iContiguous = ETrue;

  1127 	attributesNew.iCacheAttrib = RSurfaceManager::ECached;	 // Cache attributes

  1128 	attributesNew.iMappable = ETrue;

  1129 	

  1130 	// Create a surface with no surface hints defined

  1131 	TSurfaceId surfaceIdNew;

  1132 	TInt err1 = iSurfaceManager.CreateSurface(bufNew, surfaceIdNew);

  1133 	TEST(KErrNone == err1);

  1134 	measureTotal = 0;