// 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);
	}