// 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;
	}