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

// Client / server logging for Test Framework

// NOTE : does NOT include secure API changes in EKA2

// 

//

// Test system includes

#include <testframework.h>

// do not export if Unit Testing

#if defined (__TSU_TESTFRAMEWORK__)

#undef EXPORT_C

#define EXPORT_C

#endif

/**

 *

 * HTML font formatting strings

 *

 * @xxxx

 *

 */

_LIT(KResultPass, "<font size=4 color=00AF00>");

_LIT(KResultFail, "<font size=4 color=FF0000>");

_LIT(KResultInconclusive, "<font size=4 color=0000FF>");

_LIT(KResultUndefined, "<font size=4 color=FF00FF>");

_LIT(KResultEnd, "</font>");

_LIT(KResultNonHtml, "");

_LIT(KResultKnownFailure, "<font size=4 color=008080>"); //A new TVerdict for a known failed test

// logging macro used only for verdicts - not for external use

#define VER_PRINTF(r1, r2, r3)		LogExtra(__FILE8__, __LINE__, ESevrVer, _L("%S%S%S\n"), (r1), (r2), (r3)) 

/**

 *

 * Static constructor for CLog.

 *

 *

 * @return	"CLog*"

 *			The constructed CLog

 *

 * @xxxx

 *

 */

EXPORT_C CLog* CLog::NewL()

	{

	CLog* self = new(ELeave) CLog;

	self->Construct();

	return self;

	}

/**

 *

 * Static NewLC constructor for CLog.

 *

 *

 * @return	"CLog*"

 *			The constructed CLog

 *

 * @xxxx

 *

 */

EXPORT_C CLog* CLog::NewLC()

	{

	CLog* self = new(ELeave) CLog;

	CleanupStack::PushL(self);

	self->Construct();

	return self;

	}

/**

 *

 * Second-phase constructor for CLog.

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::Construct()

	{

	iLogStatus = 0;		// no outputs enabled yet

	iSeverity = ESevrAll;

	//Do we need to put information about source file & #line?

	//Default is yes.

	iLogFlags = ELogPutSrcInfo | ELogHtmlMode;

	}

/**

 *

 * Destructor for CLog.

 *

 * @xxxx

 *

 */

EXPORT_C CLog::~CLog()

	{

	// tell server to close logs here

	iClientSession.Close();

	}

/**

 *

 * Open a new test log.

 *

 * @param	"const TDesC& aLogName"

 *			Log file or console name

 *

 * @param	"TInt aLogMode"

 *			Log modes (a bitmask of TTestFrameworkLogMode).

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::OpenLogFileL(const TDesC& aLogName, TInt aLogMode)

	{

	User::LeaveIfError(iClientSession.Connect());

	iClientSession.OpenLog(aLogName, aLogMode);

	// get and store the log status - this will determine whether we

	// e.g. do any formatting for file output

	iLogStatus = iClientSession.LogStatus();

	}

/**

 *

 * Open an existing test log.

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::OpenLogFileL()

	{

	User::LeaveIfError(iClientSession.Connect());

	iLogStatus = iClientSession.LogStatus();

	}

/**

 *

 * Set put source info (i.e. traceable logging).

 *

 * @param	"TBool aPutSrcInfo"

 *			Put source info on or off.

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::SetPutSrcInfo(TBool aPutSrcInfo)

	{

	if(aPutSrcInfo)

		iLogFlags |= ELogPutSrcInfo;

	else

		iLogFlags &= ~ELogPutSrcInfo;

	}

/**

 *

 * Set HTML logging mode.

 *

 * @param	"TBool aArg"

 *			HTML mode on or off.

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::SetHtmlLogMode(TBool aArg)

	{

	if(aArg)

		iLogFlags |= ELogHtmlMode;

	else

		iLogFlags &= ~ELogHtmlMode;

	}

/**

 *

 * Get HTML logging mode.

 *

 * @return	"TBool"

 *			HTML mode on or off.

 *

 * @xxxx

 *

 */

EXPORT_C TBool CLog::HtmlLogMode() const

	{

	return ((iLogFlags & ELogHtmlMode) != 0);

	}

/**

 *

 * General logging function.

 *

 * @param	"TRefByValue<const TDesC16> aFmt"

 *			Printf-style format.

 *

 * @param	"..."

 *			Variable print parameters

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::Log(TRefByValue<const TDesC16> aFmt, ...)

	{

    VA_LIST aList;

	VA_START(aList, aFmt);

	TIntegrationTestLog16Overflow overflow16;

	// decode formatted data for display on console

	TBuf<KMaxLogLineLength> lineBuf;

	lineBuf = KNullDesC;

	lineBuf.AppendFormatList(aFmt, aList, &overflow16);

	// write to the console

	if(iLogStatus & ELogConsoleFull)

		iClientSession.WriteLog(lineBuf, ELogToConsole);

	// write to log file

	WriteFormat(_L("%S\n"), &lineBuf);

	VA_END(aList); 

	}

/**

 *

 * General logging function with severity.

 *

 * @param	"TInt aSeverity"

 *			Severity level required to log

 *

 * @param	"TRefByValue<const TDesC16> aFmt"

 *			Printf-style format.

 *

 * @param	"..."

 *			Variable print parameters

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::Log(TInt aSeverity, TRefByValue<const TDesC16> aFmt, ...)

	{

    VA_LIST aList;

	VA_START(aList, aFmt);

	if(LogSeverity::IsActive(aSeverity, Severity()))

		{

		Log(aFmt, aList);

		}

	VA_END(aList); 

	}

/**

 *

 * General logging function.

 *

 * @param	"TRefByValue<const TDesC16> aFmt"

 *			Printf-style format.

 *

 * @param	"VA_LIST aList"

 *			Variable print parameters

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::Log(TRefByValue<const TDesC16> aFmt, VA_LIST aList)

	{

	// decode formatted data for display on console

	TBuf<KMaxLogLineLength> lineBuf;

	TIntegrationTestLog16Overflow overflow16;

	lineBuf = KNullDesC;

	lineBuf.AppendFormatList(aFmt, aList, &overflow16);

	// write to log file

	WriteFormat(_L("%S\n"),&lineBuf);

	// write to the console

	if(iLogStatus & ELogConsoleFull)

		iClientSession.WriteLog(lineBuf, ELogToConsole);

	}

/**

 *

 * Traceable logging function

 *

 * Should be used for macros only

 *

 * @param	"const TText8* aFile"

 *			Source code file name

 *

 * @param	"TInt aLine"

 *			Source code line

 *

 * @param	"TInt aSeverity"

 *			Severity level required to log

 *

 * @param	"TRefByValue<const TDesC16> aFmt"

 *			Printf-style format.

 *

 * @param	"VA_LIST aList"

 *			Variable print parameters

 *

 * @xxxx

 *

 */

#ifdef EXCLUDE_FOR_UNITTEST

EXPORT_C void CLog::LogExtra(const TText8* /*aFile*/, TInt /*aLine*/, TInt /*aSeverity*/,

							 TRefByValue<const TDesC16> /*aFmt*/, VA_LIST /*aList*/)

	{

	}

#else

EXPORT_C void CLog::LogExtra(const TText8* aFile, TInt aLine, TInt aSeverity,

							 TRefByValue<const TDesC16> aFmt, VA_LIST aList)

	{

	if(LogSeverity::IsActive(aSeverity, Severity()))

		{

		TIntegrationTestLog16Overflow overflow16;

		// decode formatted data for display on console

		TBuf<KMaxLogLineLength> lineBuf;

		lineBuf = KNullDesC;

		lineBuf.AppendFormatList(aFmt, aList, &overflow16);

		// write to the console

		if(iLogStatus & ELogConsoleFull)

			WriteLogConsole(lineBuf);

		// log severity

		TBuf<1> charSevr;

		switch(aSeverity)

			{

			case ESevrVer:

				charSevr = _L("V");

				break;

			case ESevrErr:

				charSevr = _L("E");

				break;

			case ESevrWarn:

				charSevr = _L("W");

				break;

			case ESevrInfo:

			default:

				charSevr = _L("I");

				break;

			}

		// Do we need to put information about source file & #line?

		if(iLogFlags & ELogPutSrcInfo)

			{		// Braces used to scope lifetime of TBuf objects

			TPtrC8 fileName8(aFile);

			TBuf<256> fileName;

			TParse printFileName;

			fileName.Copy(fileName8);  // TText8->TBuf16

			// We don't need full file name.

			printFileName.Set(fileName, NULL, NULL) ;

			fileName.Copy(printFileName.NameAndExt()) ;

			// write to log file

			WriteFormat(_L("%S\t%S\t%d\t%S\n"), &charSevr, &fileName, aLine, &lineBuf);

			}

		else

			{

			// write to log file

			WriteFormat(_L("%S\t%S\n"), &charSevr, &lineBuf);

			}

		}

	}

#endif // EXCLUDE_FOR_UNITTEST

/**

 *

 * Traceable logging function with variable param list.

 *

 * Should be used for macros only

 *

 * @param	"const TText8* aFile"

 *			Source code file name

 *

 * @param	"TInt aLine"

 *			Source code line

 *

 * @param	"TInt aSeverity"

 *			Severity level required to log

 *

 * @param	"TRefByValue<const TDesC16> aFmt"

 *			Printf-style format.

 *

 * @param	"..."

 *			Variable print parameters

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::LogExtra(const TText8* aFile, TInt aLine, TInt aSeverity,

		TRefByValue<const TDesC16> aFmt,...)

	{

	VA_LIST aList;

	VA_START(aList, aFmt);

	LogExtra(aFile, aLine, aSeverity, aFmt, aList);

	VA_END(aList); 

	}

/**

 *

 * Write a test result highlighted to the log.

 *

 * @param	"TVerdict aVerdict"

 *			The test verdict.

 *

 * @param	"TRefByValue<const TDesC16> aFmt"

 *			Printf-style format.

 *

 * @param	"..."

 *			Variable print parameters

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::LogResult(TVerdict aVerdict, TRefByValue<const TDesC16> aFmt, ...)

	{

    VA_LIST aList;

	VA_START(aList, aFmt);

	TIntegrationTestLog16Overflow iOverflow16;

	// decode formatted data for display on console

	TBuf <KMaxLogLineLength> lineBuf;

	lineBuf.AppendFormatList(aFmt, aList, &iOverflow16);

	// write to the console

	iClientSession.WriteLog(lineBuf, ELogToConsole);

	// write to log file

	if(iLogFlags & ELogHtmlMode)

		{ 

		switch(aVerdict)

			{

		case EPass:

			VER_PRINTF(&KResultPass(), &lineBuf, &KResultEnd());

			break;

		case EFail:

			VER_PRINTF(&KResultFail(), &lineBuf, &KResultEnd());

			break;

		case EInconclusive:

		case ETestSuiteError:

		case EAbort:

			VER_PRINTF(&KResultInconclusive(), &lineBuf, &KResultEnd());

			break;

		case EKnownFailure:	//A new TVerdict for a known failed test

			VER_PRINTF(&KResultKnownFailure(), &lineBuf, &KResultEnd());

			break;

		default: // undefined

			VER_PRINTF(&KResultUndefined(), &lineBuf, &KResultEnd());

			break;

			}

		}

	else

		{

			VER_PRINTF(&KResultNonHtml(), &lineBuf, &KResultNonHtml());

		}	

	VA_END(aList); 

	}

/**

 *

 * Make a readable string out of an EPOC error code.

 *

 * @param	"TInt aError"

 *			The error code

 *

 * @return	"TPtrC"

 *			The error code as a readable string

 *

 * @xxxx

 *

 */

EXPORT_C TPtrC CLog::EpocErrorToText(TInt aError)

	{

	switch (aError)

		{

	case KErrNone:

		return _L("KErrNone");

	case KErrNotFound:

		return _L("KErrNotFound");

	case KErrGeneral:

		return _L("KErrGeneral");

	case KErrCancel:

		return _L("KErrCancel");

	case KErrNoMemory:

		return _L("KErrNoMemory");

	case KErrNotSupported:

		return _L("KErrNotSupported");

	case KErrArgument:

		return _L("KErrArgument");

	case KErrTotalLossOfPrecision:

		return _L("KErrTotalLossOfPrecision");

	case KErrBadHandle:

		return _L("KErrBadHandle");

	case KErrOverflow:

		return _L("KErrOverflow");

	case KErrUnderflow:

		return _L("KErrUnderflow");

	case KErrAlreadyExists:

		return _L("KErrAlreadyExists");

	case KErrPathNotFound:

		return _L("KErrPathNotFound");

	case KErrDied:

		return _L("KErrDied");

	case KErrInUse:

		return _L("KErrInUse");

	case KErrServerTerminated:

		return _L("KErrServerTerminated");

	case KErrServerBusy:

		return _L("KErrServerBusy");

	case KErrCompletion:

		return _L("KErrCompletion");

	case KErrNotReady:

		return _L("KErrNotReady");

	case KErrUnknown:

		return _L("KErrUnknown");

	case KErrCorrupt:

		return _L("KErrCorrupt");

	case KErrAccessDenied:

		return _L("KErrAccessDenied");

	case KErrLocked:

		return _L("KErrLocked");

	case KErrWrite:

		return _L("KErrWrite");

	case KErrDisMounted:

		return _L("KErrDisMounted");

	case KErrEof:

		return _L("KErrEof");

	case KErrDiskFull:

		return _L("KErrDiskFull");

	case KErrBadDriver:

		return _L("KErrBadDriver");

	case KErrBadName:

		return _L("KErrBadName");

	case KErrCommsLineFail:

		return _L("KErrCommsLineFail");

	case KErrCommsFrame:

		return _L("KErrCommsFrame");

	case KErrCommsOverrun:

		return _L("KErrCommsOverrun");

	case KErrCommsParity:

		return _L("KErrCommsParity");

	case KErrTimedOut:

		return _L("KErrTimedOut");

	case KErrCouldNotConnect:

		return _L("KErrCouldNotConnect");

	case KErrCouldNotDisconnect:

		return _L("KErrCouldNotDisconnect");

	case KErrDisconnected:

		return _L("KErrDisconnected");

	case KErrBadLibraryEntryPoint:

		return _L("KErrBadLibraryEntryPoint");

	case KErrBadDescriptor:

		return _L("KErrBadDescriptor");

	case KErrAbort:

		return _L("KErrAbort");

	case KErrTooBig:

		return _L("KErrTooBig");

	default:

		return _L("Unknown");

		} // end switch

	}

/**

 *

 * Make a readable string out of a test verdict.

 *

 * @param	"TVerdict aTestVerdict"

 *			The test verdict

 *

 * @return	"TPtrC"

 *			The test verdict as a readable string

 *

 * @xxxx

 *

 */

EXPORT_C TPtrC CLog::TestResultText(TVerdict aTestVerdict)

	{

	switch (aTestVerdict)

		{

	case EPass:

		return _L("PASS");

	case EFail:

		return _L("FAIL");

	case EInconclusive:

		return _L("INCONCLUSIVE");

	case ETestSuiteError:

		return _L("TEST_SUITE_ERROR");

	case EAbort:

		return _L("ABORT");

	case EKnownFailure: //A new TVerdict for a known failed test

		return _L("KNOWN_Failure"); //using lower case in 'Failure' can remove the confusion on 'savres2html.bat' making test summary

	default:

		return _L("undefined");

		}

	}

/**

 *

 * Write blank lines to the log.

 *

 * @param	"TInt number"

 *			Number of lines to write

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::LogBlankLine(TInt aNumber)

	{

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

		Log(_L(" "));

	}

/**

 *

 * Close the log.

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::CloseLogFile()

	{

	// add the htm end

	WriteFormat(_L("</end>"));

	iClientSession.CloseLog();

	}

/**

 *

 * Set log severity.

 *

 * @param	"TInt aSeverity"

 *			The required severity

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::SetSeverity(TInt aSeverity)

{

	iSeverity = aSeverity;

}

/**

 *

 * Get log severity.

 *

 * @return	"TInt"

 *			The current severity

 *

 * @xxxx

 *

 */

EXPORT_C TInt CLog::Severity() const

{

	return iSeverity;

}

/**

 *

 * Get log status from this logger's client session.

 *

 * @return	"TInt"

 *			The current log status (a bitmask of TTestFrameworkLogMode)

 *

 * @xxxx

 *

 */

EXPORT_C TInt CLog::LogStatus()

	{

	return iClientSession.LogStatus();

	}

/**

 *

 * Write formatted output to the log.

 *

 * @param	"TRefByValue<const TDesC16> aFmt"

 *			Printf-style format.

 *

 * @param	"..."

 *			Variable print parameters

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::WriteFormat(TRefByValue<const TDesC16> aFmt, ...)

	{

	// file / port logging not enabled

	if (!(iLogStatus & ELogToFile))

		if (!(iLogStatus & ELogToPort))

			return;

    VA_LIST aList;

	VA_START(aList, aFmt);

	TIntegrationTestLog16Overflow overflow16;

	TUint16* dataBufPtr = (TUint16*)(iDataBuf.Ptr());

	TPtr16 lineBuf(dataBufPtr, 0, KMaxLogLineLength);

	lineBuf.Fill('\0', KMaxLogLineLength);

	// get the current time and date

	TTime now;

	now.HomeTime();

	TDateTime dateTime = now.DateTime() ;

	// add the current time and date 

	lineBuf.Format(_L("%02d/%02d/%04d\t%02d:%02d:%02d:%03d\t"),

		dateTime.Day()+1,

		dateTime.Month()+1,

		dateTime.Year(),

		dateTime.Hour(),

		dateTime.Minute(),

		dateTime.Second(),

		(dateTime.MicroSecond() / 1000)); 

	// followed by the formatted data

	lineBuf.AppendFormatList(aFmt, aList, &overflow16);

	VA_END(aList); 

	// send one message - the server will write to both if enabled

	TInt theStatus = 0;

	if (iLogStatus & ELogToFile)

		theStatus |= ELogToFile;

	if (iLogStatus & ELogToPort)

		theStatus |= ELogToPort;

	iClientSession.WriteLog(lineBuf, theStatus);

	}

/**

 *

 * Write output to the console with date/time stamp

 *

 * @param	"const TDesC& aBuf"

 *			The output.

 *

 * @xxxx

 *

 */

EXPORT_C void CLog::WriteLogConsole(const TDesC& aBuf)

	{

	// console logging not enabled

	if (!(iLogStatus & ELogConsoleFull))

		return;

	// decode formatted data for display on console

	TUint16* dataBufPtr = (TUint16*)(iDataBuf.Ptr());

	TPtr16 lineBuf(dataBufPtr, 0, KMaxLogLineLength);

	lineBuf.Fill('\0', KMaxLogLineLength);

	// get the current time and date

	TTime now;

	now.HomeTime();

	TDateTime dateTime = now.DateTime() ;

	// add the current time and date 

	lineBuf.Format(_L("%02d/%02d/%04d\t%02d:%02d:%02d:%03d\t%S"),

		dateTime.Day()+1,

		dateTime.Month()+1,

		dateTime.Year(),

		dateTime.Hour(),

		dateTime.Minute(),

		dateTime.Second(),

		(dateTime.MicroSecond() / 1000),

		&aBuf); 

	iClientSession.WriteLog(lineBuf, ELogToConsole);

	}

/**

 *

 * This function is used to avoid a panic if format text overflows 

 * the internal buffer.

 *

 * @param "TDes16&"

 *		  the overflowing string

 *

 * @xxxx

 *

 */

void TIntegrationTestLog16Overflow::Overflow(TDes16& aDes)

	{

	aDes = _L("*** ERROR : line too long, cannot log ***");

	}

/**

 *

 * Check a severity value is valid.

 *

 * @param "TInt aSev"

 *		  The value to check.

 *

 * @return "TBool"

 *			Valid (ETrue) or not (EFalse).

 *

 * @xxxx

 *

 */

EXPORT_C TBool LogSeverity::IsValid(TInt aSev)

	{ 

	return ((aSev & ~(ESevrAll)) == 0);

	}

/**

 *

 * Check a severity value is active

 *

 * @param "TInt aThisSev"

 *		  The value to check.

 *

 * @param "TInt aGlobalSev"

 *		  The value to check against (e.g. global severity value of a log).

 *

 * @return "TBool"

 *			Active (ETrue) or not (EFalse).

 *

 * @xxxx

 *

 */

EXPORT_C TBool LogSeverity::IsActive(TInt aThisSev, TInt aGlobalSev)

	{ 

	return ((aThisSev & aGlobalSev) != 0);

	}