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

/**
 @file
 @test
 @internalComponent - Internal Symbian test code
*/

#include <sysmonclisess.h>
#include <startupproperties.h>
#include <ssm/ssmstartupproperties.h>
#include "testapps.h"
#include "tsysmon_stepnoprocmon.h"


CStepNoProcMon::CStepNoProcMon()
	{
	SetTestStepName(KCTestCaseNoProcMon);
	}

TVerdict CStepNoProcMon::doTestStepL()
	{
	INFO_PRINTF1(_L("TEST APPFWK-SYSMON-0007"));
	
	TRAPD(err, DoTestNullHandleL());
	TEST(err == KErrNone);

	TRAP(err, DoTestKilledHandleL());
	TEST(err == KErrNone);
	
	TRAP(err, DoTestWrongHandleL());
	TEST(err == KErrNone);

	TRAP(err, DoTestProcMonErrorsL());
	TEST(err == KErrNone);
	
	return TestStepResult();
	}
/**
Old Test CaseID 		APPFWK-SYSMON-0007
New Test CaseID 		DEVSRVS-SHMA-SYSMON-0007
 */

void CStepNoProcMon::DoTestNullHandleL()
	{
	INFO_PRINTF1(_L("Requesting SysMon to monitor a process NULL handle using startupproperties"));
	
	RProcess process;
	process.Close();

	RSysMonSession sess;
	sess.OpenL();
	CleanupClosePushL(sess);
	
	CStartupProperties *prop = CStartupProperties::NewLC(KTestProcGood, KNullDesC);
	prop->SetMonitored(ETrue);
	prop->SetStartMethod(EWaitForStart);	
	prop->SetRecoveryParams(EIgnoreOnFailure, 0);
	prop->SetNoOfRetries(1);
	prop->SetTimeout(0);
			
	TRAPD(err, sess.MonitorL(*prop, process)); // check that passing in a null handle would return KErrArugment
	
	// check that the initiation of monitoring failed 
	TESTE(KErrArgument == err, err);
	if(KErrArgument == err)
		{
		INFO_PRINTF1(_L("Request refused with KErrArgument"));
		}
	CleanupStack::PopAndDestroy(prop);

	INFO_PRINTF1(_L("Requesting SysMon to monitor a process NULL handle using ssmstartupproperties"));
	CSsmStartupProperties *ssmProp = CSsmStartupProperties::NewLC(KTestProcGood, KNullDesC);
	ssmProp->SetExecutionBehaviour(ESsmWaitForSignal);	
	TSsmMonitorInfo monitorInfo;
	monitorInfo.iRestartPolicy = ESsmIgnoreOnFailure;
	monitorInfo.iRestartMode = 0;
	monitorInfo.iTimeout = 0;
	monitorInfo.iRetries = 1;

	ssmProp->SetMonitorInfoL(monitorInfo);// SysMon will not do any restart attempts

	TRAP(err, sess.MonitorL(*ssmProp, process)); // check that passing in a null handle would return KErrArugment
	
	// check that the initiation of monitoring failed 
	TESTE(KErrArgument == err, err);
	if(KErrArgument == err)
		{
		INFO_PRINTF1(_L("Request refused with KErrArgument"));
		}

	CleanupStack::PopAndDestroy(ssmProp);
	CleanupStack::PopAndDestroy(&sess);
	}

/**
Check that passing in a handle to a killed process will return KErrArugment
*/
void CStepNoProcMon::DoTestKilledHandleL()
	{
	INFO_PRINTF1(_L("Requesting SysMon to monitor a handle to a killed process using startupproperties"));

	RSysMonSession sess;
	sess.OpenL();
	CleanupClosePushL(sess);

	RProcess process;
	CleanupClosePushL(process);
	User::LeaveIfError(process.Create(KTestProcGood, KNullDesC));
	ResumeL(process);
	
	process.Kill(KErrNone);
	INFO_PRINTF1(_L("Process killed."));
	
	CStartupProperties* prop = CStartupProperties::NewLC(KTestProcGood, KNullDesC);
	prop->SetMonitored(ETrue);
	prop->SetStartMethod(EWaitForStart);	
	prop->SetRecoveryParams(EIgnoreOnFailure, 0);
	prop->SetNoOfRetries(1);
	prop->SetTimeout(0);
				
	TRAPD(err, sess.MonitorL(*prop, process));
	
	// check that the initiation of monitoring failed 
	TESTE(KErrDied == err, err);
	if(KErrDied == err)
		{
		INFO_PRINTF1(_L("Request refused with KErrDied"));
		}
		
	CleanupStack::PopAndDestroy(prop);
	CleanupStack::Pop(&process);

	INFO_PRINTF1(_L("Requesting SysMon to monitor a handle to a killed process using ssmstartupproperties"));
	CleanupClosePushL(process);
	User::LeaveIfError(process.Create(KTestProcGood, KNullDesC));
	ResumeL(process);
	
	process.Kill(KErrNone);
	INFO_PRINTF1(_L("Process killed."));

	CSsmStartupProperties *ssmProp = CSsmStartupProperties::NewLC(KTestProcGood, KNullDesC);
	ssmProp->SetExecutionBehaviour(ESsmWaitForSignal);	
	TSsmMonitorInfo monitorInfo;
	monitorInfo.iRestartPolicy = ESsmIgnoreOnFailure;
	monitorInfo.iRestartMode = 0;
	monitorInfo.iTimeout = 0;
	monitorInfo.iRetries = 1;

	ssmProp->SetMonitorInfoL(monitorInfo); // SysMon will not do any restart attempts

	TRAP(err, sess.MonitorL(*ssmProp, process));
	
	// check that the initiation of monitoring failed 
	TESTE(KErrDied == err, err);
	if(KErrDied == err)
		{
		INFO_PRINTF1(_L("Request refused with KErrDied"));
		}

	CleanupStack::PopAndDestroy(ssmProp);
	CleanupStack::PopAndDestroy(&process);
	CleanupStack::PopAndDestroy(&sess);	
	}

void CStepNoProcMon::DoTestWrongHandleL()
	{
	INFO_PRINTF1(_L("Requesting SysMon to monitor wrong process handle using startupproperties"));
	
	RProcess process; // initiated with handle to current process

	RSysMonSession sess;
	sess.OpenL();
	CleanupClosePushL(sess);
	
	CStartupProperties *prop = CStartupProperties::NewLC(KTestProcGood, KNullDesC);
	prop->SetMonitored(ETrue);
	prop->SetStartMethod(EWaitForStart);	
	prop->SetRecoveryParams(EIgnoreOnFailure, 0);
	prop->SetNoOfRetries(1);
	prop->SetTimeout(0);
			
	TRAPD(err, sess.MonitorL(*prop, process)); // check that passing in a null handle would return KErrArugment
	
	// check that the initiation of monitoring failed 
	TESTE(KErrArgument == err, err);
	if(KErrArgument == err)
		{
		INFO_PRINTF1(_L("Request refused with KErrArgument"));
		}
		
	CleanupStack::PopAndDestroy(prop);

	INFO_PRINTF1(_L("Requesting SysMon to monitor wrong process handle using ssmstartupproperties"));
	CSsmStartupProperties *ssmProp = CSsmStartupProperties::NewLC(KTestProcGood, KNullDesC);
	ssmProp->SetExecutionBehaviour(ESsmWaitForSignal);	
	TSsmMonitorInfo monitorInfo;
	monitorInfo.iRestartPolicy = ESsmIgnoreOnFailure;
	monitorInfo.iRestartMode = 0;
	monitorInfo.iTimeout = 0;
	monitorInfo.iRetries = 1;

	ssmProp->SetMonitorInfoL(monitorInfo);// SysMon will not do any restart attempts
			
	TRAP(err, sess.MonitorL(*ssmProp, process)); // check that passing in a null handle would return KErrArugment
	
	// check that the initiation of monitoring failed 
	TESTE(KErrArgument == err, err);
	if(KErrArgument == err)
		{
		INFO_PRINTF1(_L("Request refused with KErrArgument"));
		}
		
	CleanupStack::PopAndDestroy(ssmProp);
	CleanupStack::PopAndDestroy(&sess);
	}

void CStepNoProcMon::DoTestProcMonErrorsL()
	{
	INFO_PRINTF1(_L("Testin SysMon in different error conditions"));
	RProcess process;
	CleanupClosePushL(process);
	
	INFO_PRINTF1(_L("Going start a process"));
	User::LeaveIfError(process.Create(KTestProcGood, KNullDesC));
	ResumeL(process);
	
	//Setup monitoring	
	INFO_PRINTF1(_L("Going to request process monitoring"));
	RSysMonSession sess;
	sess.OpenL();
	CleanupClosePushL(sess);

	CSsmStartupProperties* prop = CSsmStartupProperties::NewLC(KTestProcGood, KNullDesC);
	TSsmMonitorInfo monitorInfo;
	monitorInfo.iRestartPolicy = ESsmIgnoreOnFailure;
	monitorInfo.iRestartMode = 0;
	monitorInfo.iTimeout = 0;
	monitorInfo.iRetries = 1;
	prop->SetMonitorInfoL(monitorInfo);
	prop->SetFileParamsL(KNullDesC,KNullDesC);
	prop->SetCommandTypeL(ESsmCmdStartApp);

	INFO_PRINTF1(_L("Going to request process monitoring with NULL filename type"));
	TRAPD(err, sess.MonitorL(*prop, process));
	TEST(err == KErrArgument);
	INFO_PRINTF3(_L("Actual return value for NULL filename %d, Expected return value %d"), err, KErrArgument);

	prop->Reset();
	prop->SetFileParamsL(KNullDesC,KNullDesC);
	prop->SetCommandTypeL(ESsmCmdStartApp);
	monitorInfo.iRestartPolicy = ESsmIgnoreOnFailure;
	monitorInfo.iRestartMode = 0;
	monitorInfo.iTimeout = 0;
	monitorInfo.iRetries = -12;
	prop->SetMonitorInfoL(monitorInfo);

	CleanupStack::Pop(prop);
	CleanupStack::PushL(prop);
	
	INFO_PRINTF1(_L("Going to request process monitoring with -ve retries for WaitForStart execution behaviour"));
	TRAP(err, sess.MonitorL(*prop, process));
	TEST(err == KErrArgument);
	INFO_PRINTF3(_L("Actual return value for -ve retries for WaitForStart execution behaviour %d, Expected return value %d"), err, KErrArgument);

	prop->Reset();
	prop->SetFileParamsL(KNullDesC,KNullDesC);
	prop->SetCommandTypeL(ESsmCmdStartProcess);
	monitorInfo.iRestartPolicy = ESsmIgnoreOnFailure;
	monitorInfo.iRestartMode = 0;
	monitorInfo.iTimeout = -100;
	monitorInfo.iRetries = 1;
	prop->SetMonitorInfoL(monitorInfo);

	CleanupStack::Pop(prop);
	CleanupStack::PushL(prop);

	INFO_PRINTF1(_L("Going to request process monitoring with -ve timeout for WaitForStart execution behaviour"));
	TRAP(err, sess.MonitorL(*prop, process));
	TEST(err == KErrArgument);
	INFO_PRINTF3(_L("Actual return value for -ve timeout for WaitForStart execution behaviour %d, Expected return value %d"), err, KErrArgument);

	prop->Reset();
	prop->SetFileParamsL(KNullDesC,KNullDesC);
	prop->SetCommandTypeL(ESsmCmdStartProcess);
	monitorInfo.iRestartPolicy = (static_cast <TSsmRecoveryMethod>(100));
	monitorInfo.iRestartMode = 0;
	monitorInfo.iTimeout = -100;
	monitorInfo.iRetries = 1;
	prop->SetMonitorInfoL(monitorInfo);

	CleanupStack::Pop(prop);
	CleanupStack::PushL(prop);

	INFO_PRINTF1(_L("Going to request process monitoring with invalid recoverymethod for WaitForStart execution behaviour"));
	TRAP(err, sess.MonitorL(*prop, process));
	TEST(err == KErrArgument);
	INFO_PRINTF3(_L("Actual return value for invalid recoverymethod for WaitForStart execution behaviour %d, Expected return value %d"), err, KErrArgument);

	CStartupProperties* prop1 = CStartupProperties::NewLC(KTestProcGood, KNullDesC);
	prop1->SetStartupType(static_cast<TStartupType>(10));
	prop1->SetMonitored(ETrue);
	prop1->SetStartMethod(EWaitForStart);	
	prop1->SetRecoveryParams(EIgnoreOnFailure, 0);
	prop1->SetNoOfRetries(1);
	prop1->SetTimeout(0);
				
	INFO_PRINTF1(_L("Going to request process monitoring with invalid startuptype"));
	TRAP(err, sess.MonitorL(*prop, process));
	TEST(err == KErrArgument);
	INFO_PRINTF3(_L("Actual return value for invalid startuptype %d, Expected return value %d"), err, KErrArgument);

	process.Kill(KErrNone);
	CleanupStack::PopAndDestroy(4, &process);
	INFO_PRINTF1(_L("Test step complete"));		
	}