// Copyright (c) 1996-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:

// Test process priority control

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TPROCPRI.H"

TName OtherGroupName;

TInt ProcPriTestOtherProcess(TAny *aScreenNumber)

	{

	CTrapCleanup* CleanUpStack=CTrapCleanup::New();

	RWsSession ws;

	User::LeaveIfError(ws.Connect());

	// use correct screen

	//

	CWsScreenDevice* screen = NULL;

	TInt err;

	TRAP(err, screen = new (ELeave) CWsScreenDevice(ws));

	if (err!=KErrNone)

		return err;

	if ((err=screen->Construct((TInt)aScreenNumber))!=KErrNone)

		{

		delete screen;

		return err;

		}

	RWindowGroup group(ws);

	group.Construct(888);

	group.SetName(OTHER_PROC_GROUP_NAME);

	RSemaphore sem1;

	RSemaphore sem2;

	sem1.OpenGlobal(PROC_PRI_SEMAPHORE_NAME1);

	sem2.OpenGlobal(PROC_PRI_SEMAPHORE_NAME2);

	sem1.Signal();	// Signal thread fully initialised

	sem2.Wait();		// Wait for command to disable focus

//

	group.EnableReceiptOfFocus(EFalse);

	ws.Flush();

	sem1.Signal();	// Signal focus disabled

	sem2.Wait();		// Wait for command to enable focus

	group.EnableReceiptOfFocus(ETrue);

	ws.Flush();

	sem1.Signal();	// Signal focus enabled

	sem2.Wait();		// Wait until signalled to exit

//

	group.EnableReceiptOfFocus(EFalse);	// To stop shell being tasked into foreground

	delete screen;

	ws.Close();

	sem1.Close();

	sem2.Close();

	delete CleanUpStack;

	return(KErrNone);

	}

CTProcPri::CTProcPri(CTestStep* aStep) : CTWsGraphicsBase(aStep)

	{

	}

CTProcPri::~CTProcPri()

	{

	if (iFlags&ECreatedSem1)

		iSem1.Close();

	if (iFlags&ECreatedSem2)

		iSem2.Close();

	delete iProcess;

	}

void CTProcPri::TestPriChangeL()

	{

	#define BACK_PRI EPriorityForeground

	#define FORE_PRI EPriorityForeground

	RProcess proc;

	TEST(proc.Priority()==BACK_PRI);

	if (proc.Priority()!=BACK_PRI)

		INFO_PRINTF3(_L("proc.Priority() return value - Expected: %d, Actual: %d"), BACK_PRI, proc.Priority());		

	iSem2.Signal();

	iSem1.Wait();

	TEST(proc.Priority()==FORE_PRI);

	if (proc.Priority()!=FORE_PRI)

		INFO_PRINTF3(_L("proc.Priority() return value - Expected: %d, Actual: %d"), FORE_PRI, proc.Priority());		

	iSem2.Signal();

	iSem1.Wait();

	TEST(proc.Priority()==BACK_PRI);

	if (proc.Priority()!=BACK_PRI)

		INFO_PRINTF3(_L("proc.Priority() return value - Expected: %d, Actual: %d"), BACK_PRI, proc.Priority());		

	TInt ident;

	User::LeaveIfError(ident=TheClient->iWs.FindWindowGroupIdentifier(0,OTHER_PROC_GROUP_NAME,0));

	TInt retVal = TheClient->iWs.SetWindowGroupOrdinalPosition(ident,1);

	TEST(retVal==KErrNone);

	if (retVal!=KErrNone)

		INFO_PRINTF3(_L("TheClient->iWs.SetWindowGroupOrdinalPosition(ident,1) return value - Expected: %d, Actual: %d"), KErrNone, retVal);		

	TEST(proc.Priority()==FORE_PRI);

	if (proc.Priority()!=FORE_PRI)

		INFO_PRINTF3(_L("proc.Priority() return value - Expected: %d, Actual: %d"), FORE_PRI, proc.Priority());		

	retVal = TheClient->iWs.SetWindowGroupOrdinalPosition(ident,0);

	TEST(retVal==KErrNone);

	if (retVal!=KErrNone)

		INFO_PRINTF3(_L("TheClient->iWs.SetWindowGroupOrdinalPosition(ident,0) return value - Expected: %d, Actual: %d"), KErrNone, retVal);		

	TEST(proc.Priority()==BACK_PRI);

	if (proc.Priority()!=BACK_PRI)

		INFO_PRINTF3(_L("proc.Priority() return value - Expected: %d, Actual: %d"), BACK_PRI, proc.Priority());		

	TRequestStatus stat;

	iProcess->Logon(stat);		//Must Logon before the last Signal so we can be sure that it is still alive to get round a base issue

	iSem2.Signal();

	User::WaitForRequest(stat);

	TEST(proc.Priority()==FORE_PRI);

		if (proc.Priority()!=FORE_PRI)

		INFO_PRINTF3(_L("proc.Priority() return value - Expected: %d, Actual: %d"), FORE_PRI, proc.Priority());		

	}

void CTProcPri::ConstructL()

	{

	User::LeaveIfError(iSem1.CreateGlobal(PROC_PRI_SEMAPHORE_NAME1,0,KOwnerType));

	iFlags|=ECreatedSem1;

	User::LeaveIfError(iSem2.CreateGlobal(PROC_PRI_SEMAPHORE_NAME2,0,KOwnerType));

	iFlags|=ECreatedSem2;

	iProcess=CProcess::NewL(CProcess::eProcessPriortyTest,iTest->iScreenNumber);

	iSem1.Wait();

	}

void CTProcPri::RunTestCaseL(TInt /*aCurTestCase*/)

	{

	_LIT(KTest1,"Priority Change");

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

	switch(++iTest->iState)

		{

/**

  @SYMTestCaseID GRAPHICS-WSERV-0315

  @SYMDEF             DEF081259

  @SYMTestCaseDesc Test that the priority of a process or thread changes depending

  					on how the the process or thread is being used

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Create a process or thread and use it. Check the priority of the

  					process or thread changes depending on how it is being used

  @SYMTestExpectedResults Prioirty of the process of thread changes depending on

  							how it is being used

*/

	case 1:

		((CTProcPriStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0315"));

		iTest->LogSubTest(KTest1);

		TestPriChangeL();

		break;

	case 2:

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

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

		TestComplete();

		break;

		}

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

	}

__WS_CONSTRUCT_STEP__(ProcPri)