--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sysstatemgmt/systemstarter/test/tamastarter/src/tamastarter_app.cpp	Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,303 @@
+// 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 <e32base.h>
+#include <e32debug.h>
+#include <f32file.h>
+#include <e32const.h>
+#include <bautils.h>
+#include <bacline.h>
+#include <apacmdln.h>
+#include <utf.h>
+#include <test/testexecutestepbase.h>
+#include <cinidata.h>
+#include <sysmonclisess.h>
+
+#include "tamastarter_constants.h"
+
+_LIT(KAmaStarterTestAppPanic, "AmaStarterTestApp");
+
+
+//Function to create the new file if it does not exists.
+void CreateResultFileL(const TDesC& aFileName)
+	{
+	RFs fs;
+	User::LeaveIfError(fs.Connect());	
+	CleanupClosePushL(fs);
+	
+	if (!BaflUtils::FileExists(fs, aFileName))
+		{
+		// Create the folder if it does not exist
+		TInt ret = fs.MkDirAll(KTestAppResultsPath);
+		if (ret != KErrAlreadyExists)
+			{
+			User::LeaveIfError(ret);
+			}
+		
+		RFile	resultFile;
+		ret = resultFile.Create(fs, aFileName, EFileShareExclusive); //CIniData isn't thread safe
+		resultFile.Close();
+		User::LeaveIfError(ret);
+		}
+	
+	CleanupStack::PopAndDestroy(&fs);
+	}
+
+
+
+// Set the counter value to '0' in case it does not exists.
+void InitCounterL(CIniData& aIniData, const TDesC& aSection, const TDesC& aKey)
+	{
+	TInt value = 0;
+	TBool readResult = aIniData.FindVar(aSection, aKey, value);
+	if (!readResult)
+		{
+		TBuf<2> descVal;
+		descVal.Num(value);
+		User::LeaveIfError(aIniData.AddValue(aSection, aKey, descVal));		
+		aIniData.WriteToFileL();
+		}
+	}
+
+// Get the counter value from the data (log) file.
+TInt GetCounter(CIniData& aIniData, const TDesC& aSection, const TDesC& aKey)
+	{
+	TInt value = 0;
+	aIniData.FindVar(aSection, aKey, value);
+	return value;
+	}
+
+
+// IncrementCounter increment the counter value by '1'
+void IncrementCounterL(CIniData& aIniData, const TDesC& aSection, const TDesC& aKey)
+	{
+	TInt value = 1 + GetCounter(aIniData, aSection, aKey);
+	TBuf<2> descVal;
+	descVal.Num(value);
+	User::LeaveIfError(aIniData.SetValue(aSection, aKey, descVal));
+	aIniData.WriteToFileL();
+	}
+
+
+//StartTestL processes the command line, and appropriately updates the various counters
+//(Sucessful, failure, panic etc) depending on the arguments provided during the launch.
+//The EXE name is used as section name where all the counters will be added/updated.
+//This way each EXE launched will update its own result in the section in the result
+//file. The result file name is expected to be provided as an command line argument for the
+//result of the launch of this test EXE to be logged.
+void StartTestL(void)
+	{
+	//Get the executable filename
+	RProcess testApp;
+	TParse parse;
+	parse.Set(testApp.FullName(), NULL, NULL);
+	
+	TTime starttime;
+	starttime.UniversalTime();
+	TFileName fileForLog(parse.Name());
+	RDebug::Print( _L("*** %S::StartTestL - entry at time %d:%d.%d"), &fileForLog, starttime.DateTime().Minute(), starttime.DateTime().Second(), starttime.DateTime().MicroSecond());
+
+	HBufC* commandLineDes = NULL;	
+	//EXE is launched as new process
+	if ( User::CommandLineLength() > 0 )
+		{
+		commandLineDes = HBufC::New(User::CommandLineLength());
+		TPtr cmd = commandLineDes->Des();
+		User::CommandLine(cmd);
+		}
+	//EXE is launched as APP
+	else
+		{
+		CApaCommandLine*	apaCmdLine = NULL;
+		CApaCommandLine::GetCommandLineFromProcessEnvironment(apaCmdLine);
+		CleanupStack::PushL(apaCmdLine);		
+		commandLineDes = CnvUtfConverter::ConvertToUnicodeFromUtf8L(apaCmdLine->TailEnd());
+		CleanupStack::PopAndDestroy(apaCmdLine);
+		}
+	
+	CleanupStack::PushL(commandLineDes);
+	TLex cmdLine = commandLineDes->Des();
+	
+	TInt	timeout = 0;
+	TInt	retriedCount = 0;
+	
+	TInt	err = KErrNone;
+	TBool	toLeave = EFalse;
+	
+	TInt	panic = 0;
+	TBool	toPanic = EFalse;
+	
+	TInt	rend = KErrNone;
+	TBool	toRend = EFalse;
+	
+	TInt	cancelMonLaunch = 0;
+	TBool	cancelMon = EFalse;
+	
+	TBuf<KMaxFileName>	fileName(KTestAppResultsPath);
+	TPtrC ptr;
+
+	for(ptr.Set(cmdLine.NextToken()) ; ptr.Length() ; ptr.Set(cmdLine.NextToken()))
+		{
+		//Result file name
+		if ( !ptr.CompareF(KLog) )
+			{
+			fileName.Append(cmdLine.NextToken());
+			fileName.Append(KTestLogFileExtension);
+			CreateResultFileL(fileName);
+			}
+		//Rendezvous with
+		else if ( !ptr.CompareF(KRendezvous) )
+			{
+			TLex	lex(cmdLine.NextToken());
+			lex.Val(rend);
+			toRend = ETrue;
+			}
+		//Timeout
+		else if ( !ptr.CompareF(KTimeout) )
+			{
+			TLex	lex(cmdLine.NextToken());
+			lex.Val(timeout);
+			}
+		//Retry count
+		else if ( !ptr.CompareF(KRetry) )
+			{
+			TLex	lex(cmdLine.NextToken());
+			lex.Val(retriedCount);
+			}
+		//Leave Error value
+		else if ( !ptr.CompareF(KLeaveErrorValue) )
+			{
+			TLex	lex(cmdLine.NextToken());
+			lex.Val(err);
+			toLeave = ETrue;
+			}
+		//Panic
+		else if ( !ptr.CompareF(KPanicValue) )
+			{
+			TLex	lex(cmdLine.NextToken());
+			lex.Val(panic);
+			toPanic = ETrue;
+			}
+		//Cancel monitoring after N launches/restarts
+		else if ( !ptr.CompareF(KCancelMonitoring) )
+			{
+			TLex	lex(cmdLine.NextToken());
+			lex.Val(cancelMonLaunch);
+			cancelMon = ETrue;
+			}	
+		}
+		
+	CIniData* appResults = CIniData::NewL(fileName);
+	CleanupStack::PushL(appResults);
+
+	// Set all the counters to 0
+	//  NOTE: This is done if the counter does not exist (otherwise, it keeps the old value)
+	InitCounterL(*appResults, parse.Name(), KLaunchCntr);
+	InitCounterL(*appResults, parse.Name(), KRetryCntr);
+	InitCounterL(*appResults, parse.Name(), KSuccessCntr);
+	InitCounterL(*appResults, parse.Name(), KPanicCntr);
+	InitCounterL(*appResults, parse.Name(), KLeaveCntr);
+	InitCounterL(*appResults, parse.Name(), KFailedCntr);
+
+	// Update the Launch counter	
+	IncrementCounterL(*appResults, parse.Name(), KLaunchCntr);
+
+	// Update the Retry counter	
+	if (retriedCount > 0)
+		{
+		TInt retryCntr = GetCounter(*appResults, parse.Name(), KRetryCntr);	
+
+		//Check if app is to be timedout in case retry counter is set > 0
+		if (retryCntr < retriedCount && timeout > 0)
+			{
+			IncrementCounterL(*appResults, parse.Name(), KRetryCntr);
+			User::After(TTimeIntervalMicroSeconds32(timeout*1000));
+			}
+		}		
+
+	// Update the Success counter (or Panic, or Leave)
+	if (toPanic == EFalse && toLeave == EFalse && rend == KErrNone)
+		{
+		IncrementCounterL(*appResults, parse.Name(), KSuccessCntr);
+		}
+	else
+		{
+		if (toPanic)
+			{
+			IncrementCounterL(*appResults, parse.Name(), KPanicCntr);
+			User::SetJustInTime(EFalse);
+			User::Panic(KAmaStarterTestAppPanic,panic);			
+			}
+		if (toLeave)
+			{
+			IncrementCounterL(*appResults, parse.Name(), KLeaveCntr);
+			User::Leave(err);
+			}
+		}
+
+	// Update the Failed counter	
+	if (toRend)
+		{
+		if (rend != KErrNone)
+			{
+			IncrementCounterL(*appResults, parse.Name(), KFailedCntr);
+			}
+		RProcess::Rendezvous(rend);
+		}
+	
+	CleanupStack::PopAndDestroy(2); //cmdLine, iAppResults
+	
+	//Check if this app/process was asked to cancel its monitoring, after it has been
+	//restarted/launched 'N' (cancelMonLaunch) times
+	if (cancelMon)
+		{
+		TInt launchCntr = GetCounter(*appResults, parse.Name(), KLaunchCntr);
+		if (launchCntr >= cancelMonLaunch)
+			{
+			//Wait for 25 secs to let process execution time get passed throttle time
+			User::After(TTimeIntervalMicroSeconds32(25000000));
+			RSysMonSession	sysMonSession;
+			sysMonSession.CancelMonitorSelfL();
+			}
+		}
+	
+	TTime endtime;
+	endtime.UniversalTime();
+	RDebug::Print( _L("*** %S::StartTestL - exit at time %d:%d.%d"), &fileForLog, endtime.DateTime().Minute(), endtime.DateTime().Second(), endtime.DateTime().MicroSecond());
+	}
+
+TInt E32Main()
+	{	
+	__UHEAP_MARK;
+
+	CTrapCleanup* theTrapCleanup = CTrapCleanup::New();
+
+	TRAPD(err, StartTestL());
+	if (err)
+		{
+		User::Panic(KAmaStarterTestAppPanic,err);
+		}
+    delete theTrapCleanup;
+
+	__UHEAP_MARKEND;
+	
+	return KErrNone;
+	}