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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// f32\runtests\runtests.cpp

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32def_private.h>

#include <e32svr.h>

#include <e32ldr.h>

#include <hal.h>

#include "f32file.h"

#include "f32dbg.h"

#include "runtests.h"

#include <u32hal.h>

#define __PANIC(r) Panic(__LINE__,r)

//#define _RUN_FOREVER_

//#define _PANIC_ON_FAILURE_

const TInt KDefaultTimeout=1200;		// 20 minutes

const TInt KBackgroundTimeout=3000000;	// 3 seconds

const TInt KDestroyTimeout=1000000;		// 1 second

_LIT(KLitBackslash,"\\");

_LIT(KDebugMessage, "Testing finished, and the system will be panicked");

#ifdef __EPOC32__

_LIT(KLitDefaultTestPath,"Z:\\TEST");

#else

_LIT(KLitDefaultTestPath,"");

#endif

#ifdef _DEBUG

_LIT(KBuildType, "UDEB");

#else

_LIT(KBuildType, "UREL");

#endif

typedef RArray<TUint> RProcIdList;

GLDEF_D TPath TheTestPath = KLitDefaultTestPath();

GLDEF_D RFs TheFs;

GLDEF_D RLoader TheLoaderSession;

GLDEF_D TDesC8* TheTestList;

GLDEF_D RTimer TheTimer;

GLDEF_D TBuf<256> TheProcessCommand=KNullDesC();

GLDEF_D TInt TheTimeOut = KDefaultTimeout;

GLDEF_D TInt TheCurrentProcessList;

GLDEF_D RProcIdList ProcLists[2];

GLDEF_D RTimer IdleWaitTimer;

GLDEF_D RTimer DestructionTimer;

GLDEF_D RProperty CurrTest;

TBool ShowTimings = 0;

TInt TickPeriod = 15625;

TBool CleanUpProcesses = EFalse;

#ifdef _ENABLE_BTRACE_ANALYSIS_

// BTrace analysis forward declarations

const TInt KDefaultBTraceLevel = 0;

TBool BtraceAnalysis = EFalse;

TInt BTraceAnalysisLevel;

TInt BTraceAnalyseSetup();

void BTraceAnalyseEnd();

void BTraceAnalyse(TInt aAnalysisLevel);

#endif //_ENABLE_BTRACE_ANALYSIS_

_LIT(KLitPanicCategory,"RUNTESTS-");

_LIT(KLitLogPreamble,"RUNTESTS: ");

void LogMsg(TRefByValue<const TDesC> aFmt,...);

void DisableSimulatedFailure()

	{

	// Turn off simulated failure mechanisms for all base servers

	TheFs.SetAllocFailure(KAllocFailureOff);	// F32 heap failure

	TheFs.SetErrorCondition(KErrNone, 0);		// F32 other failure

	TheLoaderSession.DebugFunction(ELoaderDebug_SetHeapFail, 0, 0, 0);	// Loader heap failure

	TheLoaderSession.DebugFunction(ELoaderDebug_SetRFsFail, KErrNone, 0, 0);	// Loader RFs failure

	// make sure kernel heap debug is off

	__KHEAP_TOTAL_RESET;

	}

GLDEF_C void Panic(TInt aLine, TInt aReason)

	{

	TBuf<16> cat=KLitPanicCategory();

	cat.AppendNum(aLine);

	User::Panic(cat,aReason);

	}

TInt CloseAndWait(RHandleBase aH, TRequestStatus *aN = NULL)

	{

	TRequestStatus tempS;

	if(!aN)

		{

		// Create a destruction notifier if none was supplied.

		aH.NotifyDestruction(tempS);

		aN = &tempS;

		}

	if (*aN!=KRequestPending)

		{

		User::WaitForRequest(*aN);

		aH.Close();

		return KErrNoMemory;

		}

	TRequestStatus t;

	DestructionTimer.After(t, KDestroyTimeout);

	aH.Close();

	User::WaitForRequest(*aN, t);

	if (*aN != KRequestPending)

		{

		DestructionTimer.Cancel();

		User::WaitForRequest(t);

		return KErrNone;

		}

	User::CancelMiscNotifier(*aN);

	User::WaitForRequest(*aN);

	return KErrTimedOut;

	}

void CloseWaitAndWarn(RHandleBase aH, TRequestStatus *aN = NULL)

	{

	TFullName fn(aH.FullName());

	TInt r = CloseAndWait(aH, aN);

	if (r == KErrNoMemory)

		LogMsg(_L("WARNING OOM checking destruction of %S"), &fn);

	else if (r == KErrTimedOut)

		LogMsg(_L("ERROR Destruction of %S timed out"), &fn);

	}

TInt InitIdleWait()

	{

	TInt r = IdleWaitTimer.CreateLocal();

	if (r!=KErrNone)

		return r;

	return KErrNone;

	}

void WaitForIdle()

	{

	TRequestStatus idle_req;

	TRequestStatus timer_req;

	IdleWaitTimer.After(timer_req, KBackgroundTimeout);

	User::NotifyOnIdle(idle_req);

	User::WaitForRequest(idle_req, timer_req);

	if (idle_req != KRequestPending)

		{

		IdleWaitTimer.Cancel();

		User::WaitForRequest(timer_req);

		}

	else

		{

		User::CancelMiscNotifier(idle_req);

		User::WaitForRequest(idle_req);

		LogMsg(_L("WARNING Excessive Background Activity Detected"));

		}

	}

TBool IntentionallyPersistent(RProcess aProcess)

	{

	TInt v;

	TInt r = RProperty::Get(aProcess.SecureId(), KRuntestsIntentionalPersistenceKey, v);

	if (r==KErrNone && TUint(v)==KRuntestsIntentionalPersistenceValue)

		return ETrue;

	return EFalse;

	}

TInt GetProcessListThread(TAny* a)

	{

	RProcIdList& pl = *(RProcIdList*)a;

	TFindProcess fp(_L("*"));

	TFullName fn;

	TInt r = KErrNone;

	while (r==KErrNone && fp.Next(fn)==KErrNone)

		{

		RProcess p;

		r = p.Open(fp, EOwnerThread);

		if (r==KErrNone)

			{

			TUint id = (TUint)p.Id();

			r = pl.Append(id);

			p.Close();

			}

		}

	return r;

	}

TInt GetProcessList(RProcIdList& aList)

	{

	aList.Reset();

	RThread t;

	TRequestStatus s;

	TInt r = t.Create(KNullDesC, &GetProcessListThread, 0x1000, NULL, &aList);

	if (r==KErrNone)

		{

		t.Logon(s);

		t.SetPriority(EPriorityAbsoluteHigh);

		if (s==KRequestPending)

			t.Resume();

		User::WaitForRequest(s);

		r=s.Int();

		if (t.ExitType()==EExitPending)

			{

			t.Kill(0);

			WaitForIdle();

			}

		else if (t.ExitType()!=EExitKill)

			{

			r = -99;

			}

		CloseWaitAndWarn(t);

		}

	aList.Sort();

	return r;

	}

TBool ParseNumber(TLex& aLex, TUint& aNumber, TBool isTime)

	{

	TPtrC numberDes = aLex.NextToken();

	TInt len = numberDes.Length();

	if (len == 0)

		{

		return EFalse;

		}

	aNumber = 0;

	TInt magnitude = 1;

	TChar c = numberDes[len-1];

	if (isTime)

		{

		switch (c)

			{

			case 'h':

			case 'H':

				len -= 1;

				magnitude = 3600;

				break;

			case 'm':

			case 'M':

				len -= 1;

				/*FALLTHRU*/

			default:

				magnitude = 60;

				break;

			case 's':

			case 'S':

				len -= 1;

				magnitude = 1;

				break;

			}

		}

	for (TInt i = len-1; i >= 0; --i)

		{

		c = numberDes[i];

		if (c < '0' || c > '9')

			__PANIC(KErrArgument);

		aNumber += ((TInt)c-'0')*magnitude;

		magnitude *= 10;

		}

	return ETrue;

	}

void GetTimeOut(TLex& aLex)

//

//

//

	{

	TheTimeOut = KDefaultTimeout;

	TUint timeOut = 0;

	if (ParseNumber(aLex, timeOut, ETrue))

		{

		TheTimeOut = timeOut;

		}

	}

#ifdef _ENABLE_BTRACE_ANALYSIS_

void GetAnalysisLevel(TLex& aLex)

	{

	BTraceAnalysisLevel = KDefaultBTraceLevel;

	TUint level;

	if (ParseNumber(aLex, level, EFalse))

		{

		BTraceAnalysisLevel = level;

		}

	}

#endif //_ENABLE_BTRACE_ANALYSIS_

void LogMsg(TRefByValue<const TDesC> aFmt,...)

	{

	VA_LIST list;

	VA_START(list,aFmt);

	TBuf<0x100> buf=KLitLogPreamble();

	buf.AppendFormatList(aFmt,list);

	RDebug::Print(_L("%S"),&buf);

	}

_LIT(KLitError, "Error ");

TBool LogProcess(TUint aId, TBool aInit)

	{

	TFullName pn;

	TFileName fn;

	RProcess p;

	TBool killed = EFalse;

	TInt r = p.Open(TProcessId(aId));

	if (r==KErrNone)

		{

		if (IntentionallyPersistent(p))

			{

			p.Close();

			return killed;

			}

		pn = p.FullName();

		fn = p.FileName();

		if (!aInit && CleanUpProcesses && p.ExitType()==EExitPending)

			{// p is a left over process so terminate it.

			killed = ETrue;

			TRequestStatus status;

			p.Logon(status);

			p.Kill(KErrNone);	// Kill with KErrNone to suppress extra debug output from kernel.

			User::WaitForRequest(status);

			CloseAndWait(p);

			}

		else

			{

			p.Close();

			}

		}

	else

		{

		pn = KLitError;

		pn.AppendNum(r);

		}

	if (aInit)

		LogMsg(_L("Running process id=%d: %S (%S)"),aId,&pn,&fn);

	else

		{

		if(killed)

			LogMsg(_L("ERROR Leftover process was killed id=%d: %S (%S)"),aId,&pn,&fn);

		else

			LogMsg(_L("ERROR Leftover process id=%d: %S (%S)"),aId,&pn,&fn);

		}

	return killed;

	}

void ListProcesses()

	{

	RProcIdList& cur_list = ProcLists[TheCurrentProcessList];

	TInt cc = cur_list.Count();

	TInt ci;

	for (ci=0; ci<cc; ++ci)

		{

		LogProcess(cur_list[ci], ETrue);

		}

	}

void CheckProcesses()

	{

	RProcIdList& cur_list = ProcLists[TheCurrentProcessList];

	RProcIdList& new_list = ProcLists[1-TheCurrentProcessList];

	TInt r = GetProcessList(new_list);

	if (r!=KErrNone)

		{

		LogMsg(_L("WARNING Problem getting process list, error %d"),r);

		return;

		}

	TInt cc = cur_list.Count();

	TInt nc = new_list.Count();

	TInt ci = 0;

	TInt ni = 0;

	while (ci<cc || ni<nc)

		{

		TUint id1=0;

		TUint id2=0;

		if (ci<cc)

			id1 = cur_list[ci];

		if (ni<nc)

			id2 = new_list[ni];

		if (ci==cc)

			{

			// extra process has appeared so kill it and output an error message.

			if (LogProcess(id2, EFalse))

				{// Remove from list as we don't want it to be considered as vanished when the next test completes.

				new_list.Remove(ni);

				nc--;

				}

			else

				{// Extra process was left running so just move onto the next one.

				ni++;

				}

			}

		else if (ni<nc && id1==id2)

			{

			// process remains

			++ci, ++ni;

			}

		else

			{

			// process has disappeared

			LogMsg(_L("WARNING Vanished process, id=%d"),id1);

			++ci;

			}

		}

	// current list = new list

	TheCurrentProcessList = 1 - TheCurrentProcessList;

	// throw away the old list

	cur_list.Reset();

	}

_LIT8 (KLitRemark,"REM");

_LIT8 (KLitAtRemark,"@REM");

void ProcessLine(const TDesC8& aLine)

	{

	TLex8 lex(aLine);

	TPtrC8 testname=lex.NextToken();

	if (testname.Length()>=2 && testname[0]=='/' && testname[1]=='/')

		return;

	// ignore this line if it begins with rem or @rem 

	if (testname.CompareF(KLitRemark) == 0 || testname.CompareF(KLitAtRemark) == 0)

		return;

	TFileName testnameU;

	testnameU.Copy(testname);

	TFileName fullpathname;

	if (testnameU.Locate(TChar('\\'))==KErrNotFound)

		fullpathname=TheTestPath;

	fullpathname+=testnameU;

	if (testname.Locate(TChar('.'))==KErrNotFound)

		fullpathname+=_L(".EXE");

	TInt r;

	RFile file;

	r=file.Open(TheFs,fullpathname,EFileRead);

	if (r!=KErrNone)

		{

		// Remove path to let loader locate exe

		fullpathname = fullpathname.Mid(fullpathname.LocateReverse('\\')+1);

		}

	else

		file.Close();

	RProcess p;

	if(TheProcessCommand==KNullDesC)

		{

		TheProcessCommand.Copy(lex.Remainder());

		r=p.Create(fullpathname, TheProcessCommand);

		TheProcessCommand=KNullDesC();

		}

	else

		r=p.Create(fullpathname, TheProcessCommand);

	if (r!=KErrNone)

		{

		LogMsg(_L("Test %S ERROR Could not load file, error %d"),&fullpathname,r);

		return;

		}

	TRequestStatus ds;

	p.NotifyDestruction(ds);	// allocate the destruction notifier early so that it doesn't get flagged as a leak by kernel heap checking in e.g., efile (DEF133800)

	CurrTest.Set(p.FileName());

	User::After(100000);		// allow latency measurements to be output

	p.SetJustInTime(EFalse);	// we don't want the automatic test run to be halted by the debugger

	TRequestStatus ps;

	p.Rendezvous(ps);

	TInt time_remain = TheTimeOut;

	TRequestStatus ts;

	TUint start = User::TickCount();

	p.Resume();

	TBool persist = EFalse;

	TBool timer_running = EFalse;

	FOREVER

		{

		TInt nsec = Min(time_remain, 1800);

		if (!timer_running)

			TheTimer.After(ts, nsec*1000000);

		timer_running = ETrue;

		User::WaitForRequest(ps,ts);

		if (ps!=KRequestPending)

			{

			if (p.ExitType()==EExitPending)

				{

				// rendezvous completed but process not terminated

				if (!IntentionallyPersistent(p))

					{

					// not persistent - wait for process to terminate

					p.Logon(ps);

					continue;

					}

				persist = ETrue;

				}

			break;

			}

		timer_running = EFalse;

		time_remain -= nsec;

		if (time_remain==0)

			{

			LogMsg(_L("Going to kill test %S: it's taken %u seconds, which is too long"),&fullpathname,TheTimeOut);

			p.Kill(0);

			User::WaitForRequest(ps);

			p.Logon(ps);

			User::WaitForRequest(ps);

			CloseWaitAndWarn(p, &ds);

			RDebug::Print(_L("\n"));

			LogMsg(_L("Test %S TIMEOUT"),&fullpathname);

			return;

			}

		else