// 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 <e32debug.h>

 #include <e32def_private.h>

 #include <graphics/surface.h>

 #include <graphics/surfacemanager.h>

 #include "tsmgmultprocessshared.h"

 LOCAL_D RTest test(_L("TReceiveSurface"));

 class CTestDriverSecondProcess : public CTestDriver

 {

 public:

 	CTestDriverSecondProcess();

 	~CTestDriverSecondProcess();

 	void ConstructL();

 	static CTestDriverSecondProcess* NewL();

 public:

 	void TestMultipleChannelsInSecondProcess2();

 	void TestMultipleChannelsInSecondProcess1();

 	void TestCheckSyncOperation();

 	void TestCheckHandleInSecondProcess();

 	void TestSurfaceInfoUsingSurfaceId();

 	void TestOpeningSurfaceUsingSurfaceId();

 	void TestOpeningSurfaceInvalidParams();

 	void OpenWaitMap();

 	void CreateWaitKill();

 	void OpenClose();

 	void MapSurfaceInfoCantAccess();

 	void TestReadFromBufferInSecondProcess();

 	void TestGetSurfaceHint();

 	void TestSetSurfaceHint();

 	void TestAddSurfaceHint();

 	void TestOutofMemory();

 private:

 	RSurfaceManager iSurfaceManagerTwo;

 };

 CTestDriverSecondProcess::CTestDriverSecondProcess():CTestDriver()

 	{

 	}

 CTestDriverSecondProcess::~CTestDriverSecondProcess()

 	{

 	iSurfaceManagerTwo.Close();

 	}

 void CTestDriverSecondProcess::ConstructL()

 	{

 	CTestDriver::ConstructL();

 	User::LeaveIfError(	iSurfaceManagerTwo.Open());	

 	}

 CTestDriverSecondProcess* CTestDriverSecondProcess::NewL()

 {

 	CTestDriverSecondProcess * driver = new (ELeave) CTestDriverSecondProcess();

 	CleanupStack::PushL(driver);

 	driver->ConstructL();

 	CleanupStack::Pop(driver);

 	return driver;

 }

 void CTestDriverSecondProcess::TestMultipleChannelsInSecondProcess2()

 	{

    	// Store the attributes used to create the Surface

 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

 	RSurfaceManager::TSurfaceCreationAttributes& attributes = buf();

 	attributes.iSize = TSize(280,301);

 	attributes.iBuffers = 1;

 	attributes.iPixelFormat = EUidPixelFormatYUV_422SemiPlanar; // 2bpp

 	attributes.iStride = 1;

 	attributes.iOffsetToFirstBuffer = 1;

 	attributes.iAlignment = 1;

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

 	attributes.iHintCount = 2;

 	attributes.iSurfaceHints = hints;

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

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

 	attributes.iContiguous = ETrue;

 	attributes.iCacheAttrib = RSurfaceManager::ECached;

 	attributes.iOffsetBetweenBuffers = 0;

 	attributes.iMappable = ETrue;

 	// Create the surface

 	TSurfaceId surfaceIdOne;

     if(KErrNone == iSurfaceManager.CreateSurface(buf, surfaceIdOne))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	// Create the surface

 	TSurfaceId surfaceIdTwo;

     if(KErrNone == iSurfaceManager.CreateSurface(buf, surfaceIdTwo))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

     if(KErrNone == iSurfaceManager.OpenSurface(surfaceIdTwo))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

     if(KErrNone == iSurfaceManagerTwo.OpenSurface(surfaceIdOne))

 		{

 		iTestResult |= EFourthTestPassed;

 		}

     // Set the results so they can be read and tested by the first process

     iChunkWrapper->SetSecondProcessResults(iTestResult);

     // Put the surfaceId onto the shared chunk

     iChunkWrapper->SetId(surfaceIdOne);

     // Pass control back to the first process

     RSemaphore sem;

 	if(KErrNone == sem.OpenGlobal(KMultiProcessSemaphore))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

     sem.Signal();

     RSemaphore sem2;

 	if(KErrNone == sem2.OpenGlobal(KMultiProcessSemaphore2))

 		{

 		iTestResult |= EFourthTestPassed;

 		}

     sem2.Wait();

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 //	  // Put the surfaceId onto the shared chunk

 	iChunkWrapper->SetId(surfaceIdTwo);

 	sem.Close();

 	sem2.Close();

 	}

 void CTestDriverSecondProcess::TestMultipleChannelsInSecondProcess1()

 	{

 	// Open the chunk wrapper and get the surfaceId

 	TSurfaceId surfaceIdOne = iChunkWrapper->GetId();

 	// Open the surface using the surfaceId - check that it returns KErrNone

 	if(KErrNone == iSurfaceManager.OpenSurface(surfaceIdOne))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

     // Pass control back to the first process

     RSemaphore sem;

 	if(KErrNone == sem.OpenGlobal(KMultiProcessSemaphore))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

     RSemaphore sem2;

 	if(KErrNone == sem2.OpenGlobal(KMultiProcessSemaphore2))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

    	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	sem.Signal();

 	sem2.Wait();

 	// Get the surface info

 	RSurfaceManager::TInfoBuf infoBuf;

 	if(KErrNone == iSurfaceManager.SurfaceInfo(surfaceIdOne, infoBuf))

 		{

 		iTestResult |= EFourthTestPassed;

 		}

 	TSurfaceId surfaceIdTwo = iChunkWrapper->GetId();

 	if(KErrArgument == iSurfaceManager.SurfaceInfo(surfaceIdTwo, infoBuf))

 		{

 		iTestResult |= EFifthTestPassed;

 		}

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	sem.Close();

 	sem2.Close();

 	}

 void CTestDriverSecondProcess::TestCheckSyncOperation()

 	{

 	// Open the chunk wrapper and get the surfaceId

 	TSurfaceId surfaceId = iChunkWrapper->GetId();

 	// Check it returns KErrAccessDenied when the surface is not Open

 	TInt bufferNo = 1;

 	RSurfaceManager::TSyncOperation syncOperation = RSurfaceManager::ESyncBeforeNonCPURead;

 	if(KErrAccessDenied == iSurfaceManager.SynchronizeCache(surfaceId, bufferNo,syncOperation))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	// Open the surface using the surfaceId - check that it returns KErrNone

 	if(KErrNone == iSurfaceManager.OpenSurface(surfaceId))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	// Map the surface 

 	RChunk handle;

 	if(KErrNone == iSurfaceManager.MapSurface(surfaceId, handle))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

 	if(KErrNone == iSurfaceManager.SynchronizeCache(surfaceId, bufferNo,syncOperation))

 		{

 		iTestResult |= EFourthTestPassed;

 		}

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	// Close the chunkwrapper, handle and the surface manager

  	handle.Close();

 	}

 void CTestDriverSecondProcess::TestCheckHandleInSecondProcess()

 	{

 	// Open the chunk wrapper and get the surfaceId

 	TSurfaceId surfaceId = iChunkWrapper->GetId();

 	// Open the surface using the surfaceId - check that it returns KErrNone

 	if(KErrNone == iSurfaceManager.OpenSurface(surfaceId))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	// Map the surface 

 	RChunk handle;

 	if(KErrNone == iSurfaceManager.MapSurface(surfaceId, handle))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	// Get the surface info

 	RSurfaceManager::TInfoBuf infoBuf;

 	if(KErrNone == iSurfaceManager.SurfaceInfo(surfaceId, infoBuf))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

 	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

 	// Get the adress of this chunk of memory

 	TUint8* surfaceAdd = handle.Base();

 	TInt offsetToFirstBuffer;

 	if(KErrNone == iSurfaceManager.GetBufferOffset(surfaceId, 0, offsetToFirstBuffer))

 		{

 		iTestResult |= EFourthTestPassed;

 		}

 	TUint8* bufferAdd = surfaceAdd + offsetToFirstBuffer;

 	// Write to the first buffer, and test the value is written

 	*bufferAdd = 20;

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	// Close the chunkwrapper, handle and the surface manager

 	handle.Close();

 	}

 /**

 Test 18. Receiving a surface and querying SurfaceInfo for surface properties

 Process 1: Create the Surface

 Process 2: Receive the Surface Id 

 Process 2: Receive the attributes used to create 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

 Check if these are equal to the ones received.

 @see TestSurfaceInfoUsingSurfaceIdL() in tsurfacemanager.cpp

 */	

 void CTestDriverSecondProcess::TestSurfaceInfoUsingSurfaceId()

 	{	

 	// Set attributes for the surface - these are expected attributes in the second process

 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

 	RSurfaceManager::TSurfaceCreationAttributes& attributes=buf();				

     attributes.iSize = TSize(100,100);

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

     attributes.iPixelFormat = EUidPixelFormatYUV_422SemiPlanar;     // 2bpp

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

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

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

     attributes.iContiguous=ETrue;

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

 	attributes.iHintCount = 2;

 	attributes.iSurfaceHints = hints;

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

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

 	attributes.iOffsetBetweenBuffers = 0;

 	attributes.iCacheAttrib = RSurfaceManager::ENotCached;

 	attributes.iMappable = ETrue;

 	TSurfaceId surfaceId = iChunkWrapper->GetId();

 	// Open the surface using the surfaceId - check that it returns KErrNone

 	if(KErrNone == iSurfaceManager.OpenSurface(surfaceId))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	// Map the surface 

 	RChunk handle;

 	if(KErrNone == iSurfaceManager.MapSurface(surfaceId, handle))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	// Get the surface info

 	RSurfaceManager::TInfoBuf infoBuf;

 	if(KErrNone == iSurfaceManager.SurfaceInfo(surfaceId, infoBuf))		

 		{

 		iTestResult |= EThirdTestPassed;

 		}

 	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

 	TInt offsetToFirstBuffer;

 	if(KErrNone == iSurfaceManager.GetBufferOffset(surfaceId, 0, offsetToFirstBuffer))  	

 		{

 		iTestResult |= EFourthTestPassed;

 		}

 	if(info.iSize == attributes.iSize)

 		{

 		iTestResult |= EFifthTestPassed;

 		}

 	if(info.iBuffers == attributes.iBuffers)

 		{

 		iTestResult |= ESixthTestPassed;

 		}

 	if(info.iPixelFormat == attributes.iPixelFormat)

 		{

 		iTestResult |= ESeventhTestPassed;

 		}

 	if(info.iStride == attributes.iStride)

 		{

 		iTestResult |= EEighthTestPassed;

 		}

 	if(offsetToFirstBuffer >= attributes.iOffsetToFirstBuffer)

 		{

 		iTestResult |= ENinthTestPassed;

 		}

 	if(info.iContiguous == attributes.iContiguous)

 		{

 		iTestResult |= ETenthTestPassed;

 		}

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	// Close handle 

 	handle.Close();

 	}

 /**

 Test 19. Opening a surface using surfaceId

 Priocess 1: Create the surface

 Process 2: Receive the Surface id

 Process 2: Open the Surface using the stored Surface id

 Check OpenSurface returns KErrNone

 @see TestOpeningSurfaceUsingSurfaceIdL() in tsurfacemanager.cpp

 */

 void CTestDriverSecondProcess::TestOpeningSurfaceUsingSurfaceId()

 	{

 	// Open the chunk wrapper and get the surfaceId

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

 	TSurfaceId surfaceId = iChunkWrapper->GetId();

 	// Open the surface using the surfaceId - check that it returns KErrNone	

 	if(KErrNone == iSurfaceManager.OpenSurface(surfaceId))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	}

 /**

 Test 20. Opening a surface using invalid surfaceId

 Process 1:Create the surface

 Process 2: Receive a Surface Id

 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

 Process 2: Call OpenSurface using the new SurfaceId

 Check that the return value of OpenSurface is KErrArgument

 @see TestOpenSurfaceInvalidParams() in tsurfacemanager.cpp

 */

 void CTestDriverSecondProcess::TestOpeningSurfaceInvalidParams()

 	{

 	TSurfaceId surfaceId = iChunkWrapper->GetId();

 	// Open Surface using the right Id

 	if(KErrNone == iSurfaceManager.OpenSurface(surfaceId))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	// Open the surface using the invalid surfaceId - check that it returns KErrArgument

 	TSurfaceId invalidSurfaceId = surfaceId; 

 	//Add 500 to the first field of surfaceId

 	invalidSurfaceId.iInternal[0] = surfaceId.iInternal[0]+500;

 	if(KErrArgument == iSurfaceManager.OpenSurface(invalidSurfaceId))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	// Change the surfaceId type to EInvalidSurface

 	invalidSurfaceId.iInternal[3] = (surfaceId.iInternal[3] & 0x00FFFFFF) | ( TSurfaceId::EInvalidSurface <<24 ) ;

 	if(KErrArgument == iSurfaceManager.OpenSurface(invalidSurfaceId))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	}

 /**

 Test 22: Create, Open and Close in 3 different processes, 

 			leaves surface accessible in first 2 processes 

 ...	

 Process 2: Open Surface

 ...

 Process 2: MapSurface - KErrNone (still accessible)

 ...

 */

 void CTestDriverSecondProcess::OpenWaitMap()

 	{

 	// Find the surfaceId

 	TSurfaceId id = iChunkWrapper->GetId();

 	// Open Surface

 	if(KErrNone == iSurfaceManager.OpenSurface(id))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	// Pass control back to the first process

     RSemaphore sem;

 	if(KErrNone == sem.OpenGlobal(KMultiProcessSemaphore))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

     sem.Signal();

     RSemaphore sem2;

 	if(KErrNone == sem2.OpenGlobal(KMultiProcessSemaphore2))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

     sem2.Wait();

     // Map surface

 	RChunk handle;

 	if(KErrNone == iSurfaceManager.MapSurface(id, handle))

 		{

 		iTestResult |= EFourthTestPassed;

 		}

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	sem.Close();

 	sem2.Close();

 	handle.Close();

 	}

 /**

 Test 23/24/25/26: 	Test surface can be accessed when creating process dies /

 					Test surface can be closed when creating process dies /

 					Test surface can be closed from third process when 

 					creating process dies and second process closes / 

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

 					and closed in the first process.

 Process 2: Create Surface

 ...

 Process 2: Kill Process

 ...

 */

 void CTestDriverSecondProcess::CreateWaitKill()

 	{

 	// Setup attributes

     RSurfaceManager::TSurfaceCreationAttributesBuf buf;

 	RSurfaceManager::TSurfaceCreationAttributes& attributes = buf();

 	attributes.iSize = TSize(20,80);    	// w > 0, h > 0

 	attributes.iBuffers = 12; 				// > 0

 	attributes.iPixelFormat = EUidPixelFormatYUV_422SemiPlanar;	// 2bpp

 	attributes.iStride = 250;				// > 0, < width * bpp

 	attributes.iOffsetToFirstBuffer = 200;	// > 0, divisible by alignment

 	attributes.iAlignment = 4;				// 1 || 2 || 4 || 8

 	attributes.iContiguous = ETrue;

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

 	attributes.iHintCount = 2;

 	attributes.iSurfaceHints = hints;

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

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

 	attributes.iOffsetBetweenBuffers = 0;

 	attributes.iMappable = ETrue;

 	// Create the surface

 	TSurfaceId surfaceId;

     if(KErrNone == iSurfaceManager.CreateSurface(buf, surfaceId))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

     // Put the surfaceId onto the shared chunk

     iChunkWrapper->SetId(surfaceId);

     // Pass control back to the first process

     RSemaphore sem;

 	if(KErrNone == sem.OpenGlobal(KMultiProcessSemaphore))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

     sem.Signal();

     RSemaphore sem2;

 	if(KErrNone == sem2.OpenGlobal(KMultiProcessSemaphore2))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

     sem2.Wait();

     // Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 //  CleanupStack::PopAndDestroy(2,&sem);

 	sem.Close();

 	sem2.Close();

 	}

 /**

 Test 27/28/29: 	Test closing doesn't prevent opening on another process

 				Test closing doesn't prevent access on another process

 				Test closing a surface in the creating process 

 				when it has already been closed in a second process returns KErrNone

 ...

 Process 2: Open Surface

 Process 2: Close Surface

 ...

 */

 void CTestDriverSecondProcess::OpenClose()

 	{

 	// Find the surfaceId

 	TSurfaceId id = iChunkWrapper->GetId();

 	// Open Surface

 	if(KErrNone == iSurfaceManager.OpenSurface(id))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	// Close Surface

 	if(KErrNone == iSurfaceManager.CloseSurface(id))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	// Pass control back to the first process

     RSemaphore sem;

 	if(KErrNone == sem.OpenGlobal(KMultiProcessSemaphore))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

     sem.Signal();

     RSemaphore sem2;

 	if(KErrNone == sem2.OpenGlobal(KMultiProcessSemaphore2))

 		{

 		iTestResult |= EFourthTestPassed;

 		}

     sem2.Wait();

     // Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	sem.Close();

 	sem2.Close();

 	}

 /**

 Test 30: Test a surface cannot be accessed in a second process if not opened

 ...

 Process 2: Map Surface - KErrAccessDenied

 Process 2: Surface Info - KErrAccessDenied

 */

 void CTestDriverSecondProcess::MapSurfaceInfoCantAccess()

 	{

 	// Find the surfaceId

 	TSurfaceId id = iChunkWrapper->GetId();

 	// Map surface

 	RChunk handle;

 	if(KErrAccessDenied == iSurfaceManager.MapSurface(id, handle))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	// Surface Info

 	RSurfaceManager::TInfoBuf infoBuf;

 	if(KErrAccessDenied == iSurfaceManager.SurfaceInfo(id, infoBuf))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	// Pass control back to the first process

     RSemaphore sem;

 	if(KErrNone == sem.OpenGlobal(KMultiProcessSemaphore))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

     sem.Signal();

     RSemaphore sem2;

 	if(KErrNone == sem2.OpenGlobal(KMultiProcessSemaphore2))

 		{

 		iTestResult |= EFourthTestPassed;

 		}

     sem2.Wait();

     // Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 //	CleanupStack::PopAndDestroy(3,&handle);

 	sem.Close();

 	sem2.Close();

 	handle.Close();

 	}

 /**

 Test 31: Test that a buffer written to in one surface 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 

 */	

 void CTestDriverSecondProcess::TestReadFromBufferInSecondProcess()

 	{

 	// Find the surfaceId

 	TSurfaceId id = iChunkWrapper->GetId();

 	// Open Surface

 	if(KErrNone == iSurfaceManager.OpenSurface(id))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	// Map surface

 	RChunk handle;

 	if(KErrNone == iSurfaceManager.MapSurface(id, handle))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	// Read from the buffer

 	RSurfaceManager::TInfoBuf infoBuf;

 	if(KErrNone == iSurfaceManager.SurfaceInfo(id, infoBuf))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

 	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

 	TUint8* surfaceAdd = handle.Base();

 	TInt offsetToFirstBuffer;

 	if(KErrNone == iSurfaceManager.GetBufferOffset(id, 0, offsetToFirstBuffer))

   		{

 		iTestResult |= EFourthTestPassed;

 		}

 	TUint8* bufferAdd = surfaceAdd + offsetToFirstBuffer;

 	if(*bufferAdd == 134)

 		{

 		iTestResult |= EFifthTestPassed;

 		}

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	handle.Close();

 	}

 void CTestDriverSecondProcess::TestGetSurfaceHint()

 	{

 	// Open the chunk wrapper and get the surfaceId

 	TSurfaceId surfaceId = iChunkWrapper->GetId();

 	RSurfaceManager::THintPair hintPair;

 	hintPair.iKey.iUid = 0x124578;

 	if (KErrAccessDenied == iSurfaceManager.GetSurfaceHint(surfaceId, hintPair))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	if(KErrNone == iSurfaceManager.OpenSurface(surfaceId))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	if (KErrNone == iSurfaceManager.GetSurfaceHint(surfaceId, hintPair))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	}

 void CTestDriverSecondProcess::TestSetSurfaceHint()

 	{

 	// Open the chunk wrapper and get the surfaceId

 	TSurfaceId surfaceId = iChunkWrapper->GetId();

 	RSurfaceManager::THintPair hintPair;

 	hintPair.iKey.iUid = 0x124578;

 	hintPair.iValue = 300;

 	if (KErrAccessDenied == iSurfaceManager.SetSurfaceHint(surfaceId, hintPair))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	if(KErrNone == iSurfaceManager.OpenSurface(surfaceId))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	if (KErrNone == iSurfaceManager.SetSurfaceHint(surfaceId, hintPair))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

 	RSurfaceManager::THintPair hintPairNew;

 	hintPairNew.iKey.iUid = 0x124578;

 	iSurfaceManager.GetSurfaceHint(surfaceId,hintPairNew);

 	if (hintPairNew.iValue == hintPair.iValue)

 		{

 		iTestResult |= EFourthTestPassed;		

 		}

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	}

 void CTestDriverSecondProcess::TestAddSurfaceHint()

 	{

 	// Open the chunk wrapper and get the surfaceId

 	TSurfaceId surfaceId = iChunkWrapper->GetId();

 	RSurfaceManager::THintPair hintPair;

 	hintPair.iKey.iUid = 0x124580;

 	hintPair.iValue = 300;

 	hintPair.iMutable = ETrue;

 	if (KErrAccessDenied == iSurfaceManager.AddSurfaceHint(surfaceId, hintPair))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	if(KErrNone == iSurfaceManager.OpenSurface(surfaceId))

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	if (KErrNone == iSurfaceManager.AddSurfaceHint(surfaceId, hintPair))

 		{

 		iTestResult |= EThirdTestPassed;

 		}

 	RSurfaceManager::THintPair hintPairNew;

 	hintPairNew.iKey.iUid = 0x124580;

 	iSurfaceManager.GetSurfaceHint(surfaceId,hintPairNew);

 	if (hintPairNew.iValue == hintPair.iValue)

 		{

 		iTestResult |= EFourthTestPassed;		

 		}

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	}

 void CTestDriverSecondProcess::TestOutofMemory()

 	{

 	// Open the chunk wrapper and get the surfaceId

 	TSurfaceId surfaceId = iChunkWrapper->GetId();

 	// Test OOM in OpenSurface()

 	__KHEAP_SETFAIL(RHeap::EDeterministic, 1);

 	if (KErrNoMemory == iSurfaceManager.OpenSurface(surfaceId))

 		{

 		iTestResult |= EFirstTestPassed;

 		}

 	__KHEAP_RESET;

 	// Test OOM in AddConnection()

 	RSurfaceManager surfaceManagerTest;

 	__KHEAP_SETFAIL(RHeap::EDeterministic, 1);

 	if (KErrNoMemory == surfaceManagerTest.Open())

 		{

 		iTestResult |= ESecondTestPassed;

 		}

 	__KHEAP_RESET;

 	// Set the results so they can be read and tested by the first process

 	iChunkWrapper->SetSecondProcessResults(iTestResult);

 	}

 // Real main function

 void MainL()

 	{

 	test.Title();

 	RDebug::Print(_L("marker"));

 	test.Start(_L("Starting 2nd Process"));

 	TInt testCase;

 	User::GetTIntParameter(EMultiProcessSecondSlot, testCase);

 	TInt procHandles1  =0;

 	TInt threadHandles1=0;

 	RThread().HandleCount(procHandles1, threadHandles1);

 	CTestDriverSecondProcess* testDriver = CTestDriverSecondProcess::NewL(); 

 	CleanupStack::PushL(testDriver);

 	switch(testCase)

 		{

 	case ETestInfoReceivedSurface:

 		testDriver->TestSurfaceInfoUsingSurfaceId();

 		break;

 	case ETestOpenReceivedSurface:

 		testDriver->TestOpeningSurfaceUsingSurfaceId();

 		break;

 	case ETestOpenSurfaceInvalidParams:

 		testDriver->TestOpeningSurfaceInvalidParams();	

 		break;

 	case EOpenWaitMap:

 		testDriver->OpenWaitMap();

 		break;	

 	case ECreateWaitKill:

 		testDriver->CreateWaitKill();

 		break;

 	case EOpenClose:

 		testDriver->OpenClose();

 		break;

 	case EMapSurfaceInfoCantAccess:

 		testDriver->MapSurfaceInfoCantAccess();

 		break;

 	case EReadFromBuffer:

 		testDriver->TestReadFromBufferInSecondProcess();

 		break;

 	case ECheckHandle:

 		testDriver->TestCheckHandleInSecondProcess();

 		break;

 	case ESyncOperation:

 		testDriver->TestCheckSyncOperation();

 		break;

 	case ETestChannelMultiProcess1:

 		testDriver->TestMultipleChannelsInSecondProcess1();

 		break;

 	case ETestChannelMultiProcess2:

 		testDriver->TestMultipleChannelsInSecondProcess2();

 		break;

 	case EGetSurfaceHint:

 		testDriver->TestGetSurfaceHint();

 		break;

 	case ESetSurfaceHint:

 		testDriver->TestSetSurfaceHint();

 		break;

 	case EAddSurfaceHint:

 		testDriver->TestAddSurfaceHint();

 		break;

 	case ECheckOutofMemory:

 #ifdef _DEBUG

 		testDriver->TestOutofMemory();

 #endif

 		break;

 	default:

 		User::Leave(KErrArgument);

 		break;

 		}

 	CleanupStack::PopAndDestroy(testDriver);

 	// Handle check

 	TInt procHandles2  =0;

 	TInt threadHandles2=0;

 	RThread().HandleCount(procHandles2,threadHandles2);

 	if (threadHandles1 != threadHandles2)

 		{

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

 		}

 	test.End();

 	test.Close();

 	}

 // Cleanup stack harness

 GLDEF_C TInt E32Main()

 	{

 	__UHEAP_MARK;

 	CTrapCleanup* cleanupStack = CTrapCleanup::New();

 	TRAPD(error, MainL());

 	_LIT(KTSecondProcessPanic,"tsecondprocessmain");

 	__ASSERT_ALWAYS(!error, User::Panic(KTSecondProcessPanic, error));

 	delete cleanupStack;

 	__UHEAP_MARKEND;

 	return 0;

 	}