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

#include <e32std.h>

#include <graphics/surface.h>

#include <graphics/surfacemanager.h>

#include "tsmgmultprocessshared.h"

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

class CTestDriverThirdProcess : public CTestDriver

{

public:

	CTestDriverThirdProcess();

	static CTestDriverThirdProcess* NewL();

public:

	void CloseSurface();

	void SurfaceInfo();

	void OpenWaitCloseOpen();

	void OpenSurface();

};

CTestDriverThirdProcess::CTestDriverThirdProcess():CTestDriver()

	{}

CTestDriverThirdProcess* CTestDriverThirdProcess::NewL()

	{

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

	CleanupStack::PushL(driver);

	driver->CTestDriver::ConstructL();

	CleanupStack::Pop(driver);

	return driver;

	}

void CTestDriverThirdProcess::CloseSurface()

	{

	TSurfaceId id = iChunkWrapper->GetId();

	// Close Surface

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

		{

		iTestResult |= EFirstTestPassed;

		}

	iChunkWrapper->SetThirdProcessResults(iTestResult);

	}

void CTestDriverThirdProcess::SurfaceInfo()

	{

	TSurfaceId id = iChunkWrapper->GetId();

	// SurfaceInfo

	// Call Surface Info on the surface in this process

	RSurfaceManager::TInfoBuf infoBuf;

	if(KErrAccessDenied == iSurfaceManager.SurfaceInfo(id,infoBuf))// This is correct?

		{

		iTestResult |= EFirstTestPassed;

		}

	iChunkWrapper->SetThirdProcessResults(iTestResult);

	}

/**

Test 25: Test surface can be accessed from third process when creating 

			process dies and second process closes

...			

Process 3: Open Surface

...

Process 3: Close Surface - KErrNone

Process 3: Open Surface - KErrArgument

*/	

void CTestDriverThirdProcess::OpenWaitCloseOpen()

	{

	TSurfaceId id = iChunkWrapper->GetId();

	// Open the surface using the surfaceId

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

		{

		iTestResult |= EFirstTestPassed;

		}

	// Pass control back to the first process

    RSemaphore sem3;

	if(KErrNone == sem3.OpenGlobal(KMultiProcessSemaphore3))

		{

		iTestResult |= ESecondTestPassed;

		}

    User::After(100000);

    sem3.Signal();

    RSemaphore sem4;

	if(KErrNone == sem4.OpenGlobal(KMultiProcessSemaphore4))

		{

		iTestResult |= EThirdTestPassed;

		}

    sem4.Wait();

	// Close the surface

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

		{

		iTestResult |= EFourthTestPassed;

		}

	// Open the surface

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

		{

		iTestResult |= EFifthTestPassed;

		}

	iChunkWrapper->SetThirdProcessResults(iTestResult);

	sem3.Close();

	sem4.Close();

	}

/**

Test 27: Test closing on one process doesn't prevent opening on other processes, 

			provided one process still owns surface

...

Process 3: Open Surface - KErrNone

...

*/	

void CTestDriverThirdProcess::OpenSurface()

	{	

	TSurfaceId id = iChunkWrapper->GetId();

	// Open Surface

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

		{

		iTestResult |= EFirstTestPassed;

		}

	iChunkWrapper->SetThirdProcessResults(iTestResult);

	}

// Real main function

void MainL()

	{

	test.Title();

	test.Start(_L("Staring 3rd process"));

	TInt testCase;

	User::GetTIntParameter(EMultiProcessSecondSlot, testCase);

	CTestDriverThirdProcess* testDriver = CTestDriverThirdProcess::NewL(); 

	switch(testCase)

		{

	case ECloseSurface:

		testDriver->CloseSurface();

		break;

	case ESurfaceInfo:

		testDriver->SurfaceInfo();

		break;

	case EOpenWaitCloseOpen:

		testDriver->OpenWaitCloseOpen();

		break;

	case EOpenSurface:

		testDriver->OpenSurface();

		break;

	default:

		User::Leave(KErrArgument);

		break;

		}

	delete testDriver;

	test.End();

	test.Close();

	}

// Cleanup stack harness

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanupStack = CTrapCleanup::New();

	TRAPD(error, MainL());

	_LIT(KTThirdProcessPanic,"tthirdprocessmain");

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

	delete cleanupStack;

	__UHEAP_MARKEND;

	return 0;

	}