// 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:
// Old Test CaseID 		APPFWK-SSS-0006
// New Test CaseID 		DEVSRVS-SSMA-STARTSAFE-0006
// 
//

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


#include <ssm/ssmstartsafe.h>
#include "tss_procstartmon.h"
#include "ssmtestapps.h"


const TInt KThrottleTime = 15000000; //15s
const TInt KStartMonStopperTimeout = 5000000; // Could (probably) be shaved.

     
TVerdict CSsTestStepProcStartMon::doTestStepL( void )
	{
	//Creating the semaphore
	TInt err = iSem.CreateGlobal(KStartProcSignalSemaphore, 0);
	INFO_PRINTF2(_L("Created semaphore with err %d"),err);
	TEST(err == KErrNone);
		
	__UHEAP_MARK;
	
	TRAP(err, DoTestMonForAlreadyStartedProcL());
	TEST(err == KErrNone);
	INFO_PRINTF2(_L("DoTestMonForAlreadyStartedProcL completed with err = %d"), err);
	
	TRAP(err, DoTestMonSyncL());
	TEST(err == KErrNone);
	INFO_PRINTF2(_L("DoTestMonSyncL completed with err = %d"), err);
	
	__UHEAP_MARKEND;
	iSem.Close();
	return TestStepResult();	
	}



/**
 Starts an instance of ssmtestprocgood.exe synchronously, in a process, as a server, specifying 1 retry.
 Kill it and ensure that it is restarted. Tell it to stop being monitored and kill it again.
 Ensure that it stays killed.
*/
void CSsTestStepProcStartMon::DoTestMonSyncL()
	{
	INFO_PRINTF1( _L("\n\nPerforming Process-monitor sync") );
	
	CSsmStartupProperties* startupProperties = CSsmStartupProperties::NewL();
	CleanupStack::PushL( startupProperties );
	
	// Need to start testprocess as a server so that we can tell it to stop being monitored.
	startupProperties->SetFileParamsL( KTestProcGood, KLaunchServerCommandLineOption );
	startupProperties->SetCommandTypeL( ESsmCmdStartProcess );
	startupProperties->SetExecutionBehaviour( ESsmWaitForSignal ); // Rem: EssmFireAndForget is disallowed
	
	const TInt KMonitorTimeout = 3000; // milliseconds I presume
	TSsmMonitorInfo monitorInfo;
	monitorInfo.iRestartPolicy = ESsmIgnoreOnFailure;
	monitorInfo.iRestartMode = 0;
	monitorInfo.iTimeout = KMonitorTimeout;
	monitorInfo.iRetries = 1;
	startupProperties->SetMonitorInfoL(monitorInfo);

	RProcess process;
	CleanupClosePushL( process );
	CSsmStartSafe* ss  = CSsmStartSafe::NewLC();
	
	CTestAndStopper* testAndStopper = new(ELeave) CTestAndStopper( *ss, *startupProperties, process, KStartMonStopperTimeout, this );
	CleanupStack::PushL( testAndStopper );
	CActiveScheduler::Start();
	
	//Waiting to decrement the count of the semaphore which is being signalled as the application is started first time 
	iSem.Wait();
		
	// Check that the killed process is restarted by SysMon
	TEST( 1 == FindAndKill(KTestProcGood) );
	INFO_PRINTF1( _L("Await Restart before killing the process again") );
	//Waiting using semaphore
	iSem.Wait();
	
	TEST( 1 == FindAndKill(KTestProcGood) );
	INFO_PRINTF1( _L("Await Restart -> connect -> cancel monitor -> kill") );
	//Waiting using semaphore
	iSem.Wait();
		
	// Stop monitoring to stop restarts.
	RTestProcGoodSession testProcServerSession;
	
	if( KErrNone == testProcServerSession.Connect() )
		{
		testProcServerSession.CancelMonitor();
		testProcServerSession.Close();
		}
	
	TEST( 1 == FindAndKill(KTestProcGood) );
	INFO_PRINTF1( _L("Ensure the test-process is dead") );
	User::After( KThrottleTime );
	// Ensure it's not hanging around
	TEST( 0 == FindAndKill(KTestProcGood) );
	
	CleanupStack::PopAndDestroy( 4, startupProperties );
	}

void CSsTestStepProcStartMon::DoTestMonForAlreadyStartedProcL()
	{
	INFO_PRINTF1( _L("Performing Process-monitor test for already started process") );
	
	RProcess process;
	CleanupClosePushL(process);
	User::LeaveIfError(process.Create(KTestProcGood, KLaunchServerCommandLineOption));
	
	TRequestStatus status;
	process.Rendezvous(status);
	if (status == KRequestPending)
		{
		process.Resume();
		}
	else
		{
		process.Kill(KErrGeneral);
		TESTEL(EFalse, status.Int());
		}
	
	//Waiting to decrement the count of the semaphore which is being signalled as the application is started first time 
	iSem.Wait();
	User::WaitForRequest(status);
	INFO_PRINTF1(_L("Process started"));
	TEST(process.ExitType() == EExitPending);
	
	CSsmStartupProperties* startupProperties = CSsmStartupProperties::NewL();
	CleanupStack::PushL( startupProperties );
	
	// Need to start testprocess as a server so that we can tell it to stop being monitored.
	startupProperties->SetFileParamsL(KTestProcGood, KLaunchServerCommandLineOption);
	startupProperties->SetCommandTypeL(ESsmCmdStartProcess);
	startupProperties->SetExecutionBehaviour(ESsmWaitForSignal);
	
	const TInt KMonitorTimeout = 3000; // milliseconds I presume
	TSsmMonitorInfo monitorInfo;
	monitorInfo.iRestartPolicy = ESsmIgnoreOnFailure;
	monitorInfo.iRestartMode = 0;
	monitorInfo.iTimeout = KMonitorTimeout;
	monitorInfo.iRetries = 1;
	startupProperties->SetMonitorInfoL(monitorInfo);

	CSsmStartSafe* ss  = CSsmStartSafe::NewLC();

	// Try to start and monitor the process which already started using RProcess::Create().
	TRAPD(err, ss->StartAndMonitorL(*startupProperties, process));

	// Trying to start and monitor an already running process is treated as successful. Startsafe would monitor the
	// already running process.
	TEST(err == KErrNone);
	INFO_PRINTF3( _L("StartAndMonitorL() completed with %d. anticipated value %d"),err, KErrNone );
	
	RTestProcGoodSession testProcServerSession;
	err = testProcServerSession.Connect();
	TEST(KErrNone == err);
	INFO_PRINTF1( _L("Asserted that server is running"));
	process.Kill(KErrNone);
	//In multiprocessor environment, potentially objects can be deleted on a different CPU
	//from the code which requested the deletion. Hence the delay of 5 seconds has been added.
	User::After(5000000); //5sec delay.

	err = testProcServerSession.Connect();
	TEST(KErrNotFound == err);
	INFO_PRINTF3( _L("Connect to test proc server session failed with %d. anticipated value %d"),err, KErrNotFound);

	TEST(process.ExitType() == EExitKill);
	//Waiting using semaphore
	iSem.Wait();
		
	// Check that the killed process is restarted by SysMon
	err = testProcServerSession.Connect();
	TEST(KErrNone == err);
	INFO_PRINTF1( _L("Asserted that server is re-started by sysmon"));
	
	// Stop monitoring to stop restarts.
	if(KErrNone == testProcServerSession.Connect())
		{
		testProcServerSession.CancelMonitor();
		testProcServerSession.Close();
		}
	TEST(1 == FindAndKill(KTestProcGood));
	CleanupStack::PopAndDestroy(3, &process);
	}

void CSsTestStepProcStartMon::SsTestNotify( TInt aNotify )
	{
	INFO_PRINTF2( _L("StartAndMonitorL( left with %d"), aNotify );
	
	TEST( 0 );
	}



TVerdict CSsTestStepProcStartMon::doTestStepPreambleL()
	{
	iActiveScheduler = new(ELeave) CActiveScheduler;
	CActiveScheduler::Install ( iActiveScheduler );

	return CTestStep::doTestStepPreambleL();
	}



/** */
TVerdict CSsTestStepProcStartMon::doTestStepPostambleL()
	{
	return CTestStep::doTestStepPostambleL();
	}



CSsTestStepProcStartMon::CSsTestStepProcStartMon()
	{
	SetTestStepName(KCTestCaseProcStartMon);
	}



CSsTestStepProcStartMon::~CSsTestStepProcStartMon()
	{
	delete iActiveScheduler;
	}