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 multi-processed test code

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @test

    21  @internalComponent - Internal Symbian test code

    22 */

    23 

    24 #include <e32base.h>

    25 #include <e32cons.h>

    26 #include <e32test.h>

    27 #include <e32std.h>

    28 #include <e32cmn.h>

    29 #include <e32def.h>

    30 #include "tsurfacemanagermultiprocess.h"

    31 

    32 _LIT(KSecondProcess,"tsecondprocess.exe");

    33 _LIT(KThirdProcess,"tthirdprocess.exe");

    34 

    35 

    36 CTSurfaceManagerMultiProcess::CTSurfaceManagerMultiProcess(CTestStep* aStep):

    37 	CTGraphicsBase(aStep)

    38 	{

    39 	}

    40 

    41 CTSurfaceManagerMultiProcess::~CTSurfaceManagerMultiProcess()

    42 	{

    43 	}

    44 

    45 void CTSurfaceManagerMultiProcess::RunTestCaseL(TInt aCurTestCase)

    46 	{

    47 	TInt procHandles1  =0;

    48 	TInt threadHandles1=0;

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

    50 	((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

    51 

    52 	switch(aCurTestCase)

    53 		{

    54 /**

    55 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0083

    56 @SYMPREQ				PREQ 1879,PREQ1007

    57 @SYMREQ					REQ8222,REQ8223

    58 @SYMTestPriority		High 

    59 @SYMTestCaseDesc		Test mapping a surface created in the existing shared chunk to a different process

    60 						Process 1: Create a surface in a new shared chunk with valid attributes

    61 						Process 1: Map the surface in the current process to get the chunk handle.

    62 						Process 1: Create another surface in the existing chunk (rotation of the first)

    63 						Process 2: Open and Map the second surface in and get the second chunk handles

    64 						Process 2: Check these two chunks handles are different

    65 						Process 2: Get the pixel start address of the pixel data for the second surface via the second chunk handle and write a number to it

    66 						Process 1: Get the pixel start address of the pixel data for the first surface via the first chunk handle and read the number.

    67 						Process 1: Check the number is identical to what we write to in the second process.						

    68 @SYMTestStatus			Implemented

    69 @SYMTestActions			Call CreateSurface(),OpenSurface(), MapSurface(), SurfaceInfo()

    70 @SYMTestExpectedResults Mapping one surface created in the existing shared chunk to the other process will not alter the surface chunk memory

    71 */

    72 	case 1:

    73 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0083"));

    74 		TestMapSurfaceExistinChunkL();

    75 		break;		

    76 /**

    77 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0084

    78 @SYMPREQ				PREQ 1879,PREQ1007

    79 @SYMREQ					REQ8222,REQ8223

    80 @SYMTestPriority		High 

    81 @SYMTestCaseDesc		Test that the API SynchronizeCache() behaves correctly in the multi-process case. 

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

    83 						Process 2: Open the surface and map it in the current process to get the chunk handle

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

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

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

    87 @SYMTestStatus			Implemented

    88 @SYMTestActions			Call CreateSurface(),OpenSurface(), MapSurface(), SurfaceInfo()

    89 @SYMTestExpectedResults All synchronisation operation return KErrNone, the surface memory is synchronised properly with cached contents.

    90 */

    91 	case 2:

    92 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0084"));

    93 		TestSynchronizeCacheMultiProcessL();

    94 		break;

    95 /**

    96 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0046

    97 @SYMPREQ				PREQ 1879,PREQ1007

    98 @SYMREQ					REQ8222,REQ8223

    99 @SYMTestPriority		High 

   100 @SYMTestCaseDesc		Testing the behaviour of closing driver channels in multiple processes when the last channel to the device driver is closed

   101 						Process 1: Open a channel called as SurfaceManager1 to the LDD by calling RSurfaceManager::Open() 

   102 						Process 1: Create a surface SurfaceID1 using SurfaceManager1

   103 						Process 1: Open another channel called as SurfaceManager2 to the LDD 

   104 						Process 1: Create another surface SurfaceID2 using SurfaceManager2

   105 						Process 1: Open SurfaceID1 using both SurfaceManager1 and SurfaceManager2

   106 						Process 1: Open SurfaceID2 using both SurfaceManager1 and SurfaceManager2

   107 						Process 2: Open a channel to the LDD and open the surfaceID1 in the process 

   108 						Process 1: Close both channels to the LDD SurfaceManager1 and SurfaceManager2

   109 						Process 2: Call SurfaceInfo() on surfaceID1 and check the return is KErrNone. Call SurfaceInfo() on surfaceID2 and check it returns KErrArgument.

   110 						Process 1: Reopen the channel to the LDD.  Call SurfaceInfo() on surfaceID1. The return value is KErrNone. Call SurfaceInfo() on surfaceID2. The return value is KErrArgument.

   111 @SYMTestStatus			Implemented

   112 @SYMTestActions			Call CreateSurface(),OpenSurface(), MapSurface(), SurfaceInfo()

   113 @SYMTestExpectedResults If all the channels to the driver are closed in a process, the surfaces which have been opened in the other process will not be closed. They are still usable when the first process connects to the driver again.  

   114 */

   115 	case 3:

   116 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0046"));

   117 		TestCloseChannelsMultiProcess1L();

   118 		break;	

   119 /**

   120 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0047

   121 @SYMPREQ				PREQ 1879,PREQ1007

   122 @SYMREQ					REQ8222,REQ8223

   123 @SYMTestPriority		High 

   124 @SYMTestCaseDesc		Testing the behaviour of closing driver channels and surfaces when the process is killed

   125 						Process 2: Open a channel called as SurfaceManager1 to the LDD by calling RSurfaceManager::Open() 

   126 						Process 2: Create a surface SurfaceID1 using SurfaceManager1

   127 						Process 2: Open another channel called as SurfaceManager2 to the LDD 

   128 						Process 2: Create another surface SurfaceID2 using SurfaceManager2

   129 						Process 2: Open SurfaceID1 using both SurfaceManager1 and SurfaceManager2

   130 						Process 2: Open SurfaceID2 using both SurfaceManager1 and SurfaceManager2

   131 						Process 1: Open a channel called as SurfaceManager3 to the LDD and open the surfaceID1 in the process 

   132 						Process 2: Kill the process

   133 						Process 1: Call OpenSurface() on surfaceID1 using SurfaceManager3 and check it returns KErrNone, as the surfaceID1 is still open

   134 						Process 1: Call OpenSurface() on surfaceID2 using SurfaceManager3 and check it returns KErrArgument, as the surfaceID2 is already deleted

   135 						Process 1: Close surfaceID1 and SurfaceManager3

   136 @SYMTestStatus			Implemented

   137 @SYMTestActions			Call CreateSurface(),OpenSurface(), MapSurface(), SurfaceInfo()

   138 @SYMTestExpectedResults When the last channel to the surface manager by the process exiting, the surface manager will automatically close the surfaces which are open in that process.  Any surfaces which were only open in that process will be deleted.

   139 */

   140 	case 4:

   141 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0047"));

   142 		TestCloseChannelsMultiProcess2L();

   143 		break;		

   144 /**

   145 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0048

   146 @SYMPREQ				PREQ1007

   147 @SYMREQ					REQ8222,REQ8223

   148 @SYMTestPriority		High 

   149 @SYMTestCaseDesc		Multiprocess API testing for getting information using SurfaceInfo

   150 						Process 1: Create the Surface

   151 						Process 2: Receive the Surface Id 

   152 						Process 2: Receive the attributes expected to be used by the surface

   153 						Process 2: Open the surface using the id	

   154 						Process 2: Map the surface

   155 						Process 2: Call SurfaceInfo to get the attributes of the Surface

   156 						Process 2: Check if these are equal to the ones received.

   157 @SYMTestStatus			Implemented

   158 @SYMTestActions			Call CreateSurface(),OpenSurface(), MapSurface(), SurfaceInfo()

   159 @SYMTestExpectedResults The surface can be successfully transmitted between processes

   160 */

   161 	case 5:

   162 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0048"));

   163 		TestSurfaceInfoUsingSurfaceIdL();

   164 		break;

   165 /**

   166 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0049

   167 @SYMPREQ				PREQ1007

   168 @SYMREQ					REQ8222,REQ8223

   169 @SYMTestPriority		High 

   170 @SYMTestCaseDesc		Multiprocess API testing for opening the Surface using SurfaceId

   171 						Priocess 1: Create the surface

   172 						Process 2: Receive the Surface id

   173 						Process 2: Open the Surface using the stored SurfaceId

   174 						Process 2: Check that it returns KErrNone

   175 @SYMTestStatus			Implemented

   176 @SYMTestActions			Call CreateSurface(),OpenSurface()

   177 @SYMTestExpectedResults Check that opening the surface using a recieved id returns KErrNone

   178 */

   179 	case 6:

   180 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0049"));

   181 		TestOpeningSurfaceUsingSurfaceIdL();

   182 		break;

   183 /**

   184 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0050

   185 @SYMPREQ				PREQ1007

   186 @SYMREQ					REQ8222,REQ8223

   187 @SYMTestPriority		High 

   188 @SYMTestCaseDesc		Multiprocess test for opening the surface (OpenSurface negative test)

   189 						Receive a Surface Id from another process

   190 						Change Surface Id by

   191 							1. adding 500 to the SurfaceId

   192 							2. making the Surface ID negative

   193 							3. converting the type of the Surface ID to EInvalidSurface

   194 						Call OpenSurface using the new SurfaceId					

   195 @SYMTestStatus			Implemented

   196 @SYMTestActions			Call CreateSurface(),OpenSurface()

   197 @SYMTestExpectedResults Check that opening the surface using a modified id returns KErrArgument

   198 */

   199 	case 7:

   200 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0050"));

   201 		TestOpenSurfaceInvalidParamsL();

   202 		break;

   203 /**

   204 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0051

   205 @SYMPREQ				PREQ1007

   206 @SYMREQ					REQ8222,REQ8223

   207 @SYMTestPriority		High 

   208 @SYMTestCaseDesc		Closing an unopened surface in a second process 

   209 						Process 1: Create Surface

   210 						Process 2: Close Surface 		

   211 @SYMTestStatus			Implemented

   212 @SYMTestActions			Call CreateSurface(),CloseSurface()

   213 @SYMTestExpectedResults Check that CloseSurface() returns KErrAccessDenied		

   214 */

   215 	case 8:

   216 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0051"));

   217 		TestClosingUnopenedSurfaceL();

   218 		break;

   219 /**

   220 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0052

   221 @SYMPREQ				PREQ1007

   222 @SYMREQ					REQ8222,REQ8223

   223 @SYMTestPriority		High 

   224 @SYMTestCaseDesc		Accessing an unopened surface in a second process give KErrArgument

   225 @SYMTestStatus			Implemented

   226 @SYMTestActions			Call CreateSurface(),CloseSurface(), MapSurface(), SurfaceInfo()

   227 @SYMTestExpectedResults The surface cant be accessed/closed if it is not opened first in another process.	

   228 */

   229 	case 9:

   230 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0052"));

   231 		TestSurfaceInfoUnopenedSurfaceL();

   232 		break;

   233 /**

   234 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0053

   235 @SYMPREQ				PREQ1007

   236 @SYMREQ					REQ8222,REQ8223

   237 @SYMTestPriority		High 

   238 @SYMTestCaseDesc		Create, Open and Close in 3 different processes, 

   239 						leaves surface accessible in first 2 processes 

   240 @SYMTestStatus			Implemented

   241 @SYMTestActions			Call CreateSurface(),CloseSurface(), MapSurface(), SurfaceInfo()

   242 @SYMTestExpectedResults The surface cant be accessed/closed if it is not opened first in another process.	

   243 */

   244 	case 10:

   245 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0053"));

   246 		CreateOpenCloseThreeProcessL();

   247 		break;

   248 /**

   249 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0054

   250 @SYMPREQ				PREQ1007

   251 @SYMREQ					REQ8222,REQ8223

   252 @SYMTestPriority		High 

   253 @SYMTestCaseDesc		Test surface can be accessed when creating process dies

   254 						Process 2: Create Surface

   255 						Process 1: Open Surface

   256 						Process 2: Kill Process

   257 						Process 1: Map Surface 

   258 						Process 1: Surface Info

   259 @SYMTestStatus			Implemented

   260 @SYMTestActions			Call CreateSurface(),OpenSurface(), MapSurface(), SurfaceInfo()

   261 @SYMTestExpectedResults It is expected that the surface can be accessed when creating process dies	

   262 */

   263 	case 11:

   264 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0054"));

   265 		TestSurfaceAccessWhenCreatingProcessDiesL();

   266 		break;

   267 /**

   268 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0055

   269 @SYMPREQ				PREQ1007

   270 @SYMREQ					REQ8222,REQ8223

   271 @SYMTestPriority		High 

   272 @SYMTestCaseDesc		Test surface can be closed when creating process dies

   273 						Process 2: Create Surface

   274 						Process 1: Open Surface

   275 						Process 2: Kill Process

   276 						Process 1: Close Surface 

   277 @SYMTestStatus			Implemented

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

   279 @SYMTestExpectedResults It is expected that the surface can be closed when creating process dies	

   280 */

   281 	case 12:

   282 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0055"));

   283 		TestClosingSurfaceWhenCreatingProcessDiesL();

   284 		break;

   285 /**

   286 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0056

   287 @SYMPREQ				PREQ1007

   288 @SYMREQ					REQ8222,REQ8223

   289 @SYMTestPriority		High 

   290 @SYMTestCaseDesc		Test surface can be closed from third process when 

   291 						creating process dies and second process closes

   292 						Process 2: Create Surface

   293 						Process 1: Open Surface

   294 						Process 3: Open Surface

   295 						Process 2: Kill Process

   296 						Process 1: Close Surface - KErrNone

   297 						Process 3: Close Surface - KErrNone

   298 						Process 3: Open Surface - KErrArgument

   299 @SYMTestStatus			Implemented

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

   301 @SYMTestExpectedResults It is expected that surface can be closed from third process when 

   302 						creating process dies and second process closes	

   303 */

   304 	case 13:

   305 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0056"));

   306 		TestCloseSurfaceInThirdProcessL();

   307 		break;

   308 /**

   309 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0057

   310 @SYMPREQ				PREQ1007

   311 @SYMREQ					REQ8222,REQ8223

   312 @SYMTestPriority		High 

   313 @SYMTestCaseDesc		Test surface can't be accessed in a second process when open 

   314 						and closed in the first process.

   315 						Process 2: Create Surface

   316 						Process 1: Open Surface

   317 						Process 1: Close Surface

   318 						Process 2: Kill Process

   319 						Process 1: Open Surface 

   320 @SYMTestStatus			Implemented

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

   322 @SYMTestExpectedResults It is expected that test surface can't be accessed when closed (2process)

   323 */

   324 	case 14:

   325 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0057"));

   326 		TestNoAccessWhenSurfaceClosedTwoProcessL();

   327 		break;

   328 /**

   329 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0058

   330 @SYMPREQ				PREQ1007

   331 @SYMREQ					REQ8222,REQ8223

   332 @SYMTestPriority		High 

   333 @SYMTestCaseDesc		Test closing on one process doesn't prevent opening on other processes, 

   334 						provided one process still owns surface

   335 						Process 1: Create Surface

   336 						Process 2: Open Surface

   337 						Process 2: Close Surface

   338 						Process 3: Open Surface - KErrNone

   339 @SYMTestStatus			Implemented

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

   341 @SYMTestExpectedResults It is expected that closing on one process doesn't prevent opening on other processes, 

   342 						provided one process still owns surface

   343 */

   344 	case 15:

   345 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0058"));

   346 		TestOpeningOnProcessAfterClosingOnOtherL();

   347 		break;

   348 /**

   349 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0059

   350 @SYMPREQ				PREQ1007

   351 @SYMREQ					REQ8222,REQ8223

   352 @SYMTestPriority		High 

   353 @SYMTestCaseDesc		Test closing on one process doesn't prevent access on other 

   354 						processes, provided one process still owns surface

   355 						Process 1: Create Surface

   356 						Process 2: Open Surface

   357 						Process 2: Close Surface

   358 						Process 1: Map Surface - KErrNone

   359 						Process 1: SurfaceInfo - KErrNone

   360 @SYMTestStatus			Implemented

   361 @SYMTestActions			Call CreateSurface(),CloseSurface(), OpenSurface(), MapSurface(), SurfaceInfo()

   362 @SYMTestExpectedResults It is expected that closing on one process doesn't prevent access on other 

   363 */

   364 	case 16:

   365 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0059"));

   366 		TestAccessAfterClosingL();

   367 		break;

   368 /**

   369 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0060

   370 @SYMPREQ				PREQ1007

   371 @SYMREQ					REQ8222,REQ8223

   372 @SYMTestPriority		High 

   373 @SYMTestCaseDesc		Test closing a surface in the creating process when it 

   374 						has already been closed in a second process 

   375 						Process 1: Create Surface

   376 						Process 2: Open Surface

   377 						Process 2: Close Surface

   378 						Process 1: Close Surface 

   379 @SYMTestStatus			Implemented

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

   381 @SYMTestExpectedResults Check Close Surface in process 1 returns KErrNone

   382 */

   383 	case 17:

   384 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0060"));

   385 		TestClosingAfterClosingOnOtherProcessL();

   386 		break;

   387 /**

   388 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0061

   389 @SYMPREQ				PREQ1007

   390 @SYMREQ					REQ8222,REQ8223

   391 @SYMTestPriority		High 

   392 @SYMTestCaseDesc		Test a surface cannot be accessed in a second process if not opened

   393 						Process 1: Create Surface

   394 						Process 2: Map Surface  

   395 						Process 2: Surface Info 

   396 @SYMTestStatus			Implemented

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

   398 @SYMTestExpectedResults Check Map Surface and SurfaceInfo in the second process return KErrAccessDenied

   399 */

   400 	case 18:

   401 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0061"));

   402 		TestErrSufaceAccessNotOpenL();

   403 		break;

   404 /**

   405 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0062

   406 @SYMPREQ				PREQ1007

   407 @SYMREQ					REQ8222,REQ8223

   408 @SYMTestPriority		High 

   409 @SYMTestCaseDesc		Test surface buffers written to in one process can be read from in another

   410 						Process 1: Create Surface

   411 						Process 1: Map Surface 

   412 						Process 1: Write to buffer

   413 						Process 2: Open the surface 

   414 						Process 2: Read from buffer 

   415 @SYMTestStatus			Implemented

   416 @SYMTestActions			Call CreateSurface(),MapSurface(), OpenSurface()

   417 @SYMTestExpectedResults Value written to buffer in process 1 is equal to value retrieved from buffer in process 2.

   418 */

   419 	case 19:

   420 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0062"));

   421 		TestReadFromBufferInSecondProcessL();

   422 		break;

   423 /**

   424 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0063

   425 @SYMPREQ				PREQ1007, PREQ 1879

   426 @SYMREQ					REQ8222,REQ8223

   427 @SYMTestPriority		High 

   428 @SYMTestCaseDesc		Test that the API GetSurfaceHint() behaves correctly in the multi-process case. 

   429 						Process 1: Create the surface in a new shared chunk with valid creation attributes.

   430 						Process 2: Set a THintPair with a key value set to 0x124580 and value set to 300, iMutable set to ETrue.

   431 						Process 2: Call GetSurfaceHint()and Check it returns KErrAccessDenied

   432 						Process 2: Open the surface and then Call SetSurfaceHint(), Check it returns KErrNone.

   433 						Process 2: Call GetSurfaceHint() to retrieve the THintPair with the key value 0x124578

   434 								   Check the THintPair has the iValue set to 20 and iMutable set to ETrue.

   435 @SYMTestStatus			Implemented

   436 @SYMTestActions			Call CreateSurface(),OpenSurface(), GetSurfaceHint()

   437 @SYMTestExpectedResults GetSurfaceHint() behaves properly in the multiprocess. 

   438 */

   439 	case 20:

   440 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0063"));

   441 		TestGetSurfaceHintMultiProcessL();

   442 		break;

   443 /**

   444 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0064

   445 @SYMPREQ				PREQ1007, PREQ 1879

   446 @SYMREQ					REQ8222,REQ8223

   447 @SYMTestPriority		High 

   448 @SYMTestCaseDesc		Test that the API SetSurfaceHint() behaves correctly in the multi-process case. 

   449 						Process 1: Create the surface in a new shared chunk with valid creation attributes.

   450 						Process 2: Set a THintPair with a key value set to 0x124580 and value set to 300, iMutable set to ETrue.

   451 						Process 2: Call SetSurfaceHint()and Check it returns KErrAccessDenied

   452 						Process 2: Open the surface and then Call SetSurfaceHint(), Check it returns KErrNone.

   453 						Process 2: Call GetSurfaceHint() to retrieve the THintPair with the key value 0x124578

   454 								   Check the retrieved THintPair has the iValue set to 300.

   455 @SYMTestStatus			Implemented

   456 @SYMTestActions			Call CreateSurface(),OpenSurface(), SetSurfaceHint(),GetSurfaceHint()

   457 @SYMTestExpectedResults SetSurfaceHint() behaves properly in the multiprocess. 

   458 */

   459 	case 21:

   460 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0064"));

   461 		TestSetSurfaceHintMultiProcessL();

   462 		break;

   463 /**

   464 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0065

   465 @SYMPREQ				PREQ1007, PREQ 1879

   466 @SYMREQ					REQ8222,REQ8223

   467 @SYMTestPriority		High 

   468 @SYMTestCaseDesc		Test that the API AddSurfaceHint() behaves correctly in the multi-process case. 

   469 						Process 1: Process 1: Create the surface in a new shared chunk with valid creation attributes.

   470 						Process 2: Set a THintPair with a key value set to 0x124580 and value set to 300, iMutable set to ETrue.

   471 						Process 2: Call AddSurfaceHint()and Check it returns KErrAccessDenied

   472 						Process 2: Open the surface and then Call AddSurfaceHint(), Check it returns KErrNone.

   473 						Process 2: Call GetSurfaceHint() to retrieve the THintPair with the key value 0x124580

   474 								   Check the retrieved THintPair has the iValue set to 300 and iMutable set to ETrue.

   475 @SYMTestStatus			Implemented

   476 @SYMTestActions			Call CreateSurface(),OpenSurface(), GetSurfaceHint(), AddSurfaceHint()

   477 @SYMTestExpectedResults AddSurfaceHint() behaves properly in the multiprocess. 

   478 */

   479 	case 22:

   480 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0065"));

   481 		TestAddSurfaceHintMultiProcessL();

   482 		break;

   483 /**

   484 @SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0066

   485 @SYMPREQ				PREQ1007, PREQ 1879

   486 @SYMREQ					REQ8222,REQ8223

   487 @SYMTestPriority		High 

   488 @SYMTestCaseDesc		Testing how OpenSurface() and AddConnection() behanves under out of memory conditions 

   489 						Process 1: Create a surface and pass it in to the second process

   490 						Process 2: Open the surface manager, inducing a kernel alloc failure on each possible kernel alloc with the use of MACRO(__KHEAP_SETFAIL).

   491 						Check that returns KerrNoMemory

   492 						Process 2: Call OpenSurface() on the new shared chunk, inducing a kernel alloc failure on each possible kernel alloc with the use of MACRO(__KHEAP_SETFAIL).

   493 						Check that returns KerrNoMemory

   494 @SYMTestStatus			Implemented

   495 @SYMTestActions			Call CreateSurface(),OpenSurface(), RSurfaceManager::Open()

   496 @SYMTestExpectedResults OpenSurface and AddConnection should return KerrNoMemory. 

   497 */		

   498 	case 23:

   499 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

   500 #ifdef _DEBUG

   501 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0066"));

   502 		TestOutofMemoryCasesL();

   503 #endif

   504 		break;

   505 	default:

   506 		((CTSurfaceManagerMultiProcessStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

   507 		((CTSurfaceManagerMultiProcessStep*)iStep)->CloseTMSGraphicsStep();

   508 		TestComplete();

   509 		break;

   510 		}

   511 	((CTSurfaceManagerMultiProcessStep*)iStep)->RecordTestResultL();

   512 	// Handle check

   513 	TInt procHandles2  =0;

   514 	TInt threadHandles2=0;

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

   516 	if (threadHandles1 != threadHandles2)

   517 		{

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

   519 		}

   520  

   521 	}

   522 

   523 void CTSurfaceManagerMultiProcess::TestMapSurfaceExistinChunkL()

   524 	{

   525 	// Create a surface in a new shared chunk

   526 	INFO_PRINTF1(_L("Test mapping a surface created in the existing shared chunk to a different process\r\n"));

   527 	// Open the surface manager

   528 	RSurfaceManager surfaceManager;

   529  	User::LeaveIfError(surfaceManager.Open());

   530 	CleanupClosePushL(surfaceManager);

   531 

   532 	TRequestStatus status;

   533 	// Setup attributes 

   534    	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

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

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

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

   538 	attributes.iPixelFormat = EUidPixelFormatYUV_422SemiPlanar;		// 2bpp

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

   540 	attributes.iOffsetToFirstBuffer = 0;	// way of reserving space before the surface pixel data

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

   542 	attributes.iMappable = ETrue;

   543 	

   544 	RSurfaceManager::THintPair hints[2];	// two hint pairs specified

   545 	attributes.iHintCount = 2;

   546 	attributes.iSurfaceHints = hints;

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

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

   549 

   550 	attributes.iContiguous = ETrue;

   551 	attributes.iCacheAttrib = RSurfaceManager::ECached;

   552 	attributes.iOffsetBetweenBuffers = 0;

   553 		

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

   555 	TSurfaceId surfaceId;

   556 	

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

   558 	TEST(KErrNone == surfaceManager.CreateSurface(buf, surfaceId));

   559 	

   560 	//store all the attributes

   561 	RSurfaceManager::TInfoBuf infoBuf;

   562 	TEST(KErrNone == surfaceManager.SurfaceInfo(surfaceId, infoBuf));

   563 	

   564 	//Map the surface in the current processs

   565 	RChunk handle;

   566 	TEST(KErrNone == surfaceManager.MapSurface(surfaceId,handle));

   567 	

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

   569   	RSurfaceManager::TSurfaceCreationAttributesBuf buff;

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

   571 

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

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

   574 	attributesNew.iPixelFormat = EUidPixelFormatYUV_422Reversed;		// 2bpp

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

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

   577 	attributesNew.iMappable = ETrue;

   578 	

   579 	attributes.iHintCount = 1;

   580 	attributes.iSurfaceHints = hints;

   581 	hints[0].Set(TUid::Uid(0x124545), 50, EFalse);

   582 	

   583 	attributesNew.iAlignment = RSurfaceManager::EPageAligned;

   584 	attributesNew.iOffsetBetweenBuffers = 0;

   585 		

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

   587 	TSurfaceId surfaceIdNew;

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

   589 	// For the time being KErrArgument will be returned as the core codes are

   590 	// not ready to check the passed in shared chunk handle.

   591 	TEST(KErrNone == surfaceManager.CreateSurface(buff, surfaceIdNew, handle));

   592 	

   593 	iInfo2.iSurfaceId = surfaceId;

   594 	iInfo2.iSurfaceManager = surfaceManager;

   595 

   596   	// Create a TCleanupItem object

   597     CleanupStack::PushL(TCleanupItem((TCleanupOperation)CloseSurfaceWhenLeave, &iInfo2));

   598 

   599     // Save the surfaceId to the shared chunk

   600 	CChunkWrapper* chunkWrapper = CChunkWrapper::CreateL(KSharedChunkName, KSharedChunkSize, KSharedChunkSize);

   601     chunkWrapper->SetId(surfaceId);

   602    	CleanupStack::Pop();

   603 

   604     // Create a second process

   605     RProcess process;

   606 	TEST(KErrNone == process.Create(KSecondProcess, KNullDesC));

   607 

   608 	// Specify the test for the second process

   609 	TEST(KErrNone == process.SetParameter(EMultiProcessSecondSlot, ECheckHandle));

   610 	// Kick off the second process and wait for it to complete

   611 	// The actual testing is done in the second process

   612 	process.Logon(status);

   613 	process.Resume();

   614 	User::WaitForRequest(status);

   615 	

   616 	// Check the results of the second process tests

   617 	TInt result = chunkWrapper->GetSecondProcessResults();

   618 	TEST(result & EFirstTestPassed);

   619 	TEST(result & ESecondTestPassed);

   620 	TEST(result & EThirdTestPassed);

   621 

   622 	

   623 	// Get the adress of this chunk of memory

   624 	TUint8* surfaceAdd = handle.Base();

   625 	TUint8* bufferAdd = surfaceAdd + attributes.iOffsetToFirstBuffer;

   626 	

   627 	// Reads from first buffer, and test the value is written

   628 	TInt temp = *bufferAdd;

   629 	TEST(temp == 20);

   630 	

   631 	// Delete the chunkWrapper

   632 	delete chunkWrapper;

   633 	process.Close();	

   634 	handle.Close();

   635 	CleanupStack::PopAndDestroy(1, &surfaceManager);

   636 	}

   637 

   638 void CTSurfaceManagerMultiProcess::TestSynchronizeCacheMultiProcessL()

   639 	{

   640 	// Create a surface in a new shared chunk

   641 	INFO_PRINTF1(_L("Test that the API SynchronizeCache() behaves correctly in the multi-process case\r\n"));

   642 	// Open the surface manager

   643 	RSurfaceManager surfaceManager;

   644  	User::LeaveIfError(surfaceManager.Open());

   645 	CleanupClosePushL(surfaceManager);

   646 

   647 	TRequestStatus status;

   648 	// Setup attributes 

   649 	

   650    	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

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

   652 

   653 	attributes.iSize = TSize(480,16);

   654 	attributes.iBuffers = 2;				// number of buffers in the surface

   655 	attributes.iPixelFormat = EUidPixelFormatYUV_422Reversed;		// 2bpp

   656 	attributes.iStride = 1013;				// Number of bytes between start of one line and start of next

   657 	attributes.iOffsetToFirstBuffer = 0;	// way of reserving space before the surface pixel data

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

   659 	

   660 	RSurfaceManager::THintPair hints[2];	// two hint pairs specified

   661 	attributes.iHintCount = 2;

   662 	attributes.iSurfaceHints = hints;

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

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

   665 	

   666 	attributes.iContiguous = ETrue;

   667 	attributes.iCacheAttrib = RSurfaceManager::ECached;

   668 	attributes.iOffsetBetweenBuffers = 0;

   669 	attributes.iMappable = ETrue;

   670 	

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

   672 	TSurfaceId surfaceId;

   673 	

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

   675 	TEST(KErrNone == surfaceManager.CreateSurface(buf, surfaceId));

   676 	

   677 	iInfo2.iSurfaceManager = surfaceManager;

   678 	iInfo2.iSurfaceId = surfaceId;		

   679 	// Create a TCleanupItem object

   680     CleanupStack::PushL(TCleanupItem((TCleanupOperation)CloseSurfaceWhenLeave, &iInfo2));

   681 

   682     // Save the surfaceId to the shared chunk

   683 	CChunkWrapper* chunkWrapper = CChunkWrapper::CreateL(KSharedChunkName, KSharedChunkSize, KSharedChunkSize);

   684     chunkWrapper->SetId(surfaceId);

   685    	CleanupStack::Pop();

   686 

   687     // Create a second process

   688     RProcess process;

   689 	TEST(KErrNone == process.Create(KSecondProcess, KNullDesC));

   690 

   691 	// Specify the test for the second process

   692 	TEST(KErrNone == process.SetParameter(EMultiProcessSecondSlot, ESyncOperation));

   693 	// Kick off the second process and wait for it to complete

   694 	// The actual testing is done in the second process

   695 	process.Logon(status);

   696 	process.Resume();

   697 	User::WaitForRequest(status);

   698 	

   699 	// Check the results of the second process tests

   700 	TInt result = chunkWrapper->GetSecondProcessResults();

   701 	// Only four tests were carried out in the second process

   702 	TEST(result & EFirstTestPassed);

   703 	TEST(result & ESecondTestPassed);

   704 	TEST(result & EThirdTestPassed);

   705 	TEST(result & EFourthTestPassed);

   706 	// Delete the chunkWrapper

   707 	delete chunkWrapper;

   708 	process.Close();	

   709 	CleanupStack::PopAndDestroy(1, &surfaceManager);

   710 

   711 	}

   712 

   713 

   714 void CTSurfaceManagerMultiProcess::TestCloseChannelsMultiProcess1L()

   715 	{

   716 	// Create a surface in a new shared chunk

   717 	INFO_PRINTF1(_L("Testing the behaviour of closing driver channels in multiple processes when  the last channel to the device driver is closed\r\n"));

   718 	

   719 	// Create a semaphore

   720 	const TInt initCount = 0;

   721 	RSemaphore sem;

   722 	TEST(KErrNone == sem.CreateGlobal(KMultiProcessSemaphore, initCount));

   723 	CleanupClosePushL(sem);

   724 	RSemaphore sem2;

   725 	TEST(KErrNone == sem2.CreateGlobal(KMultiProcessSemaphore2, initCount));

   726 	CleanupClosePushL(sem2);

   727 	

   728 	// Open the surface manager

   729 	RSurfaceManager surfaceManagerOne;

   730 	// Close the surface manager without opening it first

   731 	INFO_PRINTF1(_L("Close the surface manager without opening it first\r\n"));

   732 	// Is this Ok?

   733 //	surfaceManagerOne.Close();

   734  

   735 	User::LeaveIfError(surfaceManagerOne.Open());

   736  	CleanupClosePushL(surfaceManagerOne);

   737    	// Store the attributes used to create the Surface

   738 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

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

   740 	attributes.iSize = TSize(280,301);

   741 	attributes.iBuffers = 1;

   742 	attributes.iPixelFormat = EUidPixelFormatYUV_422SemiPlanar; // 2bpp

   743 	attributes.iStride = 1;

   744 	attributes.iOffsetToFirstBuffer = 1;

   745 	attributes.iAlignment = 1;

   746 	

   747 	RSurfaceManager::THintPair hints[2];	// two hint pairs specified

   748 	attributes.iHintCount = 2;

   749 	attributes.iSurfaceHints = hints;

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

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

   752 	

   753 	attributes.iContiguous = ETrue;

   754 	attributes.iCacheAttrib = RSurfaceManager::ECached;

   755 	attributes.iOffsetBetweenBuffers = 0;

   756 	attributes.iMappable = ETrue;

   757 	

   758 	// Create a surface

   759 	TSurfaceId surfaceIdOne;

   760 	TEST(KErrNone == surfaceManagerOne.CreateSurface(buf, surfaceIdOne));

   761 

   762 	RSurfaceManager surfaceManagerTwo;

   763 	User::LeaveIfError(surfaceManagerTwo.Open());

   764 	CleanupClosePushL(surfaceManagerTwo);

   765 	// Create a surface

   766 	TSurfaceId surfaceIdTwo;

   767 	TEST(KErrNone == surfaceManagerTwo.CreateSurface(buf,surfaceIdTwo));

   768 

   769 	TEST(KErrNone == surfaceManagerOne.OpenSurface(surfaceIdTwo));

   770 	TEST(KErrNone == surfaceManagerTwo.OpenSurface(surfaceIdOne));

   771 

   772 	iInfo2.iSurfaceId = surfaceIdOne;

   773 	iInfo2.iSurfaceManager = surfaceManagerOne;

   774 	// Create a TCleanupItem object

   775     CleanupStack::PushL(TCleanupItem((TCleanupOperation)CloseSurfaceWhenLeave, &iInfo2));

   776 

   777     // Save the surfaceId to the shared chunk

   778 	CChunkWrapper* chunkWrapper = CChunkWrapper::CreateL(KSharedChunkName, KSharedChunkSize, KSharedChunkSize);

   779     chunkWrapper->SetId(surfaceIdOne);

   780    	CleanupStack::Pop();

   781 

   782 	// Create a second process

   783 	RProcess process;

   784 	TEST(KErrNone == process.Create(KSecondProcess, KNullDesC));

   785 	

   786 	// Kick off the process and wait for it to complete

   787 	TRequestStatus status = KRequestPending;

   788 	process.Logon(status);

   789 	TEST(KErrNone == process.SetParameter(EMultiProcessSecondSlot, ETestChannelMultiProcess1));

   790 	process.Resume();

   791 	CleanupClosePushL(process);

   792 	

   793 	// Passes control to the second process

   794 	sem.Wait();

   795 	

   796 	// Check the results of the second process tests

   797 	TInt result = chunkWrapper->GetSecondProcessResults();

   798 	TEST(result & EFirstTestPassed);

   799 	TEST(result & ESecondTestPassed);

   800 	TEST(result & EThirdTestPassed);

   801 	

   802 	surfaceManagerOne.Close();

   803 	surfaceManagerTwo.Close();

   804 

   805 	// Pass control off to the second process again

   806 	chunkWrapper->SetId(surfaceIdTwo);

   807 	sem2.Signal();

   808 

   809 	// Wait for the second process to terminate

   810 	User::WaitForRequest(status);

   811 	

   812 

   813 	// Copme back from the second process - find the surfaceId

   814 	// Check that the tests in the second process have passed 

   815 	result = chunkWrapper->GetSecondProcessResults();

   816 	TEST(result & EFourthTestPassed);

   817 	TEST(result & EFifthTestPassed);

   818 	//More things to check in here

   819 //	TEST(KErrNone == surfaceManagerOne.Open()));

   820 	

   821 	// Delete the chunkWrapper and the semaphore

   822 	delete chunkWrapper;

   823 	CleanupStack::PopAndDestroy(5, &sem);

   824 	

   825 

   826 	}

   827 

   828 void CTSurfaceManagerMultiProcess::TestCloseChannelsMultiProcess2L()

   829 	{

   830 	// Create a surface in a new shared chunk

   831 	INFO_PRINTF1(_L("Testing the behaviour of closing driver channels in multiple processes when  the last channel to the device driver is closed\r\n"));

   832 	

   833 	// Create a semaphore

   834 	const TInt initCount = 0;

   835 	RSemaphore sem;

   836 	TEST(KErrNone == sem.CreateGlobal(KMultiProcessSemaphore, initCount));

   837 	CleanupClosePushL(sem);

   838 	RSemaphore sem2;

   839 	TEST(KErrNone == sem2.CreateGlobal(KMultiProcessSemaphore2, initCount));

   840 	CleanupClosePushL(sem2);

   841 	

   842 	// Create a second process

   843 	RProcess process;

   844 	TEST(KErrNone == process.Create(KSecondProcess, KNullDesC));

   845 	

   846 	// Kick off the process and wait for it to complete

   847 	TRequestStatus status = KRequestPending;

   848 	process.Logon(status);

   849 	TEST(KErrNone == process.SetParameter(EMultiProcessSecondSlot, ETestChannelMultiProcess2));

   850 	process.Resume();

   851 	CleanupClosePushL(process);

   852 	

   853 	// Passes control to the second process

   854 	sem.Wait();

   855 		

   856 	// Open the chunk wrapper and get the surfaceId

   857 	CChunkWrapper* chunkWrapper = CChunkWrapper::OpenL(KSharedChunkName, ETrue);

   858 	TSurfaceId surfaceIdOne = chunkWrapper->GetId();

   859 	// Check the results of the second process tests

   860 	TInt result = chunkWrapper->GetSecondProcessResults();

   861 	TEST(result & EFirstTestPassed);

   862 	TEST(result & ESecondTestPassed);

   863 	TEST(result & EThirdTestPassed);

   864 	TEST(result & EFourthTestPassed);

   865 

   866 	// Open the surface manager

   867 	RSurfaceManager surfaceManagerThree;

   868  	User::LeaveIfError(surfaceManagerThree.Open());

   869 	CleanupClosePushL(surfaceManagerThree);

   870 	

   871 	TEST(KErrNone == surfaceManagerThree.OpenSurface(surfaceIdOne));

   872 	// Pass control off to the second process again

   873 	sem2.Signal();

   874 

   875 	// Wait for the second process to terminate

   876 	User::WaitForRequest(status);

   877 	

   878 	TSurfaceId surfaceIdTwo = chunkWrapper->GetId();

   879 	

   880 	// Call OpenSurface() on surfaceID1 using SurfaceManager3 and check it returns KErrNone, as the surfaceID1 is still open

   881 	TEST(KErrNone == surfaceManagerThree.OpenSurface(surfaceIdOne));

   882 	// Call OpenSurface() on surfaceID1 using SurfaceManager3 and check it returns KErrNone, as the surfaceID1 is still open

   883 	TEST(KErrArgument == surfaceManagerThree.OpenSurface(surfaceIdTwo));

   884 

   885 	// Delete the chunkWrapper and the semaphore

   886 	delete chunkWrapper;

   887 	CleanupStack::PopAndDestroy(4, &sem);

   888 	}

   889 

   890 

   891 void CTSurfaceManagerMultiProcess::TestSurfaceInfoUsingSurfaceIdL()

   892 	{

   893 	INFO_PRINTF1(_L("Receiving a surface and querying SurfaceInfo for surface properties\r\n"));

   894 	// Open the surface manager

   895 	RSurfaceManager surfaceManager;

   896  	User::LeaveIfError(surfaceManager.Open());

   897 	CleanupClosePushL(surfaceManager);

   898 

   899 	TRequestStatus status;

   900 	

   901 	// Set attributs for creating the surface

   902 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

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

   904 	attributes.iSize = TSize(200,200);

   905 	attributes.iBuffers = 1;				

   906 	attributes.iPixelFormat = EUidPixelFormatARGB_1555;		

   907 	attributes.iStride = 415;				

   908 	attributes.iOffsetToFirstBuffer = 80;	

   909 	attributes.iAlignment = 8;			

   910 	attributes.iContiguous=ETrue;

   911 	

   912 	RSurfaceManager::THintPair hints[2];	// two hint pairs specified

   913 	attributes.iHintCount = 2;

   914 	attributes.iSurfaceHints = hints;

   915 	hints[0].Set(TUid::Uid(0x124545), 50, EFalse);

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

   917 	

   918 	attributes.iOffsetBetweenBuffers = 0;

   919 	attributes.iCacheAttrib = RSurfaceManager::ENotCached;

   920 	attributes.iMappable = ETrue;

   921 	

   922 	// Create the surface

   923 	TSurfaceId surfaceId;

   924     TEST(KErrNone == surfaceManager.CreateSurface(attributes, surfaceId));

   925 

   926     iInfo2.iSurfaceId = surfaceId;

   927 	iInfo2.iSurfaceManager = surfaceManager;

   928 	// Create a TCleanupItem object

   929     CleanupStack::PushL(TCleanupItem((TCleanupOperation)CloseSurfaceWhenLeave, &iInfo2));

   930 

   931     // Save the surfaceId to the shared chunk

   932 	CChunkWrapper* chunkWrapper = CChunkWrapper::CreateL(KSharedChunkName, KSharedChunkSize, KSharedChunkSize);

   933     chunkWrapper->SetId(surfaceId);

   934    	CleanupStack::Pop();

   935 

   936     // Create a second process

   937     RProcess process;

   938 	TEST(KErrNone == process.Create(KSecondProcess, KNullDesC));

   939 

   940 	// Specify the test for the second process

   941 	TEST(KErrNone == process.SetParameter(EMultiProcessSecondSlot, ETestInfoReceivedSurface));

   942 	// Kick off the second process and wait for it to complete

   943 	// The actual testing is done in the second process

   944 	process.Logon(status);

   945 	process.Resume();

   946 	User::WaitForRequest(status);

   947 	

   948 	// Check the results of the second process tests

   949 	TInt result = chunkWrapper->GetSecondProcessResults();

   950 	TEST(result & EFirstTestPassed);

   951 	TEST(result & ESecondTestPassed);

   952 	TEST(result & EThirdTestPassed);

   953 	TEST(result & EFourthTestPassed);

   954 	TEST(result & EFifthTestPassed);

   955 	TEST(result & ESixthTestPassed);

   956 	TEST(result & ESeventhTestPassed);

   957 	TEST(result & EEighthTestPassed);

   958 	TEST(result & ENinthTestPassed);

   959 

   960 	// Delete the chunkWrapper

   961 	delete chunkWrapper;

   962 	process.Close();	

   963 	CleanupStack::PopAndDestroy(1, &surfaceManager);

   964 

   965 	}

   966 	

   967 void CTSurfaceManagerMultiProcess::TestOpeningSurfaceUsingSurfaceIdL()

   968 	{

   969 	INFO_PRINTF1(_L("Test Opening a surface using surfaceId (passed from this to another process)\r\n"));

   970 	// Open the surface manager

   971 	RSurfaceManager surfaceManager;

   972  	User::LeaveIfError(surfaceManager.Open());

   973 	CleanupClosePushL(surfaceManager);

   974 

   975 	TRequestStatus status;

   976 	

   977 	// Set attributs for creating the surface

   978 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

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

   980 	attributes.iSize = TSize(200,200);

   981 	attributes.iBuffers = 1;				

   982 	attributes.iPixelFormat = EUidPixelFormatARGB_1555;		

   983 	attributes.iStride = 1600;				

   984 	attributes.iOffsetToFirstBuffer = 80;	

   985 	attributes.iAlignment = 8;			

   986 	attributes.iContiguous = ETrue;

   987 	

   988 	RSurfaceManager::THintPair hints[2];	// two hint pairs specified

   989 	attributes.iHintCount = 2;

   990 	attributes.iSurfaceHints = hints;

   991 	hints[0].Set(TUid::Uid(0x124545), 50, EFalse);

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

   993 

   994 	attributes.iOffsetBetweenBuffers = 0;

   995 	attributes.iMappable = ETrue;

   996 

   997 	// Create the surface

   998 	TSurfaceId surfaceId;

   999     TEST(KErrNone == surfaceManager.CreateSurface(attributes, surfaceId));

  1000 

  1001 	iInfo2.iSurfaceId = surfaceId;

  1002 	iInfo2.iSurfaceManager = surfaceManager;

  1003 	// Create a TCleanupItem object

  1004     CleanupStack::PushL(TCleanupItem((TCleanupOperation)CloseSurfaceWhenLeave, &iInfo2));

  1005 

  1006     // Save the surfaceId to the shared chunk

  1007 	CChunkWrapper* chunkWrapper = CChunkWrapper::CreateL(KSharedChunkName, KSharedChunkSize, KSharedChunkSize);

  1008     chunkWrapper->SetId(surfaceId);

  1009    	CleanupStack::Pop();

  1010  

  1011     // Create a second process

  1012     RProcess process;

  1013 	TEST(KErrNone == process.Create(KSecondProcess, KNullDesC));

  1014 

  1015 	// Specify the test for the second process

  1016 	TEST(KErrNone == process.SetParameter(EMultiProcessSecondSlot, ETestOpenReceivedSurface));	

  1017 	process.Logon(status);

  1018 	process.Resume();

  1019 	User::WaitForRequest(status);

  1020 	

  1021 	// Check the test results of the second process

  1022 	TInt result = chunkWrapper->GetSecondProcessResults();

  1023 	TEST(result & EFirstTestPassed);

  1024 

  1025 	// Delete the chunkWrapper

  1026 	delete chunkWrapper;

  1027 	process.Close();

  1028 	CleanupStack::PopAndDestroy(1, &surfaceManager);

  1029 

  1030 	}

  1031 

  1032 void CTSurfaceManagerMultiProcess::TestOpenSurfaceInvalidParamsL()

  1033 	{

  1034    	INFO_PRINTF1(_L("Opening a surface with invalid parameters\r\n"));

  1035    	RSurfaceManager surfaceManager;

  1036 	User::LeaveIfError(surfaceManager.Open());

  1037 	CleanupClosePushL(surfaceManager);

  1038 

  1039 	// Store the attributes used to create the Surface

  1040 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

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

  1042 	

  1043 	attributes.iSize = TSize(150,412);

  1044 	attributes.iBuffers = 3;

  1045 	attributes.iPixelFormat = EUidPixelFormatARGB_1555; // 2bpp

  1046 	attributes.iStride = 1000;

  1047 	attributes.iOffsetToFirstBuffer = 5;

  1048 	attributes.iAlignment = 1;

  1049 	attributes.iContiguous=EFalse;

  1050 	

  1051 	RSurfaceManager::THintPair hints[2];	// two hint pairs specified

  1052 	attributes.iHintCount = 2;

  1053 	attributes.iSurfaceHints = hints;

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

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

  1056 	

  1057 	attributes.iCacheAttrib = RSurfaceManager::ECached;

  1058 	attributes.iOffsetBetweenBuffers = 0;

  1059 	attributes.iMappable = ETrue;

  1060 	

  1061 	// Create a surface - increments reference count by 1

  1062 	TSurfaceId surfaceId;

  1063     TEST(KErrNone == surfaceManager.CreateSurface(buf, surfaceId));

  1064 		

  1065 	iInfo2.iSurfaceId = surfaceId;

  1066 	iInfo2.iSurfaceManager = surfaceManager;

  1067 	// Create a TCleanupItem object

  1068     CleanupStack::PushL(TCleanupItem((TCleanupOperation)CloseSurfaceWhenLeave, &iInfo2));

  1069 

  1070     // Save the surfaceId to the shared chunk

  1071 	CChunkWrapper* chunkWrapper = CChunkWrapper::CreateL(KSharedChunkName, KSharedChunkSize, KSharedChunkSize);

  1072     chunkWrapper->SetId(surfaceId);

  1073 

  1074    	CleanupStack::Pop();

  1075 

  1076     // Create a second process

  1077     RProcess process;

  1078 	TEST(KErrNone == process.Create(KSecondProcess, KNullDesC));

  1079 

  1080 	// Specify the test for the second process

  1081 	TEST(KErrNone == process.SetParameter(EMultiProcessSecondSlot, ETestOpenSurfaceInvalidParams));

  1082 	// Kick off the second process and wait for it to complete

  1083 	// The actual testing is done in the second process

  1084 	TRequestStatus status;

  1085 	process.Logon(status);

  1086 	process.Resume();

  1087 	User::WaitForRequest(status);

  1088 	

  1089 	// Check the results of the second process tests

  1090 	TInt result = chunkWrapper->GetSecondProcessResults();

  1091 	TEST(result & EFirstTestPassed);

  1092 	TEST(result & ESecondTestPassed);

  1093 	TEST(result & EThirdTestPassed);

  1094 

  1095 	// Tidy up

  1096 	delete chunkWrapper;

  1097 	process.Close();

  1098 	CleanupStack::PopAndDestroy(1, &surfaceManager);

  1099 	}

  1100 

  1101 void CTSurfaceManagerMultiProcess::TestClosingUnopenedSurfaceL()

  1102 	{

  1103 	INFO_PRINTF1(_L("Closing an unopened surface in a second process\r\n"));

  1104 	// Open the surface manager

  1105 	RSurfaceManager surfaceManager;

  1106 	User::LeaveIfError(surfaceManager.Open());

  1107 	CleanupClosePushL(surfaceManager);

  1108 

  1109 	// Store the attributes used to create the Surface

  1110 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

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

  1112 	

  1113 	attributes.iSize = TSize(280,301);

  1114 	attributes.iBuffers = 3;

  1115 	attributes.iPixelFormat = EUidPixelFormatYUV_422SemiPlanar; // 2bpp

  1116 	attributes.iStride = 605;

  1117 	attributes.iOffsetToFirstBuffer = 4;

  1118 	attributes.iAlignment = 4;

  1119 	attributes.iContiguous=EFalse;

  1120 	

  1121 	RSurfaceManager::THintPair hints[2];	// two hint pairs specified

  1122 	attributes.iHintCount = 2;

  1123 	attributes.iSurfaceHints = hints;

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

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

  1126 

  1127 	attributes.iCacheAttrib = RSurfaceManager::ECached;

  1128 	attributes.iOffsetBetweenBuffers = 0;

  1129 	attributes.iMappable = ETrue;

  1130 

  1131 	// Create the surface

  1132 	TSurfaceId surfaceId;

  1133 	TEST(KErrNone == surfaceManager.CreateSurface(buf, surfaceId));

  1134