// 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::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.