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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Surface manager multi-processed test code

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include <e32base.h>

#include <e32cons.h>

#include <e32test.h>

#include <e32std.h>

#include <e32cmn.h>

#include <e32def.h>

#include "tsurfacemanagermultiprocess.h"

_LIT(KSecondProcess,"tsecondprocess.exe");

_LIT(KThirdProcess,"tthirdprocess.exe");

CTSurfaceManagerMultiProcess::CTSurfaceManagerMultiProcess(CTestStep* aStep):

	CTGraphicsBase(aStep)

	{

	}

CTSurfaceManagerMultiProcess::~CTSurfaceManagerMultiProcess()

	{

	}

void CTSurfaceManagerMultiProcess::RunTestCaseL(TInt aCurTestCase)

	{

	TInt procHandles1  =0;

	TInt threadHandles1=0;

	RThread().HandleCount(procHandles1, threadHandles1);

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

	switch(aCurTestCase)

		{

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0083

@SYMPREQ				PREQ 1879,PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

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

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

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

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

						Process 2: Check these two chunks handles are different

						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

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

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

@SYMTestStatus			Implemented

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

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

*/

	case 1:

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

		TestMapSurfaceExistinChunkL();

		break;		

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0084

@SYMPREQ				PREQ 1879,PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

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

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

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

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

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

@SYMTestStatus			Implemented

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

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

*/

	case 2:

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

		TestSynchronizeCacheMultiProcessL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0046

@SYMPREQ				PREQ 1879,PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

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

						Process 1: Create a surface SurfaceID1 using SurfaceManager1

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

						Process 1: Create another surface SurfaceID2 using SurfaceManager2

						Process 1: Open SurfaceID1 using both SurfaceManager1 and SurfaceManager2

						Process 1: Open SurfaceID2 using both SurfaceManager1 and SurfaceManager2

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

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

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

						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.

@SYMTestStatus			Implemented

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

@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.  

*/

	case 3:

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

		TestCloseChannelsMultiProcess1L();

		break;	

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0047

@SYMPREQ				PREQ 1879,PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

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

						Process 2: Create a surface SurfaceID1 using SurfaceManager1

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

						Process 2: Create another surface SurfaceID2 using SurfaceManager2

						Process 2: Open SurfaceID1 using both SurfaceManager1 and SurfaceManager2

						Process 2: Open SurfaceID2 using both SurfaceManager1 and SurfaceManager2

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

						Process 2: Kill the process

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

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

						Process 1: Close surfaceID1 and SurfaceManager3

@SYMTestStatus			Implemented

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

@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.

*/

	case 4:

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

		TestCloseChannelsMultiProcess2L();

		break;		

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0048

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Multiprocess API testing for getting information using SurfaceInfo

						Process 1: Create the Surface

						Process 2: Receive the Surface Id 

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

						Process 2: Open the surface using the id	

						Process 2: Map the surface

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

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

@SYMTestStatus			Implemented

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

@SYMTestExpectedResults The surface can be successfully transmitted between processes

*/

	case 5:

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

		TestSurfaceInfoUsingSurfaceIdL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0049

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Multiprocess API testing for opening the Surface using SurfaceId

						Priocess 1: Create the surface

						Process 2: Receive the Surface id

						Process 2: Open the Surface using the stored SurfaceId

						Process 2: Check that it returns KErrNone

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),OpenSurface()

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

*/

	case 6:

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

		TestOpeningSurfaceUsingSurfaceIdL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0050

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

						Receive a Surface Id from another process

						Change Surface Id by

							1. adding 500 to the SurfaceId

							2. making the Surface ID negative

							3. converting the type of the Surface ID to EInvalidSurface

						Call OpenSurface using the new SurfaceId					

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),OpenSurface()

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

*/

	case 7:

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

		TestOpenSurfaceInvalidParamsL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0051

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Closing an unopened surface in a second process 

						Process 1: Create Surface

						Process 2: Close Surface 		

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface()

@SYMTestExpectedResults Check that CloseSurface() returns KErrAccessDenied		

*/

	case 8:

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

		TestClosingUnopenedSurfaceL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0052

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

@SYMTestStatus			Implemented

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

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

*/

	case 9:

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

		TestSurfaceInfoUnopenedSurfaceL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0053

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

						leaves surface accessible in first 2 processes 

@SYMTestStatus			Implemented

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

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

*/

	case 10:

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

		CreateOpenCloseThreeProcessL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0054

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test surface can be accessed when creating process dies

						Process 2: Create Surface

						Process 1: Open Surface

						Process 2: Kill Process

						Process 1: Map Surface 

						Process 1: Surface Info

@SYMTestStatus			Implemented

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

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

*/

	case 11:

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

		TestSurfaceAccessWhenCreatingProcessDiesL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0055

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test surface can be closed when creating process dies

						Process 2: Create Surface

						Process 1: Open Surface

						Process 2: Kill Process

						Process 1: Close Surface 

@SYMTestStatus			Implemented

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

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

*/

	case 12:

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

		TestClosingSurfaceWhenCreatingProcessDiesL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0056

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test surface can be closed from third process when 

						creating process dies and second process closes

						Process 2: Create Surface

						Process 1: Open Surface

						Process 3: Open Surface

						Process 2: Kill Process

						Process 1: Close Surface - KErrNone

						Process 3: Close Surface - KErrNone

						Process 3: Open Surface - KErrArgument

@SYMTestStatus			Implemented

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

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

						creating process dies and second process closes	

*/

	case 13:

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

		TestCloseSurfaceInThirdProcessL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0057

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

						and closed in the first process.

						Process 2: Create Surface

						Process 1: Open Surface

						Process 1: Close Surface

						Process 2: Kill Process

						Process 1: Open Surface 

@SYMTestStatus			Implemented

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

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

*/

	case 14:

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

		TestNoAccessWhenSurfaceClosedTwoProcessL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0058

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

						provided one process still owns surface

						Process 1: Create Surface

						Process 2: Open Surface

						Process 2: Close Surface

						Process 3: Open Surface - KErrNone

@SYMTestStatus			Implemented

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

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

						provided one process still owns surface

*/

	case 15:

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

		TestOpeningOnProcessAfterClosingOnOtherL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0059

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

						processes, provided one process still owns surface

						Process 1: Create Surface

						Process 2: Open Surface

						Process 2: Close Surface

						Process 1: Map Surface - KErrNone

						Process 1: SurfaceInfo - KErrNone

@SYMTestStatus			Implemented

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

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

*/

	case 16:

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

		TestAccessAfterClosingL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0060

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

						has already been closed in a second process 

						Process 1: Create Surface

						Process 2: Open Surface

						Process 2: Close Surface

						Process 1: Close Surface 

@SYMTestStatus			Implemented

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

@SYMTestExpectedResults Check Close Surface in process 1 returns KErrNone

*/

	case 17:

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

		TestClosingAfterClosingOnOtherProcessL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0061

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

						Process 1: Create Surface

						Process 2: Map Surface  

						Process 2: Surface Info 

@SYMTestStatus			Implemented

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

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

*/

	case 18:

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

		TestErrSufaceAccessNotOpenL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0062

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

						Process 1: Create Surface

						Process 1: Map Surface 

						Process 1: Write to buffer

						Process 2: Open the surface 

						Process 2: Read from buffer 

@SYMTestStatus			Implemented

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

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

*/

	case 19:

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

		TestReadFromBufferInSecondProcessL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0063

@SYMPREQ				PREQ1007, PREQ 1879

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

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

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

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

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

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

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

@SYMTestStatus			Implemented

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

@SYMTestExpectedResults GetSurfaceHint() behaves properly in the multiprocess. 

*/

	case 20:

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

		TestGetSurfaceHintMultiProcessL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0064

@SYMPREQ				PREQ1007, PREQ 1879

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

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

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

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

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

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

								   Check the retrieved THintPair has the iValue set to 300.

@SYMTestStatus			Implemented

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

@SYMTestExpectedResults SetSurfaceHint() behaves properly in the multiprocess. 

*/

	case 21:

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

		TestSetSurfaceHintMultiProcessL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0065

@SYMPREQ				PREQ1007, PREQ 1879

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

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

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

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

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

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

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

@SYMTestStatus			Implemented

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

@SYMTestExpectedResults AddSurfaceHint() behaves properly in the multiprocess. 

*/

	case 22:

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

		TestAddSurfaceHintMultiProcessL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0066

@SYMPREQ				PREQ1007, PREQ 1879

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

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

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

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

						Check that returns KerrNoMemory

						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).

						Check that returns KerrNoMemory

@SYMTestStatus			Implemented

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

@SYMTestExpectedResults OpenSurface and AddConnection should return KerrNoMemory. 

*/		

	case 23:

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

#ifdef _DEBUG

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

		TestOutofMemoryCasesL();

#endif

		break;

	default:

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

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

		TestComplete();

		break;

		}

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

	// Handle check

	TInt procHandles2  =0;

	TInt threadHandles2=0;

	RThread().HandleCount(procHandles2,threadHandles2);

	if (threadHandles1 != threadHandles2)

		{

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

		}

	}

void CTSurfaceManagerMultiProcess::TestMapSurfaceExistinChunkL()

	{

	// Create a surface in a new shared chunk

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

	// Open the surface manager

	RSurfaceManager surfaceManager;