// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// The following tests are performed to test the Child behaviour on its Parent's termination.

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "T_ProcStep.h"

const TInt KTProcTerminatingChildI = 1246;

const TInt KTProcTerminatingChildII = 1247;

const TInt KTProcTerminatingChildIII = 1248;

const TInt KTProcTerminatingParent = 1249;

CChildProcess* CChildProcess::NewL(RProcess& aParentProcess,TProcessId aChildProcessId)

	{

	CChildProcess* self= new(ELeave) CChildProcess(aParentProcess,aChildProcessId);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CChildProcess::~CChildProcess()

/**

 * Destructor

 */

	{

	Cancel();

	}

void CChildProcess::ConstructL()

/**

 * Sets active, so that control goes into RunL() 

 * where parent is terminated and child process logged on.

 */	

 	{

	User::LeaveIfError(iChildProcess.Open(iChildProcessId));

	SetActive();

	TRequestStatus *status=&iStatus;

	User::RequestComplete(status,KErrNone);

	CActiveScheduler::Start();

	}

CChildProcess::CChildProcess(RProcess& aParentProcess,TProcessId aChildProcessId):CActive(0),iChildProcessId(aChildProcessId),iParentProcess(aParentProcess),iCount(0)

	{

	CActiveScheduler::Add(this);

	}

void CChildProcess::RunL()

/**

 * Opens the parent process, on failure leaves.

 * Logs on the child process status, sets it active and terminates the parent process.

 * When child terminates scheduler is stopped.

 */

	{

	switch(iCount)

		{

		case 0:

			iCount++;

			iChildProcess.Logon(iStatus);

			SetActive();

			iParentProcess.Terminate(KErrNone);

			break;

		case 1:

			CActiveScheduler::Stop();

		default:

			break;

		}

	}

void CChildProcess::DoCancel()

	{

	switch(iCount)

		{

		case 0:

			iChildProcess.LogonCancel(iStatus);

			iCount++;

			break;

		case 1:

			iChildProcess.LogonCancel(iStatus);

			break;

		default:

			break;

		}

	}

////////////////////////////////////////////////////////////////////////////

//

// T_ProcStep.cpp 

// ------------

//

// Implements the test cases to test Child behaviour on Parent termination.

//

////////////////////////////////////////////////////////////////////////////

CT_ProcStep::CT_ProcStep()

/**

 * Constructor

 */

	{

	}

CT_ProcStep::~CT_ProcStep()

/**

 * Destructor

 */

	{

	}

/**

 @SYMTestCaseID	APPFWK-APPARC-0015

 @SYMPREQ	PREQ1123

 @SYMTestCaseDesc The Test determines that the Child dies when its Parent is terminated.

 @SYMTestPriority Critical

 @SYMTestStatus Implemented

 @SYMTestActions. Creates and launches a process (parent). Creates another process (child) passing the first(parent) process ID.

 Launches the child process. Terminates parent and checks the existance of child process. The child should die.

 API Calls:\n

 RProcess::Create(const TDesC &aFileName, const TDesC &aCommand, TOwnerType aType=EOwnerProcess);\n

 RProcess::Resume();

 RProcess::ExitType() const;

 RProcess::ExitReason() const;

 RProcess::Id() const;

 CApaCommandLine::SetProcessEnvironmentL(RProcess &aProcess) const;

 CApaCommandLine::NewLC();

 CApaCommandLine::SetParentProcessId(TProcessId);

 @SYMTestExpectedResults Termination of child process automatically.\n

 */

void CT_ProcStep::testChildSetToTerminateL(void)

	{

	TInt ret(0);

	//commandline for parent process

	CApaCommandLine* parentProcCmdln=CApaCommandLine::NewLC();

	INFO_PRINTF1(_L("	CommandLine for Parent Process created "));

	//parent process

	RProcess parentProc;

	ret = parentProc.Create(KParentExe,KNullDesC);

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	CleanupClosePushL(parentProc);

	INFO_PRINTF2(_L("	Create Parent Process returned : %d"),ret);

	//attach commandline to parent process

	TRAP(ret,parentProcCmdln->SetProcessEnvironmentL(parentProc));

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	INFO_PRINTF1(_L("	Attach CommandLine to Process "));

	INFO_PRINTF1(_L("	Run Parent Process "));

	parentProc.Resume();

	//Time for the parent process to launch itself

	User::After(500000);

	//commandline for child process

	//Get parent process ID here

	TUint64 parentProcId = parentProc.Id();

	INFO_PRINTF2(_L("	Parent Process Id = 0x%lx "),parentProcId);

	CApaCommandLine* childProcCmdln=CApaCommandLine::NewLC();

	INFO_PRINTF1(_L("	CommandLine for Child Process created "));

	//setting the parent process ID to child

	childProcCmdln->SetParentProcessId(parentProcId);

	INFO_PRINTF1(_L("	Set ParentProcessId to Child "));

	//child process

	RProcess childProc;

	ret = childProc.Create(KChildOneExe,KNullDesC);

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	CleanupClosePushL(childProc);

	INFO_PRINTF2(_L("	Create Child Process returned : %d"),ret);

	//attach commandline to child process

	TRAP(ret,childProcCmdln->SetProcessEnvironmentL(childProc));

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	INFO_PRINTF1(_L("	Attach CommandLine to Process "));

	INFO_PRINTF1(_L("	Run Child Process "));

	childProc.Resume();

	//Time for the child process to launch itself

	User::After(500000);

	//child process Id is reqd to monitor if it gets killed on its parent's termination

	TUint64 childProcId = childProc.Id();

	INFO_PRINTF2(_L("	Child Process Id = 0x%lx "),childProcId);

	CChildProcess* childProcess=NULL;

	TRAP(ret, childProcess=CChildProcess::NewL(parentProc,childProcId));

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	CleanupStack::PushL(childProcess);

	TExitType exitType = parentProc.ExitType();

	TEST(exitType == EExitTerminate);

	TInt exitReason = parentProc.ExitReason();

	TEST(exitReason == 0);

	if(exitType==EExitTerminate && exitReason==0)

		{

		INFO_PRINTF1(_L("	Parent process is Terminated"));

		}

	exitType = childProc.ExitType();

	TEST(exitType == EExitTerminate);

	exitReason = childProc.ExitReason();

	TEST(exitReason == 0);

	if(exitType == EExitTerminate && exitReason==0)

		{

		INFO_PRINTF1(_L("	The child process is killed automatically ... "));

		}

	CleanupStack::PopAndDestroy(childProcess);

	CleanupStack::PopAndDestroy(&childProc);

	CleanupStack::PopAndDestroy(childProcCmdln);

	CleanupStack::PopAndDestroy(&parentProc);

	CleanupStack::PopAndDestroy(parentProcCmdln);

	}

/**

 @SYMTestCaseID APPFWK-APPARC-0016

 @SYMPREQ PREQ1123

 @SYMTestCaseDesc Test determines that the Child remains when its Parent is terminated.

 @SYMTestPriority Critical

 @SYMTestStatus Implemented

 @SYMTestActions. Creates and launches a process (parent). Creates another process (child) without passing the first(parent) process ID.

 Launches the child process. Terminates parent and checks the existance of child process. The child process should be alive.

 API Calls:\n

 RProcess::Create(const TDesC &aFileName, const TDesC &aCommand, TOwnerType aType=EOwnerProcess);\n

 RProcess::Resume();

 RProcess::ExitType() const;

 RProcess::ExitReason() const;

 RProcess::Id() const;

 RProcess::Terminate(TInt aReason);

 CApaCommandLine::SetProcessEnvironmentL(RProcess &aProcess) const;

 CApaCommandLine::NewLC();

 @SYMTestExpectedResults Existence of child process.\n

 */

void CT_ProcStep::testChildSetToRemainL(void)

	{

	TInt ret(0);

	//commandline for parent process

	CApaCommandLine* parentProcCmdln=CApaCommandLine::NewLC();

	INFO_PRINTF1(_L("	CommandLine for Parent Process created "));

	//parent process

	RProcess parentProc;

	ret = parentProc.Create(KParentExe,KNullDesC);

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	CleanupClosePushL(parentProc);

	INFO_PRINTF2(_L("	Create Parent Process returned : %d"),ret);

	//attach commandline to parent process

	TRAP(ret,parentProcCmdln->SetProcessEnvironmentL(parentProc));

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	INFO_PRINTF1(_L("	Attach CommandLine to Process "));

	INFO_PRINTF1(_L("	Run Parent Process "));

	parentProc.Resume();

	//Time for the parent process to launch itself

	User::After(500000);

	//commandline for child process

	//Get parent process ID here

	TUint64 parentProcId = parentProc.Id();

	INFO_PRINTF2(_L("	Parent Process Id = 0x%lx "),parentProcId);

	CApaCommandLine* childProcCmdln=CApaCommandLine::NewLC();

	INFO_PRINTF1(_L("	CommandLine for Child Process created "));

	//child process

	RProcess childProc;

	ret = childProc.Create(KChildOneExe,KNullDesC);

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	CleanupClosePushL(childProc);

	INFO_PRINTF2(_L("	Create Child Process returned : %d"),ret);

	//attach commandline to child process

	TRAP(ret,childProcCmdln->SetProcessEnvironmentL(childProc));

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	INFO_PRINTF1(_L("	Attach CommandLine to Process "));

	INFO_PRINTF1(_L("	Run Child Process "));

	childProc.Resume();

	//Time for the child process to launch itself

	User::After(500000);

	parentProc.Terminate(KTProcTerminatingParent);

		INFO_PRINTF1(_L("	Kill Parent Process ... "));

	TExitType exitType = parentProc.ExitType();

	TEST(exitType == EExitTerminate);

	TInt exitReason = parentProc.ExitReason();

	TEST(exitReason == KTProcTerminatingParent);

	//child process Id is reqd to monitor if it gets killed on its parent's termination

	TUint64 childProcId = childProc.Id();

	INFO_PRINTF2(_L("	Child Process Id = 0x%lx "),childProcId);

	//Wait for child to terminate ... if it really does

	User::After(10000000);

	exitType = childProc.ExitType();

	TEST(exitType == EExitPending);

	if(exitType == EExitPending)

		{

		INFO_PRINTF1(_L("	Child process is still running "));

		INFO_PRINTF1(_L("	so terminating it manually ..."));

		childProc.Terminate(KTProcTerminatingChildI);

		exitType = childProc.ExitType();

		TEST(exitType == EExitTerminate);

		exitReason = childProc.ExitReason();

		TEST(exitReason == KTProcTerminatingChildI);

		}

	CleanupStack::PopAndDestroy(&childProc);

	CleanupStack::PopAndDestroy(childProcCmdln);

	CleanupStack::PopAndDestroy(&parentProc);

	CleanupStack::PopAndDestroy(parentProcCmdln);

	}

/**

 @SYMTestCaseID APPFWK-APPARC-0017

 @SYMPREQ PREQ1123

 @SYMTestCaseDesc Test determines that one Child remains and another terminates when their Parent terminates, based on their creation.

 @SYMTestPriority High

 @SYMTestStatus Implemented

 @SYMTestActions. Creates and launches a process (parent). Creates a process (child I) passing the first (parent) process ID.

 Creates a second process (child II) without passing the first (parent) process ID. Launches both the child processes.

 Terminates parent and checks the existance of both the child processes. Child I should die and Child II should remain alive.

 API Calls:\n

 RProcess::Create(const TDesC &aFileName, const TDesC &aCommand, TOwnerType aType=EOwnerProcess);\n

 RProcess::Resume();

 RProcess::ExitType() const;

 RProcess::ExitReason() const;

 RProcess::Id() const;

 RProcess::Terminate(TInt aReason);

 CApaCommandLine::SetProcessEnvironmentL(RProcess &aProcess) const;

 CApaCommandLine::NewLC();

 CApaCommandLine::SetParentProcessId(TProcessId);

 @SYMTestExpectedResults Termination of first child process and existence of the second.\n

 */

void CT_ProcStep::testTwoChildsOneToTerminateAndOtherToRemainL(void)

	{

	TInt ret(0);

	TExitType exitType;

	//commandline for parent process

	CApaCommandLine* parentProcCmdln=CApaCommandLine::NewLC();

	INFO_PRINTF1(_L("	CommandLine for Parent Process created "));

	//parent process

	RProcess parentProc;

	ret = parentProc.Create(KParentExe,KNullDesC);

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	CleanupClosePushL(parentProc);

	INFO_PRINTF2(_L("	Create Parent Process returned : %d"),ret);

	//attach commandline to parent process

	TRAP(ret,parentProcCmdln->SetProcessEnvironmentL(parentProc));

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	INFO_PRINTF1(_L("	Attach CommandLine to Process "));

	INFO_PRINTF1(_L("	Run Parent Process "));

	parentProc.Resume();

	//Time for the parent process to launch itself

	User::After(500000);

	//commandline for child process

	//Get parent process ID here

	TUint64 parentProcId = parentProc.Id();

	INFO_PRINTF2(_L("	Parent Process Id = 0x%lx"),parentProcId);

	//For Child ONE

	CApaCommandLine* childProcOneCmdln=CApaCommandLine::NewLC();

	INFO_PRINTF1(_L("	CommandLine for Child One created "));

	//setting the parent process ID to child I

	childProcOneCmdln->SetParentProcessId(parentProcId);

	INFO_PRINTF1(_L("	Set ParentProcessId to Child One "));

	//child process ONE

	RProcess childProcOne;

	ret = childProcOne.Create(KChildOneExe,KNullDesC);

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	CleanupClosePushL(childProcOne);

	INFO_PRINTF2(_L("	Create Child One returned : %d"),ret);

	//attach commandline to child process

	TRAP(ret,childProcOneCmdln->SetProcessEnvironmentL(childProcOne));

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	INFO_PRINTF1(_L("	Attach CommandLine of Child One to its Process "));

	INFO_PRINTF1(_L("	Run Child One "));

	childProcOne.Resume();

	//Time for the child one to launch itself

	User::After(500000);

	//child process Id is reqd to monitor if it gets killed on its parent's termination

	TUint64 childProcOneId = childProcOne.Id();

	INFO_PRINTF2(_L("	Child One Id = 0x%lx "),childProcOneId);

	//For Child TWO

	CApaCommandLine* childProcTwoCmdln=CApaCommandLine::NewLC();

	INFO_PRINTF1(_L("	CommandLine for Child Two created "));

	//child process TWO

	RProcess childProcTwo;

	ret = childProcTwo.Create(KChildTwoExe,KNullDesC);

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	CleanupClosePushL(childProcTwo);

	INFO_PRINTF2(_L("	Create Child Two returned : %d"),ret);

	//attach commandline to child process

	TRAP(ret,childProcTwoCmdln->SetProcessEnvironmentL(childProcTwo));

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	INFO_PRINTF1(_L("	Attach CommandLine of Child Two to its Process "));

	INFO_PRINTF1(_L("	Run Child Two "));

	childProcTwo.Resume();

	//Time for the child one to launch itself

	User::After(500000);

	//child II process Id is reqd to monitor if it gets killed on its parent's termination

	TUint64 childProcTwoId = childProcTwo.Id();

	INFO_PRINTF2(_L("	Child Two Id = 0x%lx "),childProcTwoId);

	CChildProcess* childProcess=NULL;

	TRAP(ret, childProcess=CChildProcess::NewL(parentProc,childProcOneId));

	TEST(ret == KErrNone);

	User::LeaveIfError(ret);

	CleanupStack::PushL(childProcess);

	exitType = parentProc.ExitType();

	TEST(exitType == EExitTerminate);

	TInt exitReason = parentProc.ExitReason();

	TEST(exitReason == 0);

	if(exitType==EExitTerminate && exitReason==0)

		{

		INFO_PRINTF1(_L("	Parent process is Terminated"));

		}

	exitType = childProcOne.ExitType();

	TEST(exitType == EExitTerminate);

	exitReason = childProcOne.ExitReason();

	TEST(exitReason == 0);

	if(exitType==EExitTerminate && exitReason==0)

		{

		INFO_PRINTF1(_L("	Child I is killed automatically ... "));

		}

	//Wait and see if child II terminates automatically...

	User::After(10000000);

	exitType = childProcTwo.ExitType();

	TEST(exitType == EExitPending);

	if(exitType==EExitPending)

		{

		INFO_PRINTF1(_L("	Child II running successfully"));

		childProcTwo.Terminate(KTProcTerminatingChildII);

		exitType = childProcTwo.ExitType();

		TEST(exitType==EExitTerminate);

		exitReason = childProcTwo.ExitReason();

		TEST(exitReason == KTProcTerminatingChildII);

		INFO_PRINTF1(_L("	So Terminated it manually ..."));

		}

	CleanupStack::PopAndDestroy(childProcess);

	CleanupStack::PopAndDestroy(&childProcTwo);

	CleanupStack::PopAndDestroy(childProcTwoCmdln);

	CleanupStack::PopAndDestroy(&childProcOne);