// Copyright (c) 1996-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:

 //

 //! @file f32test\concur\t_tdebug.cpp

 #include <e32test.h>

 #include <f32file.h>

 #include "t_server.h"

 #include "t_tdebug.h"

 #include "cfafsdlyif.h"

 TThreadData TTest::iData[KMaxThreads];

 TThreadData TTest::iDummy;

 TFullName   TTest::iWhere;

 RMutex      TTest::iDebugLock;

 RMutex      TTest::iPrintLock;

 TBool       TTest::iInit = EFalse;

 LOCAL_C TFileName gErrorPos;

 // Instance of the class to force initialisation.

 LOCAL_C TTest gTest;

 LOCAL_C TInt KSecond = 1000000;

 class TTestOverflowTruncate : public TDesOverflow

 ///

 /// Used to suppress overflow when appending formatted text to a buffer.

 ///

 	{

 public:

 	virtual void Overflow(TDes &/*aDes*/) {}

 	};

 TTest::TTest()

 //

 // Constructor, forces initialisation of variables.

 //

 	{

 	Init();

 	}

 TInt TTest::Init()

 ///

 /// Initialise stuff (currently just the locks) if it hasn't been

 /// done already.

 ///

 	{

 	if (!iInit)

 		{

 		TInt r = KErrNone;

 		r = iDebugLock.CreateLocal();

 		if (r != KErrNone)

 			{

 			RDebug::Print(_L("ERROR %d creating iDebugLock\n"), r);

 			return r;

 			}

 		r = iPrintLock.CreateLocal();

 		if (r != KErrNone)

 			{

 			RDebug::Print(_L("ERROR %d creating iPrintLock\n"), r);

 			return r;

 			}

 		iInit = ETrue;

 		}

 	return KErrNone;

 	}

 TInt TTest::Create(TInt aNum, TThreadFunction aFunction, const TDesC& aName)

 ///

 /// Create a thread, setting up the name and our data area.

 ///

 	{

 	if (aNum < 0 || aNum > KMaxThreads)

 		{

 		test.Printf(_L("Illegal thread %d\n"), aNum);

 		test(EFalse);

 		}

 	TThreadData &d = iData[aNum];

 	// test.Printf(_L("creating thread %d (%S)\n"), aNum, &aName);

 //	d.iThread.LogonCancel(d.iStat);

 //	d.iThread.Close();

 	TInt r;

 	r = d.iThread.Create(aName, aFunction, KDefaultStackSize+32*1024, KMinHeapSize, 0x20000, &d);

 	if (r != KErrNone)

 	{

 		TBuf<128> buf;

 		test.Printf(_L("Error creating thread %d '%S' (was %d '%S'): %S\n"),

 			aNum, &aName, d.iNum, &d.iName, &TTest::ErrStr(r, buf));

 		test(0);

 	}

 	d.iId   = d.iThread.Id();

 	d.iNum  = aNum;

 	d.iName = aName;

 	d.iThread.Logon(d.iStat);

 	return r;

 	}

 TInt TTest::RunOnly()

 ///

 /// Resume all of the threads we have created.

 ///

 	{

 	TInt i;

 	for (i = 0; i < KMaxThreads; i++)

 		{

 		if (iData[i].iId > 0)

 			{

 			iData[i].iThread.Resume();

 			}

 		}

 	return KErrNone;

 	}

 TInt TTest::Run(TBool aExitAny, TInt aTimeout)

 ///

 /// Run until all (or any one) threads has completed, or until a timeout.

 /// @param aExitAny If true, exit when the first thread completes, otherwise

 ///        wait until they have all completed.

 /// @param aTimeout if zero, no timeout, otherwise it is the timeout in microseconds.

 ///

 	{

 	TInt i;

 	TInt status  = RunOnly();

 	RTimer timer;

 	TRequestStatus tstat;

 	timer.CreateLocal();

 	if (aTimeout)

 		timer.After(tstat, aTimeout);

 	for (;;)

 		{

 		status = KErrNone;

 		User::WaitForAnyRequest();

 		if (aTimeout > 0 && tstat != KRequestPending)

 			break;

 		TBool running = EFalse;

 		for (i = 0; i < KMaxThreads; i++)

 			{

 			if (iData[i].iId > 0)

 				{

 				if (iData[i].iStat == KRequestPending)

 					{

 					running = ETrue;

 					}

 				else

 					{

 					TThreadData &d = iData[i];

 					// ignore result of LogonCancel, since we know thread has finished

 					d.iThread.LogonCancel(d.iStat);

 					d.iThread.Close();

 					d.iId = 0;

 					if (d.iStat != KErrNone)

 						{

 						status = KErrAbort;

 						TBuf<32> ebuf;

 						test.Printf(_L("ERROR: %S in thread %S: %S\n                %S"),

 									&ErrStr(d.iStat.Int(), ebuf), &d.iName, &d.iMess, &iWhere);

 						if (aExitAny)

 							{

 							running = EFalse;

 							break;

 							}

 						}

 					}

 				}

 			}

 		if (!running)

 			break;

 		}

 	timer.Cancel();

 	timer.Close();

 	return status;

 	}

 void TTest::KillAll(TInt aReason)

 //

 // Kill (destroy) all of the created threads, then wait for up to 10 seconds

 // for them all to die (and just exit if any are still alive).

 //

 	{

 	for (TInt i = 0; i < KMaxThreads; i++)

 		{

 		if (iData[i].iId > 0)

 			{

 			TThreadData &d = iData[i];

 			d.iThread.Kill(aReason);

 			}

 		}

 	Run(EFalse, 10*KSecond);

 	}

 TThreadData& TTest::Self()

 ///

 /// Return a reference to the current thread; if it's not one we've created

 /// return a reference to a dummy data area indicating no thread.

 ///

 	{

 	RThread me;

 	TInt i;

 	for (i = 0; i < KMaxThreads; i++)

 		{

 		if (me.Id() == iData[i].iId)

 			{

 			return iData[i];

 			}

 		}

 	iDummy.iId = 0;

 	iDummy.iNum = -1;

 	iDummy.iName.Format(_L("#%d"), (TUint)me.Id());

 	return iDummy;

 	}

 TThreadData& TTest::Data(TInt aIndex)

 ///

 /// Return a reference to the data area for the specified thread, or to a

 /// dummy area if it's not in the right range.

 ///

 /// @param aIndex index to the thread (ThreadData::iNum is the same number).

 ///

 	{

 	if (aIndex >= 0 && aIndex < KMaxThreads)

 		return iData[aIndex];

 	iDummy.iId = 0;

 	iDummy.iNum = -1;

 	iDummy.iName = _L("");

 	return iDummy;

 	}

 void TTest::Start(const TDesC& aStr)

 ///

 /// Output "START TEST" and the string.

 ///

 	{

 	Printf(_L("START TEST: %S\n"), &aStr);

 	}

 void TTest::Next(const TDesC& aStr)

 ///

 /// Output "NEXT TEST" and the string.

 ///

 	{

 	Printf(_L("NEXT TEST: %S\n"), &aStr);

 	}

 void TTest::PrintLock()

 ///

 /// Wait if another task is doing output.

 ///

 	{

 	iPrintLock.Wait();

 	}

 void TTest::PrintUnlock()

 ///

 /// Signal that output is complete so that other tasks can do output.

 ///

 	{

 	iPrintLock.Signal();

 	}

 void TTest::Printf(TRefByValue<const TDesC> aFmt, ...)

 ///

 /// Output the formatted text, prepending it with the thread name if it is one

 /// we've created.  Parameters as for printf().  Note that if more than one

 /// thread tries to call it at the same time it will lock so that only one is

 /// processed at a time, the debug output isn't thread-safe (it can mix

 /// characters from different threads).

 ///

 	{

 	TTestOverflowTruncate overflow;

 	VA_LIST list;

 	VA_START(list, aFmt);

 	TBuf<256> buf;

 		buf.SetLength(0);

 	if (Self().iNum >= 0)

 		{

 		buf.Append(Self().iName);

 		buf.Append(_L(": "));

 		}

 	buf.AppendFormatList(aFmt, list, &overflow);

 #if defined(__WINS__)

 	if (buf.Right(1) != _L("\n"))

 		buf.Append(_L("\n"));

 #else

 	if (buf.Right(1) == _L("\n"))

 		buf.SetLength(buf.Length() - 1);

 #endif

 	iDebugLock.Wait();

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

 	iDebugLock.Signal();

 	VA_END(list);

 	}

 void TTest::Printf()

 ///

 /// Output a blank line, prepended with the thread name if any.

 ///

 	{

 	Printf(_L("\n"));

 	}

 void TTest::Fail(TPos aPos, TRefByValue<const TDesC> aFmt, ...)

 ///

 /// Output an error message (formatted as for printf()), then exit the thread.

 /// The message is placed in the buffer associated with the thread so that

 /// the parent task can display it.

 ///

 	{

 	VA_LIST list;

 	VA_START(list, aFmt);

 	Self().iMess.FormatList(aFmt, list);

 	iDebugLock.Wait();

 	TPtrC8 ptr((TUint8*)aPos.iFailFile);

 	gErrorPos.Copy(ptr);

 	iWhere.Format(_L("  %S line %d\n"), &gErrorPos, aPos.iFailLine);

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

 	RDebug::Print(_L("ERROR in thread %S: %S"), &Self().iName, &Self().iMess);

 	RDebug::Print(_L("        %S line %d\n"), &gErrorPos, aPos.iFailLine);

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

 	iDebugLock.Signal();

 	User::Exit(KErrAbort);

 	}

 void TTest::Fail(TPos aPos, TInt aErr, TRefByValue<const TDesC> aFmt, ...)

 ///

 /// Output an error message including the interpreted error value followed

 /// by the specified text (formatted as for printf()), then exit the thread.

 /// The message is placed in the buffer associated with the thread so that

 /// the parent task can display it.

 ///

 	{

 	VA_LIST list;

 	VA_START(list, aFmt);

 	TBuf<32> ebuf;

 	ErrStr(aErr, ebuf);

 	Self().iMess.FormatList(aFmt, list);

 	iDebugLock.Wait();

 	TPtrC8 ptr((TUint8*)aPos.iFailFile);

 	gErrorPos.Copy(ptr);

 	iWhere.Format(_L("  %S line %d\n"), &gErrorPos, aPos.iFailLine);

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

 	RDebug::Print(_L("%S in thread %S: %S"), &ebuf, &Self().iName, &Self().iMess);

 	RDebug::Print(_L("        %S line %d\n"), &gErrorPos, aPos.iFailLine);

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

 	iDebugLock.Signal();

 	User::Exit(aErr);

 	}

 TDesC& TTest::ErrStr(TInt aErr, TDes& aDes)

 ///

 /// Interpret an error status value as a string in the specified buffer.

 /// If the value isn't recognised then it formats a string containing the

 /// value itself (like "Error -65").

 /// @param aErr The error value.

 /// @param aDes Descriptor of the buffer to be used.

 /// @return     Descriptor of the buffer.

 ///

 	{

 	switch (aErr)

 		{

 		case KErrNone:

 			aDes = _L("KErrNone");

 			break;

 		case KErrNotFound:

 			aDes = _L("KErrNotFound");

 			break;

 		case KErrGeneral:

 			aDes = _L("KErrGeneral");

 			break;

 		case KErrCancel:

 			aDes = _L("KErrCancel");

 			break;

 		case KErrNoMemory:

 			aDes = _L("KErrNoMemory");

 			break;

 		case KErrNotSupported:

 			aDes = _L("KErrNotSupported");

 			break;

 		case KErrArgument:

 			aDes = _L("KErrArgument");

 			break;

 		case KErrTotalLossOfPrecision:

 			aDes = _L("KErrTotalLossOfPrecision");

 			break;

 		case KErrBadHandle:

 			aDes = _L("KErrBadHandle");

 			break;

 		case KErrOverflow:

 			aDes = _L("KErrOverflow");

 			break;

 		case KErrUnderflow:

 			aDes = _L("KErrUnderflow");

 			break;

 		case KErrAlreadyExists:

 			aDes = _L("KErrAlreadyExists");

 			break;

 		case KErrPathNotFound:

 			aDes = _L("KErrPathNotFound");

 			break;

 		case KErrDied:

 			aDes = _L("KErrDied");

 			break;

 		case KErrInUse:

 			aDes = _L("KErrInUse");

 			break;

 		case KErrServerTerminated:

 			aDes = _L("KErrServerTerminated");

 			break;

 		case KErrServerBusy:

 			aDes = _L("KErrServerBusy");

 			break;

 		case KErrCompletion:

 			aDes = _L("KErrCompletion");

 			break;

 		case KErrNotReady:

 			aDes = _L("KErrNotReady");

 			break;

 		case KErrUnknown:

 			aDes = _L("KErrUnknown");

 			break;

 		case KErrCorrupt:

 			aDes = _L("KErrCorrupt");

 			break;

 		case KErrAccessDenied:

 			aDes = _L("KErrAccessDenied");

 			break;

 		case KErrLocked:

 			aDes = _L("KErrLocked");

 			break;

 		case KErrWrite:

 			aDes = _L("KErrWrite");

 			break;

 		case KErrDisMounted:

 			aDes = _L("KErrDisMounted");

 			break;

 		case KErrEof:

 			aDes = _L("KErrEof");

 			break;

 		case KErrDiskFull:

 			aDes = _L("KErrDiskFull");

 			break;

 		case KErrBadDriver:

 			aDes = _L("KErrBadDriver");

 			break;

 		case KErrBadName:

 			aDes = _L("KErrBadName");

 			break;

 		case KErrCommsLineFail:

 			aDes = _L("KErrCommsLineFail");

 			break;

 		case KErrCommsFrame:

 			aDes = _L("KErrCommsFrame");

 			break;

 		case KErrCommsOverrun:

 			aDes = _L("KErrCommsOverrun");

 			break;

 		case KErrCommsParity:

 			aDes = _L("KErrCommsParity");

 			break;

 		case KErrTimedOut:

 			aDes = _L("KErrTimedOut");

 			break;

 		case KErrCouldNotConnect:

 			aDes = _L("KErrCouldNotConnect");

 			break;

 		case KErrCouldNotDisconnect:

 			aDes = _L("KErrCouldNotDisconnect");

 			break;

 		case KErrDisconnected:

 			aDes = _L("KErrDisconnected");

 			break;

 		case KErrBadLibraryEntryPoint:

 			aDes = _L("KErrBadLibraryEntryPoint");

 			break;

 		case KErrBadDescriptor:

 			aDes = _L("KErrBadDescriptor");

 			break;

 		case KErrAbort:

 			aDes = _L("KErrAbort");

 			break;

 		case KErrTooBig:

 			aDes = _L("KErrTooBig");

 			break;

 		case KErrDivideByZero:

 			aDes = _L("KErrDivideByZero");

 			break;

 		case KErrBadPower:

 			aDes = _L("KErrBadPower");

 			break;

 		case KErrDirFull:

 			aDes = _L("KErrDirFull");

 			break;

 		case KErrHardwareNotAvailable:

 			aDes = _L("KErrHardwareNotAvailable");

 			break;

 		case KErrSessionClosed:

 			aDes = _L("KErrSessionClosed");

 			break;

 		case KErrPermissionDenied:

 			aDes = _L("KErrPermissionDenied");

 			break;

 		case KRequestPending:

 			aDes = _L("KRequestPending");

 			break;

 		default:

 			aDes = _L("Error ");

 			aDes.AppendNum(aErr);

 			break;

 		}

 	return aDes;

 	}

 TInt TTest::ParseCommandArguments(TPtrC aArgV[], TInt aArgMax)

 ///

 /// Parse command line.  Put the parameters into array aArgv for

 /// use by the tests, strip out flags starting with / or - and interpret

 /// them to set debug flags.

 ///

 	{

 	RFs fs;

 	TInt r = fs.Connect();

 	test(r == KErrNone);

 	TInt flags = 0;

 	TInt argc = ParseCommandArguments(aArgV, aArgMax, flags);

 	fs.SetDebugRegister(flags);

 	fs.Close();

 	return argc;

 	}

 TInt TTest::ParseCommandArguments(TPtrC aArgV[], TInt aArgMax, TInt& aDebugFlags)

 ///

 /// Parse command line.  Put the parameters into array aArgv for

 /// use by the tests, strip out flags starting with / or - and interpret

 /// them to set debug flags.

 ///

 	{

 	LOCAL_D TBuf<0x100> cmd;

 	User::CommandLine(cmd);

 	TLex lex(cmd);

 	TPtrC token=lex.NextToken();

 	TFileName thisfile=RProcess().FileName();

 	if (token.MatchF(thisfile)==0)

 		{

 		token.Set(lex.NextToken());

 		}

 	// set up parameter list (offset zero is the filename)

 	TInt argc = 0;

 	aArgV[argc++].Set(thisfile);

 	while (token.Length() != 0)

 		{

 		TChar ch = token[0];

 		// strip out (and interpret) flags starting with - or /

 		if (ch == '-' || ch == '/')

 			{

 			for (TInt i = 1; i < token.Length(); i++)

 				{

 				switch (User::UpperCase(token[i]))

 					{

 					case 'D':

 						aDebugFlags |= KDLYFAST;

 						break;

 					case 'F':

 						aDebugFlags |= KFSYS;

 						break;

 					case 'I':

 						aDebugFlags |= KISO9660;

 						break;

 					case 'L':

 						aDebugFlags |= KFLDR;

 						break;

 #ifdef __CONCURRENT_FILE_ACCESS__

 					case 'M':

 						aDebugFlags |= KTHRD;

 						break;

 #endif

 					case 'N':

 						aDebugFlags |= KNTFS;

 						break;

 					case 'S':

 						aDebugFlags |= KFSERV;

 						break;

 					case 'T':

 						aDebugFlags |= KLFFS;

 						break;

 					case 'Y':

 						aDebugFlags |= KDLYTRC;

 						break;

 					}

 				}

 			}

 		else if (argc < aArgMax)

 			aArgV[argc++].Set(token);

 		token.Set(lex.NextToken());

 		}

 	return argc;

 	}

 TChar TTest::DefaultDriveChar()

 	{

 	TFileName session;

 	RFs fs;

 	fs.Connect();

 	fs.SessionPath(session);

 	fs.Close();

 	TChar drvch = User::UpperCase(session[0]);

 	return drvch;

 	}

 TTest::TPos::TPos(const char *aFile, TInt aLine)

 	{

 	iFailFile = aFile;

 	iFailLine = aLine;

 	}