diff -r 000000000000 -r 3e07fef1e154 testexecfw/tef/utils/src/testexecutelogger.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testexecfw/tef/utils/src/testexecutelogger.cpp Mon Mar 08 15:03:44 2010 +0800 @@ -0,0 +1,3997 @@ +/* +* Copyright (c) 2005-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: +* Interface class which exposes methods to TestExecute to mediate calls to HTML and XML log client sessions +* Includes construction of console which was previosly within the testexecute.cpp +* Includes methods for initialising log creation & writing initial and end up tags and results summary +* +*/ + + + +/** + @file TestExecuteLogger.cpp +*/ + +#include "TestExecuteLogger.h" +#include "Version.h" +#include "TEFConst.h" +#include "SerialWriter.h" +#include +#include + +_LIT8(KHtmlBegin8,"

\n");
+_LIT8(KHtmlEnd8,"

\n"); +_LIT(KHtmlBegin16,"

");
+_LIT(KHtmlEnd16,"

"); + +// Test Block XML literals +_LIT(KObjectType, "OBJECT_TYPE"); +_LIT(KObjectSection, "OBJECT_SECTION"); +_LIT(KSection, "SECTION"); +_LIT(KFunctionName, "FUNCTION_NAME"); +_LIT(KDelay, "DELAY"); +_LIT(KInterval, "INTERVAL"); +_LIT(KEErrorCode, "EXPECTED_ERROR_CODE"); +_LIT(KErrorCode, "ERROR_CODE"); +_LIT(KEAsyncErrorCode, "EXPECTED_ASYNC_ERROR_CODE"); +_LIT(KAsyncErrorCode, "ASYNC_ERROR_CODE"); +_LIT(KBadCommand, "BAD_COMMAND"); + +/** + * Logging Test result information to html formatted file and, at same time, + * a simplified test file. + * The html file is TEF traditional log result file used to acting as TestDB. + * The simplified file is used to enable super amount test cases. + * @param aLogFileDir - Directory of log file, usually @ testexecute.ini + * HTML = ${SYSDRIVE}\logs\testexecute\ + * @param aLogFileName - name of log file. + * @param aResultBuf - log result this is buffer of log. + * + * @internalComponent + */ +void CTestExecuteLogger::LoggingTestCaseResultToSummaryResultL( const TDesC &aLogFileDir,const TDesC &aLogFileName,const TDesC8 &aResultBuf) + { + RFs fS; + User::LeaveIfError(fS.Connect()); + CleanupClosePushL(fS); + + TBuf resultFileName(aLogFileDir); + resultFileName.Append(aLogFileName); + RFile logFile; + User::LeaveIfError(logFile.Open(fS,resultFileName, EFileWrite | EFileRead | EFileShareAny)); + CleanupClosePushL(logFile); + + TInt pos=0; + (void)logFile.Seek(ESeekEnd, pos); + (void)logFile.Write(aResultBuf); + + // Closing of objects + CleanupStack::Pop(&logFile); + logFile.Close(); + CleanupStack::Pop(&fS); + fS.Close(); + } + + +/** + * @param aLogOptions - One of the 3 enum values for HTML, XML and both HTML & XML logging + * Constructor + * Initialises HTML & XML objects for logging + */ +EXPORT_C CTestExecuteLogger::CTestExecuteLogger(TLoggerOptions aLogOptions) : + iLoggerOptions(aLogOptions), + iSerialWriter(NULL), + iPIPSExists(false) + { + } + +/** + * Destructor + */ +EXPORT_C CTestExecuteLogger::~CTestExecuteLogger() + { + } + +/** + * @param aFile - Name of the file that intiates the LogExtra call + * @param aLine - Line number within the file that initiates the call + * @param aSeverity - One of the 4 enum values indicating the severity of the message to be logged + * @param aFmt - Format string that indicates the number & type of inputs required for the variable argument call + * Function displays the message in the log based on the number of inputs followed by the format string + */ +EXPORT_C void CTestExecuteLogger::LogExtra(const TText8* aFile, TInt aLine, TInt aSeverity,TRefByValue aFmt,...) + { + // Create a variable list and collect the arguments into it + VA_LIST aList; + VA_START(aList, aFmt); + + if(iLoggerChannel == EFile || iLoggerChannel == EBoth) + { + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + // Call the Html log client interface for logging into html log + HtmlLogger().LogExtra(aFile, aLine, aSeverity, aFmt, aList); + } + if (iLoggerOptions == ELogXMLOnly || iLoggerOptions == ELogBoth) + { + // Call the Xml log client interface for logging into xml log + XmlLogger().Log(aFile, aLine, RFileFlogger::TLogSeverity(aSeverity), aFmt, aList); + } + if(iPIPSExists) + { + PIPSLogger().LogExtra(aFile, aLine, aSeverity, aFmt, aList); + } + } + if(iLoggerChannel == ESerial || iLoggerChannel == EBoth) + { + HBufC* buffer = HBufC::New(KMaxTestExecuteLogLineLength*2); + if (buffer) + { + TPtr ptr(buffer->Des()); + ptr.AppendFormatList(aFmt, aList); + iSerialWriter->WriteDecorated(ptr); + delete buffer; + } + } + + VA_END(aList); + } + +EXPORT_C TInt CTestExecuteLogger::ShareAuto() + { + if(iPIPSExists) + { + PIPSLogger().ShareAuto(); + } + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + return HtmlLogger().ShareAuto(); + } + return KErrNone; + } + +EXPORT_C void CTestExecuteLogger::Write(const TDesC& aLogBuffer) + { + if(iLoggerChannel == EFile || iLoggerChannel == EBoth) + { + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + HtmlLogger().Write(aLogBuffer); + } + } + if(iLoggerChannel == ESerial || iLoggerChannel == EBoth) + { + iSerialWriter->WriteDecorated(aLogBuffer) ; + } + if(iPIPSExists) + { + PIPSLogger().Write(aLogBuffer); + } + } + +EXPORT_C void CTestExecuteLogger::WriteFormat(TRefByValue aFmt,...) + { + VA_LIST aList; + VA_START(aList, aFmt); + if(iLoggerChannel == EFile || iLoggerChannel == EBoth) + { + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + HtmlLogger().WriteFormat(aFmt, aList); + } + } + if(iLoggerChannel == ESerial || iLoggerChannel == EBoth) + { + HBufC* buffer = HBufC::New(KMaxTestExecuteLogLineLength*2); + if (buffer) + { + TPtr ptr(buffer->Des()); + ptr.AppendFormatList(aFmt, aList); + iSerialWriter->WriteDecorated(ptr); + delete buffer; + } + } + if(iPIPSExists) + { + PIPSLogger().WriteFormat(aFmt, aList); + } + + VA_END(aList); + } + +EXPORT_C void CTestExecuteLogger::Write(const TDesC8& aLogBuffer) + { + if(iLoggerChannel == EFile || iLoggerChannel == EBoth) + { + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + HtmlLogger().Write(aLogBuffer); + } + } + if(iLoggerChannel == ESerial || iLoggerChannel == EBoth) + { + iSerialWriter->WriteDecorated(aLogBuffer) ; + } + if(iPIPSExists) + { + PIPSLogger().Write(aLogBuffer); + } + } + +EXPORT_C void CTestExecuteLogger::WriteFormat(TRefByValue aFmt,...) + { + // Set up a Variable argument list and call private method + VA_LIST aList; + VA_START(aList, aFmt); + if(iLoggerChannel == EFile || iLoggerChannel == EBoth) + { + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + HtmlLogger().WriteFormat(aFmt, aList); + } + } + if(iLoggerChannel == ESerial || iLoggerChannel == EBoth) + { + HBufC8* buffer = HBufC8::New(KMaxTestExecuteLogLineLength*2); + if (buffer) + { + TPtr8 ptr(buffer->Des()); + ptr.AppendFormatList(aFmt, aList); + iSerialWriter->WriteDecorated(ptr); + delete buffer; + } + } + if(iPIPSExists) + { + PIPSLogger().WriteFormat(aFmt, aList); + } + VA_END(aList); + } + +/** + * @param aFile - Name of the file that intiates the LogExtra call + * @param aLine - Line number within the file that initiates the call + * @param aSeverity - One of the 4 enum values indicating the severity of the message to be logged + * @param aCommandName - Name of the command whose fields are logged with the call to the function + * @param aNumberOfParams - Represents the size of the structure array being passed in to the function + * @param aLogFields - Pointer to the structure array passed in, that contains the field name & their values + * Logs the command name along with their field names and values corresponding to each of them + * The array should be passed in with structures for holding each of the field name/value pairs + */ +EXPORT_C void CTestExecuteLogger::LogToXml(const TText8* aFile, TInt aLine, TInt aSeverity,const TDesC& aCommandName, const TInt aNumberOfParams, TExtraLogField* aLogFields) + { + if((iLoggerChannel == EFile || iLoggerChannel == EBoth) + &&(iLoggerOptions == ELogXMLOnly || iLoggerOptions == ELogBoth)) + { + XmlLogger().Log(aFile, aLine, RFileFlogger::TLogSeverity(aSeverity), aNumberOfParams, aLogFields, KTEFStringFormat, &aCommandName); + } + } + +/** + * @param aFile - Name of the file that intiates the LogExtra call + * @param aLine - Line number within the file that initiates the call + * @param aSeverity - One of the 4 enum values indicating the severity of the message to be logged + * @param aCommandName - Name of the command whose fields are logged with the call to the function + * Logs the command name alone for those that does not have any valid fields for logging + */ +EXPORT_C void CTestExecuteLogger::LogToXml(const TText8* aFile, TInt aLine, TInt aSeverity,const TDesC& aCommandName) + { + if((iLoggerChannel == EFile || iLoggerChannel == EBoth) + &&(iLoggerOptions == ELogXMLOnly || iLoggerOptions == ELogBoth)) + { + XmlLogger().Log(aFile, aLine, RFileFlogger::TLogSeverity(aSeverity), KTEFStringFormat, &aCommandName); + } + } + +/** + * @param aScriptFilePath - Relative path where the script file is placed + * @param aSeparateLogFileMode - Flag that is switched on for separate file for logging, off otherwise + * @param aLogLevel - Indicates the default threshold level for logging messages within the XML log + * Initialises the logging for both HTML and XML, creating the directory path & files and adding initial tags for the logs + */ +EXPORT_C void CTestExecuteLogger::InitialiseLoggingL(const TDesC& aScriptFilePath, TBool aSeparateLogFileMode, TInt aLogLevel) + { + // Check to see if the plugin wrapper around the GetSystemDrive is loadable + // If yes, then instantiate the wrapper object and obtain the default system drive + // Else, use the hardcoded default drive as c: + TDriveName defaultSysDrive(KTEFLegacySysDrive); + RFs fileServer; + TVersionName version(fileServer.Version().Name()); + + RLibrary pluginLibrary; + CWrapperUtilsPlugin* plugin = TEFUtils::WrapperPluginNew(pluginLibrary); + + if (plugin!=NULL) + { + TDriveUnit driveUnit(plugin->GetSystemDrive()); + defaultSysDrive.Copy(driveUnit.Name()); + delete plugin; + pluginLibrary.Close(); + } + + // Create a object of Cinidata for parsing ini files + CTestExecuteIniData* parseTestExecuteIni = NULL; + TBuf htmlLogPath; + TBuf xmlLogPath; + TInt logLevel(aLogLevel); + TInt enableCommandsCountLogging; + TInt outPort; + + TRAPD(err,parseTestExecuteIni = CTestExecuteIniData::NewL(defaultSysDrive)); + if (err == KErrNone) + { + CleanupStack::PushL(parseTestExecuteIni); + parseTestExecuteIni->ExtractValuesFromIni(); + parseTestExecuteIni->GetKeyValueFromIni(KTEFHtmlKey, htmlLogPath); + iHtmlLogPath.Copy(htmlLogPath); + parseTestExecuteIni->GetKeyValueFromIni(KTEFXmlKey, xmlLogPath); + iXmlLogPath.Copy(xmlLogPath); + parseTestExecuteIni->GetKeyValueFromIni(KTEFRemotePanicDetection, iRemotePanic); + parseTestExecuteIni->GetKeyValueFromIni(KTEFEnableTestsCountLog, enableCommandsCountLogging); + parseTestExecuteIni->GetKeyValueFromIni(KTEFLogChannel, iLoggerChannel); + parseTestExecuteIni->GetKeyValueFromIni(KTEFOutputPort, outPort); + CleanupStack::PopAndDestroy(parseTestExecuteIni); + } + else + { + TBuf testExecuteLogPath(KTestExecuteLogPath); + testExecuteLogPath.Replace(0, 2, defaultSysDrive); + iHtmlLogPath.Copy(testExecuteLogPath); + iXmlLogPath.Copy(testExecuteLogPath); + iRemotePanic = 0; + enableCommandsCountLogging = KTEFOneValue; + } + + RFs fS; + User::LeaveIfError(fS.Connect()); + CleanupClosePushL(fS); + // Create the path arrived above + err = fS.MkDirAll(iHtmlLogPath); + if(err != KErrNone && err != KErrAlreadyExists) + User::Leave(err); // Leave if unable to create the HTML log path + err = fS.MkDirAll(iXmlLogPath); + if(err != KErrNone && err != KErrAlreadyExists) + User::Leave(err); // Leave if unable to create the XML log path + + // Delete any existing KTestExecuteScheduleTestLogCompatibilityNameFile + TBuf scheduleTestLogFileNameFile(iHtmlLogPath); + scheduleTestLogFileNameFile.Append(KTestExecuteScheduleTestLogCompatibilityNameFile); + (void)fS.Delete(scheduleTestLogFileNameFile); + TBuf loggerFile; + // Set up for separate log files as a safeguard + _LIT(KScriptEngine,"ScriptEngine"); + loggerFile.Copy(KScriptEngine); + + // HTML format + _LIT(KHtmExtension,".htm"); + // XML format + _LIT(KXmlExtension,".xml"); + + if(!aSeparateLogFileMode) + { + // Extract the log file name from the full script file path + // For example - z:\somefolder\somefile.script + // We try and extract "somefile". + _LIT(KTEFScriptExtension,".script"); + TInt offset = aScriptFilePath.Find(KTEFScriptExtension); + if(offset != KErrNotFound) + { + // Loop back to isolate \somefile.script + TInt i = offset-1; + for(;i;i--) + { + if(aScriptFilePath[i] == '\\') + break; + } + if(i) + { + // Get rid of the '\' + i++; + // For defect 116013, check the name length+path length. If bigger than 80 then leave KErrTooBig + if (offset-i+iHtmlLogPath.Length()+KHtmExtension().Length() > KMaxTestExecuteNameLength + || offset-i+iHtmlLogPath.Length()+KXmlExtension().Length() > KMaxTestExecuteNameLength) + { + User::Leave(KErrTooBig); + } + // END defect 116013 + // Isolated somefile.script + TInt j(0); + // Chop off the ".script" + loggerFile.SetLength(offset-i); + for(;i loggerFile8; + loggerFile8.Copy(loggerFile); + // Write "somefile" + User::LeaveIfError(file.Write(loggerFile8)); + CleanupStack::Pop(&file); + file.Close(); + } + } + } + + // Construct the full path for HTML + TBuf loggerHtmlFilePath(iHtmlLogPath); + loggerHtmlFilePath.Append(loggerFile); + loggerHtmlFilePath.Append(KHtmExtension); + // Construct the full path for XML + TBuf loggerXmlFilePath(iXmlLogPath); + loggerXmlFilePath.Append(loggerFile); + loggerXmlFilePath.Append(KXmlExtension); + + // Delete the log files if it exists + (void)fS.Delete(loggerHtmlFilePath); + (void)fS.Delete(loggerXmlFilePath); + + // Delete the summary file if it exists + TBuf resultSummary(iHtmlLogPath); + resultSummary.Append(KTEFTestExecuteResultSummaryFile); + (void)fS.Delete(resultSummary); + RFile file; + // Create a summary file and write the html tags + User::LeaveIfError(file.Create(fS,resultSummary, EFileShareAny | EFileWrite)); + CleanupClosePushL(file); + User::LeaveIfError(file.Write(KHtmlBegin8)); + CleanupStack::Pop(&file); + file.Close(); + + // Delete the simplified summary file + TBuf resultSimplifiedSummaryFile(iHtmlLogPath); + resultSimplifiedSummaryFile.Append(KTEFTestExecuteResultSimplifiedSummaryFile); + (void)fS.Delete(resultSimplifiedSummaryFile); + // Create the brand-new simplified summary file + User::LeaveIfError(file.Create(fS,resultSimplifiedSummaryFile, EFileShareAny | EFileWrite)); + file.Close(); + + CleanupStack::Pop(&fS); + fS.Close(); + + // Connect to HTML and XML log client session + User::LeaveIfError(Connect()); + + // Update the array of commands for any additions to commands count + // Also update the KTEFCommandCountsStructSize from the TEFExportConst.h for array size + TPtrC commandList[KTEFCommandCountsStructSize] = + { + TPtrC(KTEFRunScriptCommand), + TPtrC(KTEFStartTestCaseCommand), + TPtrC(KTEFRunTestStepCommand), + TPtrC(KTEFRunTestStepResultCommand), + TPtrC(KTEFRunPanicStepCommand), + TPtrC(KTEFRunPanicStepResultCommand), + TPtrC(KTEFRunProgramCommand), + TPtrC(KTEFRunWSProgramCommand), + TPtrC(KTEFStartTestBlock) + }; + + iRunScriptCommandCount = 0; + // Create an instance of the script pre-processor to extract count details of commands listed in array defined above + CScriptPreProcess scriptPreProcess(aScriptFilePath, commandList); + + // enableCommandsCountLogging is a flag which is updated based on the configuration done in testexecute.ini + // The script should be pre-processed only if the flag is set to ON in testexecute.ini + // The flag is set to OFF by default + if (enableCommandsCountLogging == KTEFOneValue) + { + // Start pre-processing and updates the counts in the structure array + scriptPreProcess.CountNoOfOccurences(); + } + + if(iLoggerChannel == ESerial || iLoggerChannel == EBoth) + { + InitialiseSerialLoggingL(logLevel, enableCommandsCountLogging, scriptPreProcess,outPort); + } + if(iLoggerChannel == EFile || iLoggerChannel == EBoth) + { + if (iLoggerOptions == ELogHTMLOnly) + { + // Call Initilise routine for HTML logging + // Also need to pass in the status of the enableCommandsCountLogging and the pre-processor object + InitialiseHTMLLoggingL(loggerHtmlFilePath, logLevel, enableCommandsCountLogging, scriptPreProcess); + } + else if (iLoggerOptions == ELogXMLOnly) + { + // Call Initilise routine for XML logging + // Also need to pass in the status of the enableCommandsCountLogging and the pre-processor object + InitialiseXMLLoggingL(loggerXmlFilePath, logLevel, enableCommandsCountLogging, scriptPreProcess); + } + else + { + // Call Initilise routine for HTML & XML logging + // Also need to pass in the status of the enableCommandsCountLogging and the pre-processor object + InitialiseHTMLLoggingL(loggerHtmlFilePath, logLevel, enableCommandsCountLogging, scriptPreProcess); + InitialiseXMLLoggingL(loggerXmlFilePath, logLevel, enableCommandsCountLogging, scriptPreProcess); + } + } + if(iPIPSExists) + { + InitialisePIPSLoggingL(logLevel, enableCommandsCountLogging, scriptPreProcess) ; + } + } + + + +EXPORT_C void CTestExecuteLogger::SetPipeName(TPtrC& aPipeName) + + { + User::LeaveIfError(PIPSLogger().CreateLog(aPipeName)); + } +/** + * Connects to the HTML log client session and creating the logs with initial tags for logging + * @param aLogFilePath - Relative path that is arrived after retrieving the path from the user through testexecute.ini + * @param aEnableCommandCount - Integer value representing the status of the EnableTestsCountLog option in the testexecute.ini + * @param aScriptPreProcess - Reference to the script pre-processor object used for retrieving values from structure array for logging + * @leave - If the logger instance is not able to create the HTML log file + */ +void CTestExecuteLogger::InitialisePIPSLoggingL( TInt aLogLevel, const TInt& aEnableCommandCount, CScriptPreProcess& aScriptPreProcess) + { + + PIPSLogger().SetLogLevel(TLogSeverity(aLogLevel)); + PIPSLogger().Write(KHtmlBegin16); // Write initial HTML tags + // Introduce a new information block called TEST SCRIPT SYNOPSIS + // To display synopsis of the script file and to display the TEF version + const TInt KTEFSynopsisStringMaxLength = 512; + TBuf lineBuf(KTEFFontLightBlue); + lineBuf.Append(KTEFTestSynopsisHTM); + lineBuf.Append(KTEFFontEnd); + lineBuf.Append(KTEFVersionMessage); + lineBuf.Append(KTEFProductVersion); + lineBuf.Append(KTEFNewLine); + + // If EnableTestsCountLog is set to ON, append the command and count details to the log file during intialisation + if (aEnableCommandCount == KTEFOneValue) + { + TInt index; + // Run a loop for the structure array size + for (index=0;index commandName; + TInt commandCount; + // Retrieve the command name and count at each array index + aScriptPreProcess.RetrieveValues(index, commandName, commandCount); + + // Append the command name and details to the synopsis block for logging + if (commandCount > KTEFZeroValue) + { + if (commandName.CompareF(KTEFRunScriptCommand) == 0) + { + iRunScriptCommandCount = commandCount; + } + lineBuf.Append(commandName); + lineBuf.Append(KTEFCountMessageHTM); + lineBuf.AppendNum(commandCount); + lineBuf.Append(KTEFNewLine); + } + } + } + // Write a time and date header + _LIT(KStarted,"*** TestExecute Started "); + + lineBuf.Append(KTEFNewLine); + lineBuf.Append(KTEFFontGreen); + lineBuf.Append(KStarted); + + TTime now; + now.UniversalTime(); + TDateTime dateTime = now.DateTime(); + _LIT(KFormat,"%02d/%02d/%04d %02d:%02d:%02d:%03d ***"); + // add the current time and date + lineBuf.AppendFormat(KFormat, + dateTime.Day()+1, + dateTime.Month()+1, + dateTime.Year(), + dateTime.Hour(), + dateTime.Minute(), + dateTime.Second(), + (dateTime.MicroSecond()/1000) ); + lineBuf.Append(KTEFFontEnd); + PIPSLogger().Write(lineBuf); // Append initial header message & time of logging at the start + + } +/** + * Connects to the HTML log client session and creating the logs with initial tags for logging + * @param aLogFilePath - Relative path that is arrived after retrieving the path from the user through testexecute.ini + * @param aEnableCommandCount - Integer value representing the status of the EnableTestsCountLog option in the testexecute.ini + * @param aScriptPreProcess - Reference to the script pre-processor object used for retrieving values from structure array for logging + * @leave - If the logger instance is not able to create the HTML log file + */ +void CTestExecuteLogger::InitialiseHTMLLoggingL(const TDesC& aLogFilePath, TInt aLogLevel, const TInt& aEnableCommandCount, CScriptPreProcess& aScriptPreProcess) + { + // Connect to the file logger server and create the log file we've just constructed + // This will be c:\logs\testexecute\somefile.htm or c:\logs\scriptengine.htm + + // Create the log file in the specified path with overwrite mode on + User::LeaveIfError(HtmlLogger().CreateLog(aLogFilePath,RTestExecuteLogServ::ELogModeOverWrite)); + HtmlLogger().SetLogLevel(TLogSeverity(aLogLevel)); + + HtmlLogger().Write(KHtmlBegin16); // Write initial HTML tags + + // Introduce a new information block called TEST SCRIPT SYNOPSIS + // To display synopsis of the script file and to display the TEF version + const TInt KTEFSynopsisStringMaxLength = 512; + TBuf lineBuf(KTEFFontLightBlue); + lineBuf.Append(KTEFTestSynopsisHTM); + lineBuf.Append(KTEFFontEnd); + lineBuf.Append(KTEFVersionMessage); + lineBuf.Append(KTEFProductVersion); + lineBuf.Append(KTEFNewLine); + + // If EnableTestsCountLog is set to ON, append the command and count details to the log file during intialisation + if (aEnableCommandCount == KTEFOneValue) + { + TInt index; + // Run a loop for the structure array size + for (index=0;index commandName; + TInt commandCount; + // Retrieve the command name and count at each array index + aScriptPreProcess.RetrieveValues(index, commandName, commandCount); + + // Append the command name and details to the synopsis block for logging + if (commandCount > KTEFZeroValue) + { + if (commandName.CompareF(KTEFRunScriptCommand) == 0) + { + iRunScriptCommandCount = commandCount; + } + lineBuf.Append(commandName); + lineBuf.Append(KTEFCountMessageHTM); + lineBuf.AppendNum(commandCount); + lineBuf.Append(KTEFNewLine); + } + } + } + + // Write a time and date header + _LIT(KStarted,"*** TestExecute Started "); + + lineBuf.Append(KTEFNewLine); + lineBuf.Append(KTEFFontGreen); + lineBuf.Append(KStarted); + + TTime now; + now.UniversalTime(); + TDateTime dateTime = now.DateTime(); + _LIT(KFormat,"%02d/%02d/%04d %02d:%02d:%02d:%03d ***"); + // add the current time and date + lineBuf.AppendFormat(KFormat, + dateTime.Day()+1, + dateTime.Month()+1, + dateTime.Year(), + dateTime.Hour(), + dateTime.Minute(), + dateTime.Second(), + (dateTime.MicroSecond()/1000) ); + lineBuf.Append(KTEFFontEnd); + HtmlLogger().Write(lineBuf); // Append initial header message & time of logging at the start + } + +/** + * Connects to the XML log client session and creates the logs in the path passed in + * Also sets in the default threshold for log level + * @param aLogFilePath - Relative path that is arrived after retrieving the path from the user through testexecute.ini + * @param aLogLevel - Indicates the default threshold level for logging messages within the XML log + * @param aEnableCommandCount - Integer value representing the status of the EnableTestsCountLog option in the testexecute.ini + * @param aScriptPreProcess - Reference to the script pre-processor object used for retrieving values from structure array for logging + * @leave - If the logger instance is not able to create the HTML log file + */ +void CTestExecuteLogger::InitialiseXMLLoggingL(const TDesC& aLogFilePath, TInt aLogLevel, const TInt& aEnableCommandCount, CScriptPreProcess& aScriptPreProcess) + { + // Create the log file for XML logging & open it in overwrite mode for writing the results + User::LeaveIfError(XmlLogger().CreateLog(aLogFilePath,RFileFlogger::ELogModeOverWrite)); + // Accept and set the default threshold log level for the XML logging from the user + XmlLogger().SetLogLevel(RFileFlogger::TLogSeverity(aLogLevel)); + + if (aEnableCommandCount == KTEFOneValue) + { + // Create an array of TLogField structure of size equal to the number of commands counted + TExtraLogField logField[KTEFCommandsCountPlusOne]; + + // The first structure array holds the TEF version information + logField[0].iLogFieldName.Copy(KTEFVersionMessageXML); + logField[0].iLogFieldValue.Copy(KTEFProductVersion); + + TInt index; + TInt actualStructSize=KTEFOneValue; + // Run through a loop for all the array indices + for (index=0;index commandName; + TInt commandCount; + // Retrieve the command names and counts for each array index + aScriptPreProcess.RetrieveValues(index, commandName, commandCount); + + // Append the command name and counts details to the TExtraLogField array created already + if (commandCount > KTEFZeroValue) + { + if (commandName.CompareF(KTEFRunScriptCommand) == 0) + { + iRunScriptCommandCount = commandCount; + } + logField[actualStructSize].iLogFieldName.Copy(commandName); + logField[actualStructSize].iLogFieldName.Append(KTEFCountMessageXML); + logField[actualStructSize].iLogFieldValue.AppendNum(commandCount); + actualStructSize++; + } + } + + // Pass in the updated TExtraLogField array along with a message block name + // To construct a new XML message block during the XML logging initialisation + LogToXml(((TText8*)__FILE__),__LINE__,RFileFlogger::TLogSeverity(ESevrHigh),KTEFTestSynopsisXML,actualStructSize,logField); + } + else + { + // Create an array of TLogField structure of size equal to the number of result categories for test steps + TExtraLogField logField[KTEFOneValue]; + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[0].iLogFieldName.Copy(_L("TEF_VERSION")); + logField[0].iLogFieldValue.Copy(KTEFProductVersion); + + LogToXml(((TText8*)__FILE__),__LINE__,RFileFlogger::TLogSeverity(ESevrHigh),KTEFTestSynopsisXML,KTEFOneValue,logField); + } + } + +void CTestExecuteLogger::OpenSerialPortL(const TInt aPortNumber) + { + if(iSerialWriter == NULL) + { + iSerialWriter = CSerialWriter::NewL(); + } + iPortNumber = aPortNumber; + iSerialWriter->Settings(iPortNumber) ; + } +/** + * Instantiates the Serial Logger and passes start log header + * @param aLogLevel - Indicates the default threshold level for logging messages within the XML log + * @param aEnableCommandCount - Integer value representing the status of the EnableTestsCountLog option in the testexecute.ini + * @param aScriptPreProcess - Reference to the script pre-processor object used for retrieving values from structure array for logging + * @param aPortNumber - Port to be used for serial logging. + * @leave - If the logger instance is not successful + */ +void CTestExecuteLogger::InitialiseSerialLoggingL(TInt /*aLogLevel*/, const TInt& aEnableCommandCount, CScriptPreProcess& aScriptPreProcess,TInt aPortNumber) + { + OpenSerialPortL(aPortNumber); + // Introduce a new information block called TEST SCRIPT SYNOPSIS + // To display synopsis of the script file and to display the TEF version + const TInt KTEFSynopsisStringMaxLength = 512; + TBuf lineBuf(KTEFTestSynopsisHTM); + lineBuf.Append(KTEFVersionMessage); + lineBuf.Append(KTEFProductVersion); + lineBuf.Append(KTEFNewLine); + + // If EnableTestsCountLog is set to ON, append the command and count details to the log file during intialisation + if (aEnableCommandCount == KTEFOneValue) + { + TInt index; + // Run a loop for the structure array size + for (index=0;index commandName; + TInt commandCount; + // Retrieve the command name and count at each array index + aScriptPreProcess.RetrieveValues(index, commandName, commandCount); + + // Append the command name and details to the synopsis block for logging + if (commandCount > KTEFZeroValue) + { + if (commandName.CompareF(KTEFRunScriptCommand) == 0) + { + iRunScriptCommandCount = commandCount; + } + lineBuf.Append(commandName); + lineBuf.Append(KTEFCountMessageHTM); + lineBuf.AppendNum(commandCount); + lineBuf.Append(KTEFNewLine); + } + } + } + _LIT(KStarted,"*** TestExecute Started "); + lineBuf.Append(KTEFNewLine); + lineBuf.Append(KStarted); + iSerialWriter->WriteDecorated(lineBuf) ; + } + +/** + * @param aCommentedCommandsCount - Integer descriptor containing the counts + * of commented commands in the script for logging + * Terminate Logging routine + * Responsible for closing the objects created for logging and also to close the log client sessions + * Also appends final end up tags for the logs + */ +EXPORT_C void CTestExecuteLogger::TerminateLoggingL(const TInt aCommentedCommandsCount, const TInt aRemotePanicsCount, const TInt aRunScriptFailCount) + { + RFs fS; + User::LeaveIfError(fS.Connect()); + CleanupClosePushL(fS); + + // Delete the KTestExecuteScheduleTestLogCompatibilityNameFile + // May not exist but who cares + TBuf scheduleTestLogFileNameFile(iHtmlLogPath); + scheduleTestLogFileNameFile.Append(KTestExecuteScheduleTestLogCompatibilityNameFile); + (void)fS.Delete(scheduleTestLogFileNameFile); + // Open the result summary file + TBuf resultFileName(iHtmlLogPath); + //load simpifiled log results in case of out-of-memory + resultFileName.Append(KTEFTestExecuteResultSimplifiedSummaryFile); + RFile logFile; + User::LeaveIfError(logFile.Open(fS,resultFileName, EFileWrite | EFileRead | EFileShareAny)); + CleanupClosePushL(logFile); + TInt fileSize; + // Read the complete result summary file onto the heap + // It wont be that large + User::LeaveIfError(logFile.Size(fileSize)); + HBufC* resultData = HBufC::NewLC(fileSize); + HBufC8* resultData8 = HBufC8::NewLC(fileSize); + TPtr8 ptrData8(resultData8->Des()); + User::LeaveIfError(logFile.Read(ptrData8)); + TPtr ptrData(resultData->Des()); + ptrData.Copy(ptrData8); + logFile.Close(); + CleanupStack::PopAndDestroy(resultData8); + + // Set up some vars for the test step result types + iPassCount=0; + iFailCount=0; + iAbortCount=0; + iUnknownCount=0; + iInconclusiveCount=0; + iPanicCount=0; + iUnexecutedCount=0; + + // Set up some vars for the RUN_PROGRAM result types + iRunProgramUsed=EFalse; + iRunProgramPassCount=0; + iRunProgramFailCount=0; + iRunProgramAbortCount=0; + iRunProgramUnknownCount=0; + iRunProgramInconclusiveCount=0; + iRunProgramPanicCount=0; + iRunProgramUnexecutedCount=0; + + // Set up some vars for the testcase result types + iTestCasesUsed=EFalse; + iTestCasePassCount=0; + iTestCaseFailCount=0; + iTestCaseSkippedCount=0; + iTestCaseInconclusiveCount=0; + + // We loop through looking for the ***Result test step & + // testcase ***TestCaseResult tokens + // The result code will be the token after the '=' + _LIT(KEquality,"="); + + TLex lex(ptrData); + + while (!lex.Eos()) + { + // Find the ***Result keywords to retrieve the test step summary results + + TPtrC token(lex.NextToken()); + + if(token==KTEFRunProgramCommand || token==KTEFRunWSProgramCommand) + { + iRunProgramUsed = ETrue; + TPtrC token(lex.NextToken()); + while(token != KTEFResultTag) + token.Set(lex.NextToken()); + if (lex.NextToken() != KEquality) + continue; + token.Set(lex.NextToken()); + if(token == KTEFResultAbort) + iRunProgramAbortCount++; + else if(token == KTEFResultFail) + iRunProgramFailCount++; + else if(token == KTEFResultPass) + iRunProgramPassCount++; + else if(token == KTEFResultInconclusive) + iRunProgramInconclusiveCount++; + else if(token == KTEFResultPanic) + iRunProgramPanicCount++; + else if (token == KTEFResultUnexecuted) + iRunProgramUnexecutedCount++; + else + iRunProgramUnknownCount++; + } + else if(token == KTEFResultTag) + { + if (lex.NextToken() != KEquality) + continue; + TPtrC token(lex.NextToken()); + if(token == KTEFResultAbort) + iAbortCount++; + else if(token == KTEFResultFail) + iFailCount++; + else if(token == KTEFResultPass) + iPassCount++; + else if(token == KTEFResultInconclusive) + iInconclusiveCount++; + else if(token == KTEFResultPanic) + iPanicCount++; + else if (token == KTEFResultUnexecuted) + iUnexecutedCount++; + else + iUnknownCount++; + } + else + { + if (token == KTEFTestCaseResultTag) // Find the ***TestCaseResult keywords to retrieve the test case summary results + { + iTestCasesUsed = ETrue; + if (lex.NextToken() != KEquality) + continue; + TPtrC token(lex.NextToken()); + if(token == KTEFResultPass) + iTestCasePassCount++; + else if(token == KTEFResultFail) + iTestCaseFailCount++; + else if(token == KTEFResultSkippedSelectively) + iTestCaseSkippedCount++; + else + iTestCaseInconclusiveCount++; + } + } + } + // Cleanup heap memory + CleanupStack::PopAndDestroy(resultData); + + //summary save to test result to "TestResults.htm" + resultFileName.Copy(iHtmlLogPath); + resultFileName.Append(KTEFTestExecuteResultSummaryFile); + User::LeaveIfError(logFile.Open(fS,resultFileName, EFileWrite | EFileRead | EFileShareAny)); + TInt pos=0; + (void)logFile.Seek(ESeekEnd, pos); + if(iLoggerChannel == EFile || iLoggerChannel == EBoth) + { + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + TerminateHTMLLoggingL(&logFile, aCommentedCommandsCount, aRemotePanicsCount, aRunScriptFailCount); + } + if (iLoggerOptions == ELogXMLOnly || iLoggerOptions == ELogBoth) + { + TerminateXMLLoggingL(aCommentedCommandsCount, aRemotePanicsCount, aRunScriptFailCount); + } + } + // Cleanup/Close allocated objects + Close(); + CleanupStack::Pop(&logFile); + logFile.Close(); + CleanupStack::Pop(&fS); + fS.Close(); + } + + + +/** + * @param aLogFile - Pointer to the file object for appending end up tags for HTML log result + * @param aCommentedCommandsCount - Integer descriptor containing the counts + * of commented commands in the script for logging + * Called by the Termination routine based on the logger options set by the user for HTML specific log results + */ +void CTestExecuteLogger::TerminateHTMLLoggingL(RFile* aLogFile, const TInt aCommentedCommandsCount, const TInt aRemotePanicsCount, const TInt aRunScriptFailCount) + { + // Construct a summary buffer + // And write it to the logger file and the result summary file + TBuf summaryLine; + summaryLine.Append(KTEFFontLightBlue); + + if (iTestCasesUsed) + { + _LIT(KTEFTestSummary,"TEST STEP SUMMARY:"); + summaryLine.Append(KTEFTestSummary); + } + else + { + _LIT(KSummary,"SUMMARY:"); + summaryLine.Append(KSummary); + } + + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + TBuf8 summaryLine8; + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontGreen); + summaryLine.Append(KTEFResultPass); + summaryLine.AppendFormat(KTEFEqualsInteger,iPassCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontRed); + summaryLine.Append(KTEFResultFail); + summaryLine.AppendFormat(KTEFEqualsInteger,iFailCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultAbort); + summaryLine.AppendFormat(KTEFEqualsInteger,iAbortCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultPanic); + summaryLine.AppendFormat(KTEFEqualsInteger,iPanicCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultInconclusive); + summaryLine.AppendFormat(KTEFEqualsInteger,iInconclusiveCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultUnknown); + summaryLine.AppendFormat(KTEFEqualsInteger,iUnknownCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultUnexecuted); + summaryLine.AppendFormat(KTEFEqualsInteger,iUnexecutedCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFCommentedCommands); + summaryLine.AppendFormat(KTEFEqualsInteger,aCommentedCommandsCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + if (iRemotePanic != 0) + { + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + _LIT(KTEFSystemPanics, "SYSTEM PANICS COUNT"); + summaryLine.Append(KTEFSystemPanics); + summaryLine.AppendFormat(KTEFEqualsInteger,aRemotePanicsCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + } + + if(iRunProgramUsed) + { + summaryLine.Zero(); + summaryLine.Append(KTEFFontLightBlue); + _LIT(KTEFTestCaseSummary, "RUN_PROGRAM SUMMARY:"); + summaryLine.Append(KTEFTestCaseSummary); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + TBuf8 summaryLine8; + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontGreen); + summaryLine.Append(KTEFResultPass); + summaryLine.AppendFormat(KTEFEqualsInteger,iRunProgramPassCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontRed); + summaryLine.Append(KTEFResultFail); + summaryLine.AppendFormat(KTEFEqualsInteger,iRunProgramFailCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultAbort); + summaryLine.AppendFormat(KTEFEqualsInteger,iRunProgramAbortCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultPanic); + summaryLine.AppendFormat(KTEFEqualsInteger,iRunProgramPanicCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultInconclusive); + summaryLine.AppendFormat(KTEFEqualsInteger,iRunProgramInconclusiveCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultUnknown); + summaryLine.AppendFormat(KTEFEqualsInteger,iRunProgramUnknownCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultUnexecuted); + summaryLine.AppendFormat(KTEFEqualsInteger,iRunProgramUnexecutedCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + } + + if (iTestCasesUsed) + { + summaryLine.Zero(); + summaryLine.Append(KTEFFontLightBlue); + _LIT(KTEFTestCaseSummary, "TEST CASE SUMMARY:"); + summaryLine.Append(KTEFTestCaseSummary); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + TBuf8 summaryLine8; + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontGreen); + summaryLine.Append(KTEFResultPass); + summaryLine.AppendFormat(KTEFEqualsInteger,iTestCasePassCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontRed); + summaryLine.Append(KTEFResultFail); + summaryLine.AppendFormat(KTEFEqualsInteger,iTestCaseFailCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontGrey); + summaryLine.Append(KTEFResultSkippedSelectively); + summaryLine.AppendFormat(KTEFEqualsInteger,iTestCaseSkippedCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontBlue); + summaryLine.Append(KTEFResultInconclusive); + summaryLine.AppendFormat(KTEFEqualsInteger,iTestCaseInconclusiveCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + } + + if (iRunScriptCommandCount > 0) + { + summaryLine.Zero(); + summaryLine.Append(KTEFFontLightBlue); + summaryLine.Append(KTEFRunScriptSummary); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + TBuf8 summaryLine8; + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontGreen); + summaryLine.Append(KTEFScriptExecuted); + TInt executedCount = iRunScriptCommandCount - aRunScriptFailCount; + summaryLine.AppendFormat(KTEFEqualsInteger,executedCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + + summaryLine.Zero(); + summaryLine.Append(KTEFFontRed); + summaryLine.Append(KTEFFailedOpen); + summaryLine.AppendFormat(KTEFEqualsInteger,aRunScriptFailCount); + summaryLine.Append(KTEFFontEnd); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(summaryLine); + summaryLine8.Copy(summaryLine); + summaryLine8.Append(KTEFEndOfLine); + User::LeaveIfError(aLogFile->Write(summaryLine8)); + } + + User::LeaveIfError(aLogFile->Write(KHtmlEnd8)); + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + HtmlLogger().Write(KHtmlEnd16); // Write the summary results to the HTML log file + + } + +/** + * @param aCommentedCommandsCount - Integer descriptor containing the counts + * of commented commands in the script for logging + * Called by the Termination routine based on the logger options set by the user for HTML specific log results + * Appends the XML tags for displaying the summary results for the test cases and test steps executed + * Closes the session with XML log client session + */ +void CTestExecuteLogger::TerminateXMLLoggingL(const TInt aCommentedCommandsCount, const TInt aRemotePanicsCount, const TInt aRunScriptFailCount) + { + TBuf fieldValue; + TBuf commandName; + + // Create an array of TLogField structure of size equal to the number of result categories for test steps + TExtraLogField logField[9]; + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[0].iLogFieldName.Copy(KTEFResultPass); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iPassCount); + logField[0].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[1].iLogFieldName.Copy(KTEFResultFail); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iFailCount); + logField[1].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[2].iLogFieldName.Copy(KTEFResultAbort); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iAbortCount); + logField[2].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[3].iLogFieldName.Copy(KTEFResultUnknown); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iUnknownCount); + logField[3].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[4].iLogFieldName.Copy(KTEFResultInconclusive); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iInconclusiveCount); + logField[4].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[5].iLogFieldName.Copy(KTEFResultPanic); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iPanicCount); + logField[5].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[6].iLogFieldName.Copy(KTEFResultUnexecuted); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iUnexecutedCount); + logField[6].iLogFieldValue.Copy(fieldValue); + + _LIT(KTEFCommentedCommands,"COMMENTED_COMMANDS"); + logField[7].iLogFieldName.Copy(KTEFCommentedCommands); + fieldValue.Copy(KNull); + fieldValue.AppendNum(aCommentedCommandsCount); + logField[7].iLogFieldValue.Copy(fieldValue); + + if (iRemotePanic != 0) + { + _LIT(KTEFSystemPanics, "SYSTEMPANICS"); + logField[8].iLogFieldName.Copy(KTEFSystemPanics); + fieldValue.Copy(KNull); + fieldValue.AppendNum(aRemotePanicsCount); + logField[8].iLogFieldValue.Copy(fieldValue); + + commandName.Copy(KTEFTestStepSummary); + + // Call the Logger().LogToXml routine which handles XML logging for individual commands + // Takes in the command name, number of fields and the struture array + LogToXml(((TText8*)__FILE__), __LINE__,RFileFlogger::ESevrHigh, commandName, 9, logField); + } + else + { + commandName.Copy(KTEFTestStepSummary); + + // Call the Logger().LogToXml routine which handles XML logging for individual commands + // Takes in the command name, number of fields and the struture array + LogToXml(((TText8*)__FILE__), __LINE__,RFileFlogger::ESevrHigh, commandName, 8, logField); + } + + if (iRunProgramUsed) + { + // Create an array of TLogField structure of size equal to the number of result categories for run program logging + TExtraLogField logField[7]; + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[0].iLogFieldName.Copy(KTEFResultPass); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iRunProgramPassCount); + logField[0].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[1].iLogFieldName.Copy(KTEFResultFail); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iRunProgramFailCount); + logField[1].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[2].iLogFieldName.Copy(KTEFResultAbort); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iRunProgramAbortCount); + logField[2].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[3].iLogFieldName.Copy(KTEFResultUnknown); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iRunProgramUnknownCount); + logField[3].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[4].iLogFieldName.Copy(KTEFResultInconclusive); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iRunProgramInconclusiveCount); + logField[4].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[5].iLogFieldName.Copy(KTEFResultPanic); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iRunProgramPanicCount); + logField[5].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[6].iLogFieldName.Copy(KTEFResultUnexecuted); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iRunProgramUnexecutedCount); + logField[6].iLogFieldValue.Copy(fieldValue); + + commandName.Copy(KTEFRunProgramSummary); + + // Call the Logger().LogToXml routine which handles XML logging for individual commands + // Takes in the command name, number of fields and the struture array + LogToXml(((TText8*)__FILE__), __LINE__,RFileFlogger::ESevrHigh, commandName, 7, logField); + } + + if (iTestCasesUsed) + { + // Create a TLogField structure array + // Size of array equals to number of fields to be displayed + TExtraLogField logField[3]; + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[0].iLogFieldName.Copy(KTEFResultPass); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iTestCasePassCount); + logField[0].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[1].iLogFieldName.Copy(KTEFResultFail); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iTestCaseFailCount); + logField[1].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[1].iLogFieldName.Copy(KTEFResultSkippedSelectively); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iTestCaseSkippedCount); + logField[1].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[2].iLogFieldName.Copy(KTEFResultInconclusive); + fieldValue.Copy(KNull); + fieldValue.AppendNum(iTestCaseInconclusiveCount); + logField[2].iLogFieldValue.Copy(fieldValue); + + commandName.Copy(KTEFTestCaseSummary); + + // Call the Logger().LogToXml routine which handles XML logging for individual commands + // Takes in the command name, number of fields and the struture array + LogToXml(((TText8*)__FILE__), __LINE__,RFileFlogger::ESevrHigh, commandName, 3, logField); + } + + if (iRunScriptCommandCount > 0) + { + // Create a TLogField structure array + // Size of array equals to number of fields to be displayed + TExtraLogField logField[2]; + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[0].iLogFieldName.Copy(KTEFScriptExecuted); + fieldValue.Copy(KNull); + TInt runScriptPassCount = iRunScriptCommandCount - aRunScriptFailCount; + fieldValue.AppendNum(runScriptPassCount); + logField[0].iLogFieldValue.Copy(fieldValue); + + // The first member of the structure stores the field name + // The second one holds the value for the particular field + logField[1].iLogFieldName.Copy(KTEFFailedOpen); + fieldValue.Copy(KNull); + fieldValue.AppendNum(aRunScriptFailCount); + logField[1].iLogFieldValue.Copy(fieldValue); + + commandName.Copy(KTEFRunScriptSummary); + + // Call the Logger().LogToXml routine which handles XML logging for individual commands + // Takes in the command name, number of fields and the struture array + LogToXml(((TText8*)__FILE__), __LINE__,RFileFlogger::ESevrHigh, commandName, 2, logField); + } + } + +/** + * @param aFile - Name of the file that intiated the call + * @param aLine - Line number within the file that initiates the call + * @param aSeverity - One of the 4 enum values indicating the severity of the message to be logged + * @param aCommand - Name of the command whose fields are logged with the call to the function + * @param aResult - Result of the test case for logging + * Logs the name of the test case and the result corresponding to each START_TESTCASE/END_TESTCASE pairs + * This function branches out of the main one for logging over serial. + * This is done to avoid complexity in original code. + */ +void CTestExecuteLogger::LogTestCaseResultSerialL(const TDesC& aFile, TInt aLine, TInt aSeverity, const TDesC& aCommand, const TDesC& aTestCaseName, TVerdict aResult) + { + + _LIT(KTEFSpace, " "); + _LIT(KCommand, "Command = "); + _LIT(KLineNumber,"Line = %d"); + if (aCommand == KTEFStartTestCaseCommand || aCommand == KTEFEndTestCaseCommand + || aCommand == KTEFStartSyncTestCaseCommand || aCommand == KTEFEndSyncTestCaseCommand ) + { + + // Create a heap buffer to hold the log string for HTML + HBufC* resultBuffer = HBufC::NewLC(KMaxTestExecuteCommandLength*3); + TPtr ptr(resultBuffer->Des()); + HBufC* simplifiedResultBuf = HBufC::NewLC(KMaxTestExecuteCommandLength*2); + TPtr simplifiedPtr(simplifiedResultBuf->Des()); + simplifiedPtr.Zero(); + + // Appends remainder of the information required for logging + ptr.Append(aFile); + ptr.Append(KTEFSpace); + ptr.AppendFormat(KLineNumber,aLine); + ptr.Append(KTEFSpace); + ptr.Append(KCommand); + ptr.Append(aCommand); + simplifiedPtr.Append(aCommand); + ptr.Append(KTEFSpace); + simplifiedPtr.Append(KTEFSpace); + ptr.Append(aTestCaseName); + simplifiedPtr.Append(aTestCaseName); + ptr.Append(KTEFSpace); + simplifiedPtr.Append(KTEFSpace); + + TBuf resultTmpBuf; + resultTmpBuf.Zero(); + // Append ***TestCaseResult only in case of END_TESTCASE command with result of the test case + if (aCommand == KTEFEndTestCaseCommand || aCommand == KTEFEndSyncTestCaseCommand + || aResult==ESkippedSelectively) //append for when command is start_test_case + //but this is being skipped selectively + { + resultTmpBuf.Append(KTEFTestCaseResultTag); + resultTmpBuf.Append(KTEFSpaceEquals); + if (aResult == EPass) + { + resultTmpBuf.Append(KTEFResultPass); + } + else if (aResult == EFail) + { + resultTmpBuf.Append(KTEFResultFail); + } + else if(aResult==ESkippedSelectively) + { + resultTmpBuf.Append(KTEFResultSkippedSelectively); + } + else + { + resultTmpBuf.Append(KTEFResultInconclusive); + } + ptr.Append(resultTmpBuf); + simplifiedPtr.Append(resultTmpBuf); + } + + ptr.Append(KTEFSpace); + simplifiedPtr.Append(KTEFSpace); + // Copy the 16 bit heap descriptor value to 8 bit descriptor using a TPtr pointer to 8 bit heap descriptor + HBufC8* resultBuffer8 = HBufC8::NewLC(ptr.Length()+2); + TPtr8 ptr8(resultBuffer8->Des()); + ptr8.Copy(ptr); + ptr8.Append(KTEFEndOfLine); // Append new line & carriage return for the log string + + //the result summary file HTML + LoggingTestCaseResultToSummaryResultL(iHtmlLogPath,KTEFTestExecuteResultSummaryFile,ptr8); + //the result summary file simplified text + //re-use result buffer + ptr8.Copy(simplifiedPtr); + ptr8.Append(KTEFEndOfLine); + LoggingTestCaseResultToSummaryResultL(iHtmlLogPath,KTEFTestExecuteResultSimplifiedSummaryFile,ptr8); + CleanupStack::PopAndDestroy(resultBuffer8); + // Create objects of RFs & RFile for opening the result summary file for logging + + TInt bytesCopied = 0; + + while(bytesCopied < ptr.Length()) + { + TInt bytesToCopy = ptr.Length() - bytesCopied; + if(bytesToCopy > KMaxTestExecuteLogLineLength) + { + bytesToCopy = KMaxTestExecuteLogLineLength; + } + TPtrC tmp(&ptr[bytesCopied],bytesToCopy); + bytesCopied += bytesToCopy; + iSerialWriter->WriteDecorated(tmp, aSeverity); + } + // Cleanup heap allocations + CleanupStack::PopAndDestroy(simplifiedResultBuf); + CleanupStack::PopAndDestroy(resultBuffer); + } + } + +/** + * @param aFile - Name of the file that intiated the call + * @param aLine - Line number within the file that initiates the call + * @param aSeverity - One of the 4 enum values indicating the severity of the message to be logged + * @param aCommand - Name of the command whose fields are logged with the call to the function + * @param aResult - Result of the test case for logging + * Logs the name of the test case and the result corresponding to each START_TESTCASE/END_TESTCASE pairs + */ +EXPORT_C void CTestExecuteLogger::LogTestCaseResult(const TDesC& aFile, TInt aLine, TInt aSeverity, const TDesC& aCommand, const TDesC& aTestCaseName, TVerdict aResult) + { + + if(iLoggerChannel == ESerial || iLoggerChannel == EBoth) + { + LogTestCaseResultSerialL(aFile, aLine, aSeverity, aCommand, aTestCaseName, aResult); + } + if(iLoggerChannel != EFile && iLoggerChannel != EBoth) + { + return ; + } + + _LIT(KTEFSpace, " "); + _LIT(KCommand, "Command = "); + _LIT(KLineNumber,"Line = %d"); + + if (aCommand == KTEFStartTestCaseCommand || aCommand == KTEFEndTestCaseCommand + || aCommand == KTEFStartSyncTestCaseCommand || aCommand == KTEFEndSyncTestCaseCommand ) + { + // Create a heap buffer to hold the log string for HTML + HBufC* resultBuffer = HBufC::NewLC(KMaxTestExecuteCommandLength*3); + TPtr ptr(resultBuffer->Des()); + HBufC* simplifiedResultBuf = HBufC::NewLC(KMaxTestExecuteCommandLength*2); + TPtr simplifiedPtr(simplifiedResultBuf->Des()); + simplifiedPtr.Zero(); + + // Colour of the HTML result is controlled by the result of the command + // Anyway, the START_TESTCASE has no result attached with it & hence is always set to PASS + if (aResult == EPass) + { + // Log the message in Green + ptr.Append(KTEFFontGreen); + } + else if (aResult == EFail) + { + // Log the message in Red + ptr.Append(KTEFFontRed); + } + else if(aResult == ESkippedSelectively) + { + ptr.Append(KTEFFontGrey); + } + else + { + // Log the message in Blue + ptr.Append(KTEFFontBlue); + } + + // Appends remainder of the information required for logging + ptr.Append(aFile); + ptr.Append(KTEFSpace); + ptr.AppendFormat(KLineNumber,aLine); + ptr.Append(KTEFSpace); + ptr.Append(KCommand); + ptr.Append(aCommand); + simplifiedPtr.Append(aCommand); + ptr.Append(KTEFSpace); + simplifiedPtr.Append(KTEFSpace); + ptr.Append(aTestCaseName); + simplifiedPtr.Append(aTestCaseName); + ptr.Append(KTEFSpace); + simplifiedPtr.Append(KTEFSpace); + + TBuf resultTmpBuf; + resultTmpBuf.Zero(); + // Append ***TestCaseResult only in case of END_TESTCASE command with result of the test case + if (aCommand == KTEFEndTestCaseCommand || aCommand == KTEFEndSyncTestCaseCommand + || aResult==ESkippedSelectively) //append for when command is start_test_case + //but this is being skipped selectively + { + resultTmpBuf.Append(KTEFTestCaseResultTag); + resultTmpBuf.Append(KTEFSpaceEquals); + if (aResult == EPass) + { + resultTmpBuf.Append(KTEFResultPass); + } + else if (aResult == EFail) + { + resultTmpBuf.Append(KTEFResultFail); + } + else if(aResult==ESkippedSelectively) + { + resultTmpBuf.Append(KTEFResultSkippedSelectively); + } + else + { + resultTmpBuf.Append(KTEFResultInconclusive); + } + ptr.Append(resultTmpBuf); + simplifiedPtr.Append(resultTmpBuf); + } + + ptr.Append(KTEFSpace); + ptr.Append(KTEFFontEnd); + + // Copy the 16 bit heap descriptor value to 8 bit descriptor using a TPtr pointer to 8 bit heap descriptor + HBufC8* resultBuffer8 = HBufC8::NewLC(ptr.Length()+2); + TPtr8 ptr8(resultBuffer8->Des()); + ptr8.Copy(ptr); + ptr8.Append(KTEFEndOfLine); // Append new line & carriage return for the log string + + // Create objects of RFs & RFile for opening the result summary file for logging + LoggingTestCaseResultToSummaryResultL(iHtmlLogPath,KTEFTestExecuteResultSummaryFile,ptr8); + + ptr8.Copy(simplifiedPtr); + ptr8.Append(KTEFEndOfLine); + LoggingTestCaseResultToSummaryResultL(iHtmlLogPath,KTEFTestExecuteResultSimplifiedSummaryFile,ptr8); + + + CleanupStack::PopAndDestroy(resultBuffer8); + CleanupStack::PopAndDestroy(simplifiedResultBuf); + + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + TInt bytesCopied = 0; + + while(bytesCopied < ptr.Length()) + { + TInt bytesToCopy = ptr.Length() - bytesCopied; + if(bytesToCopy > KMaxTestExecuteLogLineLength) + { + bytesToCopy = KMaxTestExecuteLogLineLength; + } + TPtrC tmp(&ptr[bytesCopied],bytesToCopy); + bytesCopied += bytesToCopy; + HtmlLogger().Write(tmp); // Write results to HTML log file + if(iPIPSExists) + { + PIPSLogger().Write(tmp); + } + } + } + + // Cleanup heap allocations + CleanupStack::PopAndDestroy(resultBuffer); + } + + if (iLoggerOptions == ELogXMLOnly || iLoggerOptions == ELogBoth) + { + _LIT(KTEFTestCaseName,"TESTCASENAME"); + _LIT(KTEFSyncTestCaseName,"SYNCTESTCASENAME"); + _LIT(KTEFTestCaseResult,"RESULT"); + + if (aCommand == KTEFStartTestCaseCommand || aCommand == KTEFStartSyncTestCaseCommand ) + { + // Create a TExtraLogField object and set the TestCaseName for Logging + TExtraLogField logField[1]; + if( aCommand == KTEFStartSyncTestCaseCommand ) + { + logField[0].iLogFieldName.Copy(KTEFSyncTestCaseName); // Sync Test Case Name + } + else + { + logField[0].iLogFieldName.Copy(KTEFTestCaseName); // Test Case Name + } + logField[0].iLogFieldValue.Copy(aTestCaseName); + + // Log the command name along with the field-value pairs + XmlLogger().Log(((TText8*)__FILE__), aLine, RFileFlogger::TLogSeverity(aSeverity), 1, logField, KTEFStringFormat, &aCommand); + } + + // If the command is END_TESTCASE, an extra RESULT field also needs to be logged + else if (aCommand == KTEFEndTestCaseCommand || aCommand == KTEFEndSyncTestCaseCommand) + { + // Create a TExtraLogField object and set the TestCaseName & Result fields for Logging + TExtraLogField logField[2]; + if( aCommand == KTEFEndSyncTestCaseCommand ) + { + logField[0].iLogFieldName.Copy(KTEFSyncTestCaseName); // Sync Test Case Name + } + else + { + logField[0].iLogFieldName.Copy(KTEFTestCaseName); // Test Case Name + } + + logField[0].iLogFieldValue.Copy(aTestCaseName); + + logField[1].iLogFieldName.Copy(KTEFTestCaseResult); // Test Case Result + + // Set the result value based on the aResult parameter being passed in + if (aResult == EPass) + { + logField[1].iLogFieldValue.Copy(KTEFResultPass); + } + else if (aResult == EFail) + { + logField[1].iLogFieldValue.Copy(KTEFResultFail); + } + else if(aResult == ESkippedSelectively) + { + logField[1].iLogFieldValue.Copy(KTEFResultSkippedSelectively); + } + else + { + logField[1].iLogFieldValue.Copy(KTEFResultInconclusive); + } + + // Log the command name along with the field-value pairs & Result + XmlLogger().Log(((TText8*)__FILE__), aLine, RFileFlogger::TLogSeverity(aSeverity), 2, logField, KTEFStringFormat, &aCommand); + } + } + } + +/** + * @param aCurrentScriptLine - Reference to a descriptor that holds the current script line + * @param aScriptFile - Name of the file where the current script file exists + * Prints the current script line + */ +EXPORT_C void CTestExecuteLogger::PrintCurrentScriptLine(TDes& aCurrentScriptLine) + { + TInt length = aCurrentScriptLine.Length(); + (aCurrentScriptLine[length - 2] == '\r') ? (aCurrentScriptLine.SetLength(length - 2)) : (aCurrentScriptLine.SetLength(length - 1)); + + if(iLoggerChannel == ESerial || iLoggerChannel == EBoth) + { + iSerialWriter->WriteDecorated(aCurrentScriptLine) ; + } + if( (iLoggerChannel == EFile || iLoggerChannel == EBoth) + && (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth)) + { + // Log the current script line to Html result log + HtmlLogger().WriteFormat(KTEFStringFormat,&aCurrentScriptLine); + } + if(iPIPSExists) + { + PIPSLogger().WriteFormat(KTEFStringFormat,&aCurrentScriptLine); + } + } + +LOCAL_C TVerdict SetExpectedResult(TLex aResultValue) + { + TInt expectedResult; + TInt err = aResultValue.Val(expectedResult); + if (err != KErrNone) + { + TBuf tempString(aResultValue.NextToken()); + tempString.UpperCase(); + if (tempString.CompareF(KTEFResultFail) == KTEFZeroValue) + { + expectedResult = EFail; + } + else if(tempString.CompareF(KTEFResultInconclusive) == KTEFZeroValue) + { + expectedResult = EInconclusive; + } + else if(tempString.CompareF(KTEFResultAbort) == KTEFZeroValue) + { + expectedResult = EAbort; + } + else if(tempString.CompareF(KTEFResultPass) == KTEFZeroValue) + { + expectedResult = EPass; + } + else + { + expectedResult = EInconclusive; + } + } + return TVerdict(expectedResult); + } + +/** + * @param aResult - Result of execution of test steps for logging + * @param aPanicString - Reference descriptor containing the panic string if the test step results in a panic + * @param aScriptLineNumber - Line number within the script file where the RUN_TEST_STEP command is available + * @param aCommand - Command name being being executed (RUN_TEST_STEP & variants) + * @param aScriptFile - Name of the script file being used for execution + * @param aSeverity - One of the 4 enum values indicating the severity of the message to be logged + * Responsible for logging results for the RUN_TEST_STEP command/variants + */ +void CTestExecuteLogger::LogResultSerialL(TVerdict aResult, const TDesC& aPanicString, TInt aScriptLineNumber,const TDesC& aCommand,const TDesC& aScriptFile) + { + + HBufC* resultBuffer = HBufC::NewLC(KMaxTestExecuteCommandLength*3); + TPtr ptr(resultBuffer->Des()); + TLex scriptLineLex(aCommand); + TLex scriptLineParamLex(aCommand); + TLex xmlLogCommandParseLex(aCommand); + TPtrC command(scriptLineLex.NextToken()); + TBool showPanicResult(ETrue); + TBool showActualResult(EFalse); + TBool showPanicInfo(EFalse); + TVerdict actualResult(aResult); + TVerdict actualPanic(aResult); + TInt expectedPanicCode(0); + TInt expectedReturnCode(EPass); + TPtrC expectedPanicStringLex(KNull); + TPtrC expectedErrorStringLex(KNull); + + // Newly added variables for implementing !Params for TEF + TVerdict tefResult(EPass); + TBuf tefError(KNull); + TBuf tefPanicString(KNull); + TBuf tefPanicCode(KNull); + TBool paramExistence(EFalse); + TPtrC panicString; + TPtrC errorString; + TPtrC defaultStr(KNull); + /// Start of defect Fix : defect 037262 + + // RUN_TEST_STEP_RESULT + // RUN_PANIC_STEP_RESULT + // + // Check that the expected result meets that of the actual result. + // + // RUN_TEST_STEP_RESULT will return : + // + // PASS if the expected result meets the actual result + // FAIL if expected result was not the same as actual, the actual result is also displayed + // PANIC if the testcode panicked. + // + // RUN_PANIC_STEP_RESULT will return : + // + // PASS if Testcode panicked and expected/actual panic code/ strings match + // PANIC if TestCode panicked but the expected/actual panic code/ strings differ + // FAIL if Testcode did not panic, the actual result is also displayed + // + // RUN_PANIC_STEP will will now return : (for defect 039749) + // PASS if Testcode panicked irrespective of panic code/ strings, the code & strings are displayed + // FAIL if Testcode did not panic, the actual result is also displayed + + if (aPanicString.Length() >= KTEFMinPanicStringLength && aPanicString.Mid(0,KTEFMinPanicStringLength).CompareF(KErrorEquals) == KTEFZeroValue) + { + errorString.Set(aPanicString.Mid(KTEFMinPanicStringLength)); + panicString.Set(KNull); + } + else if (aPanicString.Length() >= KTEFMinPanicStringLength && aPanicString.Mid(0,KTEFMinPanicStringLength).CompareF(KPanicEquals) == KTEFZeroValue) + { + panicString.Set(aPanicString.Mid(KTEFMinPanicStringLength)); + defaultStr.Set(panicString); + errorString.Set(KNull); + } + + if(command == KTEFRunTestStepCommand && aResult!= EIgnore) + { + TInt firstChar; + TPtrC commandStr(scriptLineParamLex.NextToken()); + while(!scriptLineParamLex.Eos()) + { + TInt err(0); + scriptLineParamLex.SkipSpace(); + commandStr.Set(scriptLineParamLex.NextToken()); + firstChar = commandStr[0]; + // 33 is the ascii value for "!". Used here for confirming switches + if (firstChar == KTEFAsciiExclamation) + { + if (commandStr.Length() >= KTEFMinErrorParamLength && commandStr.Mid(0,KTEFMinErrorParamLength).CompareF(KTEFError) == KTEFZeroValue) + { + if(command == KTEFRunTestStepCommand) + { + paramExistence = ETrue; + command.Set(KTEFRunErrorStepResultCommand); + TRAP(err,tefError.Copy(commandStr.Mid(KTEFMinErrorParamLength))); + if (err) + tefError.Copy(KNull); + defaultStr.Set(errorString); + } + } + else if (commandStr.Length() >= KTEFMinResultParamLength && commandStr.Mid(0,KTEFMinResultParamLength).CompareF(KTEFResult) == KTEFZeroValue) + { + if (command == KTEFRunTestStepCommand) + { + paramExistence = ETrue; + command.Set(KTEFRunTestStepResultCommand); + TLex resultVal(commandStr.Mid(KTEFMinResultParamLength)); + tefResult = SetExpectedResult(resultVal); + } + } + else if (commandStr.Length() >= KTEFMinPanicCodeParamLength && commandStr.Mid(0,KTEFMinPanicCodeParamLength).CompareF(KTEFPanicCode) == KTEFZeroValue) + { + if(command == KTEFRunTestStepCommand) + { + paramExistence = ETrue; + command.Set(KTEFRunPanicStepResultCommand); + TRAP(err,tefPanicCode.Copy(commandStr.Mid(KTEFMinPanicCodeParamLength))); + if (err) + tefPanicCode.Copy(KNull); + defaultStr.Set(panicString); + } + else if(command == KTEFRunPanicStepResultCommand && tefPanicString.Length() != KTEFZeroValue) + { + TRAP(err,tefPanicCode.Copy(commandStr.Mid(KTEFMinPanicCodeParamLength))); + if (err) + tefPanicCode.Copy(KNull); + defaultStr.Set(panicString); + } + } + else if (commandStr.Length() >= KTEFMinPanicStringParamLength && commandStr.Mid(0,KTEFMinPanicStringParamLength).CompareF(KTEFPanicString) == KTEFZeroValue) + { + if(command == KTEFRunTestStepCommand) + { + paramExistence = ETrue; + command.Set(KTEFRunPanicStepResultCommand); + TRAP(err,tefPanicString.Copy(commandStr.Mid(KTEFMinPanicStringParamLength))); + if (err) + tefPanicString.Copy(KNull); + else + { + if (tefPanicString.Mid(0,1) == KTEFOpenQuotes) + tefPanicString.Copy(tefPanicString.Mid(1,tefPanicString.Length()-2)); + } + defaultStr.Set(panicString); + } + else if(command == KTEFRunPanicStepResultCommand && tefPanicString.Length() != KTEFZeroValue) + { + TRAP(err,tefPanicString.Copy(commandStr.Mid(KTEFMinPanicStringParamLength))); + if (err) + tefPanicString.Copy(KNull); + else + { + if (tefPanicString.Mid(0,1) == KTEFOpenQuotes) + tefPanicString.Copy(tefPanicString.Mid(1,tefPanicString.Length()-2)); + } + defaultStr.Set(panicString); + } + } + } + else + break; + } + } + + if (aResult!= EIgnore) + { + if ((command == KTEFRunTestStepResultCommand) && (defaultStr.Length() == KTEFZeroValue)) + { + // Pickout the expected returncode value + TLex expectedReturnCodeLex(scriptLineLex.NextToken()); + TInt err; + if (paramExistence) + { + expectedReturnCode = tefResult; + err = 0; + } + else + err = expectedReturnCodeLex.Val(expectedReturnCode); + if (err == KTEFZeroValue) + { + if (expectedReturnCode == aResult) + { + aResult = EPass; + } + else + { + aResult = EFail; + showActualResult = ETrue; + } + } + } + else if (command == KTEFRunPanicStepResultCommand) + { + if (defaultStr.Length()) // we have indeed panicked + { + // Pickout the expected panic code value + // not necessarily 0, 106-110, but any integer value set by test step + TLex expectedPanicCodeLex(scriptLineLex.NextToken()); + //TInt expectedPanicCode; + TInt err; + if (paramExistence) + { + if (tefPanicCode.Length()) + { + TLex PanicCodeLex(tefPanicCode); + err = PanicCodeLex.Val(expectedPanicCode); + } + else + { + expectedPanicCode = aResult; + err = 0; + } + } + else + err = expectedPanicCodeLex.Val(expectedPanicCode); + + if (err == KTEFZeroValue) + { + if (expectedPanicCode == aResult) + { + //TPtrC expectedPanicStringLex; + // Now check ALSO that the panic string is identical. + if (paramExistence) + { + if (tefPanicString.Length()) + expectedPanicStringLex.Set(tefPanicString); + else + expectedPanicStringLex.Set(defaultStr); + } + else + expectedPanicStringLex.Set(scriptLineLex.NextToken()); + if (expectedPanicStringLex == defaultStr) + { + // Pretend its not a Panic + aResult = EPass; + showPanicResult = EFalse; + } + else + { + aResult = EFail; + showPanicInfo = ETrue; + showPanicResult = EFalse; + } + } + else + { + aResult = EFail; + showPanicInfo = ETrue; + showPanicResult = EFalse; + } + } + } + else + { + // we haven't panicked, we were looking for one, so this is a FAIL. + aResult = EFail; + showPanicResult = EFalse; + showActualResult = ETrue; + } + } + else if (command == KTEFRunPanicStepCommand) + { + if (defaultStr.Length()) // we have indeed panicked + { + // Pretend its not a Panic + aResult = EPass; + showPanicInfo = ETrue; + showPanicResult = EFalse; + } + else + { + // we haven't panicked, we were looking for one, so this is a FAIL. + aResult = EFail; + showPanicResult = EFalse; + showActualResult = ETrue; + } + } + else if (command == KTEFRunErrorStepResultCommand && paramExistence) + { + if (defaultStr.Length()) + { + // Pickout the expected returncode value + //TPtrC expectedErrorStringLex; + expectedErrorStringLex.Set(tefError); + + if (expectedErrorStringLex == defaultStr) + { + // Pretend its not Error + aResult = EPass; + showPanicResult = EFalse; + } + else + { + aResult = EFail; + showPanicResult = EFalse; + showPanicInfo = ETrue; + } + } + else + { + // We haven't got any error, so this is a FAIL + aResult = EFail; + showPanicResult = EFalse; + showActualResult = ETrue; + } + } + else if (errorString.Length()) + { + aResult = EFail; + defaultStr.Set(errorString); + showPanicResult = EFalse; + showPanicInfo = ETrue; + } + } + + // End of bulk of defect defect 037262, fix also includes references to showPanicResult below + // allowing expected Panics to show as Passes + printing of actualResult. + ptr.Append(aScriptFile); + _LIT(KLineNumber," Line = %d"); + ptr.AppendFormat(KLineNumber,aScriptLineNumber); + _LIT(KCommand," Command = "); + ptr.Append(KCommand); + ptr.Append(aCommand); + ptr.Trim(); + _LIT(KTEFSpace," "); + ptr.Append(KTEFSpace); + + _LIT(KCode," Code = %d "); + if (showActualResult) + { + _LIT(KActualResult, "Returned: "); + ptr.Append(KActualResult); + if(actualResult == EPass) + ptr.Append(KTEFResultPass); + else if(actualResult == EFail) + ptr.Append(KTEFResultFail); + else if(actualResult == EInconclusive) + ptr.Append(KTEFResultInconclusive); + else if(actualResult == EAbort || aResult == KErrAbort) + ptr.Append(KTEFResultAbort); + else + { + // Log the error code + ptr.Append(KTEFResultUnknown); + ptr.AppendFormat(KCode,(TInt)actualResult); + } + ptr.Append(KTEFSpace); + } + + if (showPanicInfo) + { + if (errorString.Length()) + { + TLex errorValue(defaultStr); + TInt errorInt; + errorValue.Val(errorInt); + ptr.AppendFormat(KCode,(TInt)errorInt); + ptr.Append(KTEFSpace); + } + else + { + ptr.AppendFormat(KCode,(TInt)actualPanic); + ptr.Append(KTEFSpace); + ptr.Append(defaultStr); + ptr.Append(KTEFSpace); + } + } + + ptr.Append(KTEFResultTag); + ptr.Append(KTEFSpaceEquals); + + if ((defaultStr.Length()) && showPanicResult) + { + ptr.Append(KTEFResultPanic); + _LIT(KHyphen," - "); + ptr.Append(KHyphen); + ptr.Append(defaultStr); + ptr.AppendFormat(KCode,(TInt)aResult); + } + else if(aResult == EPass) + ptr.Append(KTEFResultPass); + else if(aResult == EFail) + ptr.Append(KTEFResultFail); + else if(aResult == EInconclusive) + ptr.Append(KTEFResultInconclusive); + else if(aResult == EAbort || aResult == KErrAbort) + ptr.Append(KTEFResultAbort); + else if (aResult == EIgnore) + ptr.Append(KTEFResultUnexecuted); + else + { + // Log the error code + ptr.Append(KTEFResultUnknown); + ptr.AppendFormat(KCode,(TInt)aResult); + } + ptr.Append(KTEFSpace); + + HBufC8* resultBuffer8 = HBufC8::NewLC(ptr.Length()+2); + TPtr8 ptr8(resultBuffer8->Des()); + ptr8.Copy(ptr); + ptr8.Append(KTEFEndOfLine); + + LoggingTestCaseResultToSummaryResultL(iHtmlLogPath,KTEFTestExecuteResultSummaryFile,ptr8); + + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + TInt bytesCopied = 0; + + while(bytesCopied < ptr.Length()) + { + TInt bytesToCopy = ptr.Length() - bytesCopied; + if(bytesToCopy > KMaxTestExecuteLogLineLength) + { + bytesToCopy = KMaxTestExecuteLogLineLength; + } + TPtrC tmp(&ptr[bytesCopied],bytesToCopy); + bytesCopied += bytesToCopy; + iSerialWriter->WriteDecorated(tmp); + } + } + CleanupStack::PopAndDestroy(resultBuffer8); + CleanupStack::PopAndDestroy(resultBuffer); + } + +/** + * @param aResult - Result of execution of test steps for logging + * @param aPanicString - Reference descriptor containing the panic string if the test step results in a panic + * @param aScriptLineNumber - Line number within the script file where the RUN_TEST_STEP command is available + * @param aCommand - Command name being being executed (RUN_TEST_STEP & variants) + * @param aScriptFile - Name of the script file being used for execution + * @param aSeverity - One of the 4 enum values indicating the severity of the message to be logged + * Responsible for logging results for the RUN_TEST_STEP command/variants + */ +void CTestExecuteLogger::LogResultFileL(TVerdict aResult, const TDesC& aPanicString, TInt aScriptLineNumber,const TDesC& aCommand,const TDesC& aScriptFile, TInt aSeverity) + { + HBufC* resultBuffer = HBufC::NewLC(KMaxTestExecuteCommandLength*3); + TPtr ptr(resultBuffer->Des()); + HBufC* simplifiedResultBuf = HBufC::NewLC(KMaxTestExecuteCommandLength*3); + TPtr simplifiedPtr(simplifiedResultBuf->Des()); + TLex scriptLineLex(aCommand); + TLex scriptLineParamLex(aCommand); + TLex xmlLogCommandParseLex(aCommand); + TPtrC command(scriptLineLex.NextToken()); + TBool showPanicResult(ETrue); + TBool showActualResult(EFalse); + TBool showPanicInfo(EFalse); + TBool isARealPanic(EFalse); //PDEF117769 + TVerdict actualResult(aResult); + TVerdict actualPanic(aResult); + TInt expectedPanicCode(0); + TInt expectedReturnCode(EPass); + TPtrC expectedPanicStringLex(KNull); + TPtrC expectedErrorStringLex(KNull); + + // Newly added variables for implementing !Params for TEF + TVerdict tefResult(EPass); + TBuf tefError(KNull); + // using 256 because in script this parameter could be very long + TBuf tefPanicString(KNull); + TBuf tefPanicCode(KNull); + TBool paramExistence(EFalse); + TPtrC panicString; + TPtrC errorString; + TPtrC defaultStr(KNull); + /// Start of defect Fix : defect 037262 + + // RUN_TEST_STEP_RESULT + // RUN_PANIC_STEP_RESULT + // + // Check that the expected result meets that of the actual result. + // + // RUN_TEST_STEP_RESULT will return : + // + // PASS if the expected result meets the actual result + // FAIL if expected result was not the same as actual, the actual result is also displayed + // PANIC if the testcode panicked. + // + // RUN_PANIC_STEP_RESULT will return : + // + // PASS if Testcode panicked and expected/actual panic code/ strings match + // PANIC if TestCode panicked but the expected/actual panic code/ strings differ + // FAIL if Testcode did not panic, the actual result is also displayed + // + // RUN_PANIC_STEP will will now return : (for defect 039749) + // PASS if Testcode panicked irrespective of panic code/ strings, the code & strings are displayed + // FAIL if Testcode did not panic, the actual result is also displayed + + if (aPanicString.Length() >= KTEFMinPanicStringLength && aPanicString.Mid(0,KTEFMinPanicStringLength).CompareF(KErrorEquals) == KTEFZeroValue) + { + errorString.Set(aPanicString.Mid(KTEFMinPanicStringLength)); + panicString.Set(KNull); + } + else if (aPanicString.Length() >= KTEFMinPanicStringLength && aPanicString.Mid(0,KTEFMinPanicStringLength).CompareF(KPanicEquals) == KTEFZeroValue) + { + panicString.Set(aPanicString.Mid(KTEFMinPanicStringLength)); + defaultStr.Set(panicString); + errorString.Set(KNull); + isARealPanic = ETrue;//PDEF117769 + if (panicString.Length() == KTEFMaxPanicStringLength ) + { + //TEF not know whether the panic string is being turncated. + //if received panic string == 16, TEF will give warning info to log. + LogExtra(((TText8*)__FILE__), __LINE__, ESevrWarn, KTEFWarnPanicString ); + } + } + + //PDEF117769 + // the panic code (110) is SAME with define of EIgnore(110) + // When Panic 110 really happens, the defect code will take this situation as EIgnore. + // Solution is get the panic string when panic happens, then compare with expected panic string. + // aPanicString.Length() > 0, when panic really happens. + // So an extra condition at last. + if((command == KTEFRunTestStepCommand || command == KTEFEndTestBlock) && (aResult!= EIgnore || isARealPanic )) + { + TInt firstChar; + TPtrC commandStr(scriptLineParamLex.NextToken()); + while(!scriptLineParamLex.Eos()) + { + TInt err(0); + scriptLineParamLex.SkipSpace(); + commandStr.Set(scriptLineParamLex.NextToken()); + if( commandStr.Length()>0 ) + { + firstChar = commandStr[0]; + // 33 is the ascii value for "!". Used here for confirming switches + if (firstChar == KTEFAsciiExclamation) + { + if (commandStr.Length() >= KTEFMinErrorParamLength && commandStr.Mid(0,KTEFMinErrorParamLength).CompareF(KTEFError) == KTEFZeroValue) + { + if(command == KTEFRunTestStepCommand || command == KTEFEndTestBlock) + { + paramExistence = ETrue; + command.Set(KTEFRunErrorStepResultCommand); + TRAP(err,tefError.Copy(commandStr.Mid(KTEFMinErrorParamLength))); + if (err) + tefError.Copy(KNull); + defaultStr.Set(errorString); + } + } + else if (commandStr.Length() >= KTEFMinResultParamLength && commandStr.Mid(0,KTEFMinResultParamLength).CompareF(KTEFResult) == KTEFZeroValue) + { + if (command == KTEFRunTestStepCommand || command == KTEFEndTestBlock) + { + paramExistence = ETrue; + command.Set(KTEFRunTestStepResultCommand); + TLex resultVal(commandStr.Mid(KTEFMinResultParamLength)); + tefResult = SetExpectedResult(resultVal); + } + } + else if (commandStr.Length() >= KTEFMinPanicCodeParamLength && commandStr.Mid(0,KTEFMinPanicCodeParamLength).CompareF(KTEFPanicCode) == KTEFZeroValue) + { + if(command == KTEFRunTestStepCommand || command == KTEFEndTestBlock) + { + paramExistence = ETrue; + command.Set(KTEFRunPanicStepResultCommand); + TRAP(err,tefPanicCode.Copy(commandStr.Mid(KTEFMinPanicCodeParamLength))); + if (err) + tefPanicCode.Copy(KNull); + defaultStr.Set(panicString); + } + //PDEF117769 + else if( command == KTEFRunPanicStepResultCommand ) + { + TRAP(err,tefPanicCode.Copy(commandStr.Mid(KTEFMinPanicCodeParamLength))); + if (err) + tefPanicCode.Copy(KNull); + defaultStr.Set(panicString); + } + } + else if (commandStr.Length() >= KTEFMinPanicStringParamLength && commandStr.Mid(0,KTEFMinPanicStringParamLength).CompareF(KTEFPanicString) == KTEFZeroValue) + { + if(command == KTEFRunTestStepCommand || command == KTEFEndTestBlock) + { + paramExistence = ETrue; + command.Set(KTEFRunPanicStepResultCommand); + + ParsePaincStringFromScriptCommandLine(commandStr,scriptLineParamLex,tefPanicString); + defaultStr.Set(panicString); + } + //PDEF117769 + else if(command == KTEFRunPanicStepResultCommand) + { + ParsePaincStringFromScriptCommandLine(commandStr,scriptLineParamLex,tefPanicString); + defaultStr.Set(panicString); + } + + // print out the panic string in panic dialog + // this make easier to user check what happened, when panic string compare fail. + if (isARealPanic && tefPanicString.Compare(panicString)) + { + LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, KTEFExpectedPanicString, &tefPanicString); + LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, KTEFReceivedPanicString, &panicString); + } + } + } + } + else + break; + } + } + + //PDEF117769 + // See more detail above + if (aResult!= EIgnore || isARealPanic ) + { + if ((command == KTEFRunTestStepResultCommand) && (defaultStr.Length() == KTEFZeroValue)) + { + // Pickout the expected returncode value + TLex expectedReturnCodeLex(scriptLineLex.NextToken()); + TInt err; + if (paramExistence) + { + expectedReturnCode = tefResult; + err = 0; + } + else + err = expectedReturnCodeLex.Val(expectedReturnCode); + if (err == KTEFZeroValue) + { + if (expectedReturnCode == aResult) + { + aResult = EPass; + } + else + { + aResult = EFail; + showActualResult = ETrue; + } + } + } + else if (command == KTEFRunPanicStepResultCommand) + { + //PDEF117769 start + if ( isARealPanic ) // if panic really happens aPanicString !=0 (or >=2) + // we have indeed panicked + //PDEF117769 end + { + // Pickout the expected panic code value + // not necessarily 0, 106-110, but any integer value set by test step + TLex expectedPanicCodeLex(scriptLineLex.NextToken()); + //TInt expectedPanicCode; + TInt err; + if (paramExistence) + { + if (tefPanicCode.Length()) + { + TLex PanicCodeLex(tefPanicCode); + err = PanicCodeLex.Val(expectedPanicCode); + } + else + { + expectedPanicCode = aResult; + err = 0; + } + } + else + err = expectedPanicCodeLex.Val(expectedPanicCode); + + if (err == KTEFZeroValue) + { + if (expectedPanicCode == aResult) + { + //TPtrC expectedPanicStringLex; + // Now check ALSO that the panic string is identical. + if (paramExistence) + { + if (tefPanicString.Length()) + expectedPanicStringLex.Set(tefPanicString); + else + expectedPanicStringLex.Set(defaultStr); + } + else + { + expectedPanicStringLex.Set(scriptLineLex.NextToken()); + if (expectedPanicStringLex.Left(1) == KTEFOpenQuotes) + { + if (expectedPanicStringLex.Right(1) != KTEFOpenQuotes) + { + TBuf concatPanicString(expectedPanicStringLex.Mid(1,expectedPanicStringLex.Length()-1)); + TBool panicStringCompleted(EFalse); + while(!scriptLineLex.Eos() && !panicStringCompleted) + { + TPtrC panicStringExt(scriptLineLex.NextToken()); + concatPanicString.Append(KTEFSpace); + if(panicStringExt.Right(1) == KTEFOpenQuotes) + { + panicStringCompleted = ETrue; + concatPanicString.Append(panicStringExt.Mid(0, panicStringExt.Length()-1)); + } + else + concatPanicString.Append(panicStringExt); + } + expectedPanicStringLex.Set(concatPanicString); + } + else + expectedPanicStringLex.Set(expectedPanicStringLex.Mid(1,expectedPanicStringLex.Length()-2)); + } + } + //PDEF117769 + if ( (expectedPanicStringLex.Length() == KTEFZeroValue && defaultStr.Length() == KTEFZeroValue ) || expectedPanicStringLex == defaultStr ) + { + // Pretend its not a Panic + aResult = EPass; + showPanicResult = EFalse; + } + else + { + aResult = EFail; + showPanicInfo = ETrue; + showPanicResult = EFalse; + } + } + else + { + aResult = EFail; + showPanicInfo = ETrue; + showPanicResult = EFalse; + } + } + } + else + { + // we haven't panicked, we were looking for one, so this is a FAIL. + aResult = EFail; + showPanicResult = EFalse; + showActualResult = ETrue; + } + } + else if (command == KTEFRunPanicStepCommand) + { + if ( isARealPanic ) // we have indeed panicked + { + // Pretend its not a Panic + aResult = EPass; + showPanicInfo = ETrue; + showPanicResult = EFalse; + } + else + { + // we haven't panicked, we were looking for one, so this is a FAIL. + aResult = EFail; + showPanicResult = EFalse; + showActualResult = ETrue; + } + } + else if (command == KTEFRunErrorStepResultCommand && paramExistence) + { + if (defaultStr.Length()) + { + // Pickout the expected returncode value + //TPtrC expectedErrorStringLex; + expectedErrorStringLex.Set(tefError); + + if (expectedErrorStringLex == defaultStr) + { + // Pretend its not Error + aResult = EPass; + showPanicResult = EFalse; + } + else + { + aResult = EFail; + showPanicResult = EFalse; + showPanicInfo = ETrue; + } + } + else + { + // We haven't got any error, so this is a FAIL + aResult = EFail; + showPanicResult = EFalse; + showActualResult = ETrue; + } + } + else if (errorString.Length()) + { + aResult = EFail; + defaultStr.Set(errorString); + showPanicResult = EFalse; + showPanicInfo = ETrue; + } + } + + // End of bulk of defect defect 037262, fix also includes references to showPanicResult below + // allowing expected Panics to show as Passes + printing of actualResult. + + // Construct result tags for HTML logging + if ((defaultStr.Length()) && showPanicResult) + ptr.Append(KTEFFontBlue); + else if(aResult == EPass) + ptr.Append(KTEFFontGreen); + else if (aResult == EFail) + ptr.Append(KTEFFontRed); + else + ptr.Append(KTEFFontBlue); + ptr.Append(aScriptFile); + _LIT(KLineNumber," Line = %d"); + ptr.AppendFormat(KLineNumber,aScriptLineNumber); + _LIT(KCommand," Command = "); + ptr.Append(KCommand); + ptr.Append(aCommand); + ptr.Trim(); + simplifiedPtr.Append(aCommand); + simplifiedPtr.Trim(); + ptr.Append(KTEFSpace); + simplifiedPtr.Append(KTEFSpace); + + _LIT(KCode," Code = %d "); + + TBuf resultTmpBuf; + resultTmpBuf.Zero(); + if (showActualResult) + { + _LIT(KActualResult, "Returned: "); + resultTmpBuf.Copy(KActualResult); + if(actualResult == EPass) + resultTmpBuf.Append(KTEFResultPass); + else if(actualResult == EFail) + resultTmpBuf.Append(KTEFResultFail); + else if(actualResult == EInconclusive) + resultTmpBuf.Append(KTEFResultInconclusive); + else if(actualResult == EAbort || aResult == KErrAbort) + resultTmpBuf.Append(KTEFResultAbort); + else + { + // Log the error code + resultTmpBuf.Append(KTEFResultUnknown); + resultTmpBuf.AppendFormat(KCode,(TInt)actualResult); + } + resultTmpBuf.Append(KTEFSpace); + } + ptr.Append(resultTmpBuf); + simplifiedPtr.Append(resultTmpBuf); + + if (showPanicInfo) + { + if (errorString.Length()) + { + TLex errorValue(defaultStr); + TInt errorInt; + errorValue.Val(errorInt); + ptr.AppendFormat(KCode,(TInt)errorInt); + ptr.Append(KTEFSpace); + } + else + { + ptr.AppendFormat(KCode,(TInt)actualPanic); + ptr.Append(KTEFSpace); + ptr.Append(defaultStr); + ptr.Append(KTEFSpace); + } + } + + ptr.Append(KTEFResultTag); + simplifiedPtr.Append(KTEFResultTag); + ptr.Append(KTEFSpaceEquals); + simplifiedPtr.Append(KTEFSpaceEquals); + + resultTmpBuf.Zero(); + if ((defaultStr.Length()) && showPanicResult) + { + resultTmpBuf.Append(KTEFResultPanic); + _LIT(KHyphen," - "); + resultTmpBuf.Append(KHyphen); + resultTmpBuf.Append(defaultStr); + resultTmpBuf.AppendFormat(KCode,(TInt)aResult); + } + else if(aResult == EPass) + resultTmpBuf.Append(KTEFResultPass); + else if(aResult == EFail) + resultTmpBuf.Append(KTEFResultFail); + else if(aResult == EInconclusive) + resultTmpBuf.Append(KTEFResultInconclusive); + else if(aResult == EAbort || aResult == KErrAbort) + resultTmpBuf.Append(KTEFResultAbort); + else if (aResult == EIgnore) + resultTmpBuf.Append(KTEFResultUnexecuted); + else + { + // Log the error code + resultTmpBuf.Append(KTEFResultUnknown); + resultTmpBuf.AppendFormat(KCode,(TInt)aResult); + } + ptr.Append(resultTmpBuf); + simplifiedPtr.Append(resultTmpBuf); + + ptr.Append(KTEFSpace); + simplifiedPtr.Append(KTEFSpace); + ptr.Append(KTEFFontEnd); + + HBufC8* resultBuffer8 = HBufC8::NewLC(ptr.Length()+2); + TPtr8 ptr8(resultBuffer8->Des()); + ptr8.Copy(ptr); + ptr8.Append(KTEFEndOfLine); + + // Only log the START_TEST_BLOCK command to the results file if it has failed + // and therefore the END_TEST_BLOCK command may not be logged. + if( 0 != command.Compare(KTEFStartTestBlock) || + (0 == command.Compare(KTEFStartTestBlock) && EPass != aResult) ) + { + LoggingTestCaseResultToSummaryResultL(iHtmlLogPath,KTEFTestExecuteResultSummaryFile,ptr8); + //re-use result buffer + ptr8.Zero(); + ptr8.Copy(simplifiedPtr); + ptr8.Append(KTEFEndOfLine); + LoggingTestCaseResultToSummaryResultL(iHtmlLogPath,KTEFTestExecuteResultSimplifiedSummaryFile,ptr8); + } + + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + TInt bytesCopied = 0; + + while(bytesCopied < ptr.Length()) + { + TInt bytesToCopy = ptr.Length() - bytesCopied; + if(bytesToCopy > KMaxTestExecuteLogLineLength) + { + bytesToCopy = KMaxTestExecuteLogLineLength; + } + TPtrC tmp(&ptr[bytesCopied],bytesToCopy); + bytesCopied += bytesToCopy; + HtmlLogger().Write(tmp); + if(iPIPSExists) + { + PIPSLogger().Write(tmp); + } + } + } + + CleanupStack::PopAndDestroy(resultBuffer8); + CleanupStack::PopAndDestroy(simplifiedResultBuf); + CleanupStack::PopAndDestroy(resultBuffer); + + // Construct tags for XML logging + if (iLoggerOptions == ELogXMLOnly || iLoggerOptions == ELogBoth) + { + _LIT(KTimeout,"TIMEOUT"); + _LIT(KProgramName,"PROGRAMNAME"); + _LIT(KServerName,"SERVERNAME"); + _LIT(KStepName,"TESTSTEPNAME"); + _LIT(KIniFile,"INIFILENAME"); + _LIT(KTEFSection,"SECTIONNAME"); + _LIT(KEResult,"EXPECTEDRESULT"); + _LIT(KAResult,"ACTUALRESULT"); + _LIT(KEPanicCode,"EXPECTEDPANICCODE"); + _LIT(KAPanicCode,"PANICCODE"); + _LIT(KEPanicString,"EXPECTEDPANICSTRING"); + _LIT(KAPanicString,"PANICSTRING"); + _LIT(KEErrorCode,"EXPECTEDERRORCODE"); + _LIT(KAErrorCode,"ERRORCODE"); + _LIT(KHeapSize,"HEAPSIZE"); + _LIT(KMaximumHeapSize,"0x100000"); + + TPtrC panicCodeExpected; + TPtrC panicStringExpected; + + TBuf taskHeapSize(KMaximumHeapSize); + + TBuf fieldName; + TBuf fieldValue; + TBuf8 string1; + TBuf8 string2; + + TPtrC commandName(xmlLogCommandParseLex.NextToken()); // Collect the command name from current script line + + if(commandName == KTEFRunTestStepResultCommand) + { + // Mark the position to the timeout token within the current script line + xmlLogCommandParseLex.NextToken(); + xmlLogCommandParseLex.SkipSpace(); + xmlLogCommandParseLex.Mark(); + } + + else if(commandName == KTEFRunPanicStepResultCommand) + { + // Mark the position to the timeout token within the current script line + // Also retrieve the expected panic code & strings + panicCodeExpected.Set(xmlLogCommandParseLex.NextToken()); + panicStringExpected.Set(xmlLogCommandParseLex.NextToken()); + xmlLogCommandParseLex.SkipSpace(); + xmlLogCommandParseLex.Mark(); + } + else if(commandName == KTEFRunTestStepCommand || commandName == KTEFEndTestBlock || commandName == KTEFStartTestBlock ) + { + // Mark the position to the timeout token within the current script line + // The !TEF parameters are to be neglected if there are any + TInt firstChar; + TPtrC commandStr; + + while(!xmlLogCommandParseLex.Eos()) + { + xmlLogCommandParseLex.SkipSpace(); + xmlLogCommandParseLex.Mark(); + commandStr.Set(xmlLogCommandParseLex.NextToken()); + if( commandStr.Length()>0 ) + { + firstChar = commandStr[0]; + // 33 is the ascii value for "!". Used here for confirming switches + if (firstChar != KTEFAsciiExclamation) + { + break; + } + else + { + if (commandStr.Length() >= KTEFMinHeapParamLength && commandStr.Mid(0,KTEFMinHeapParamLength).CompareF(KTEFHeap) == KTEFZeroValue) + taskHeapSize.Copy(commandStr.Mid(KTEFMinHeapParamLength)); + } + } + else + { + break; + } + } + } + + TLex lexTimeout; + // We need to skip the timeout if it's there. + if(commandName == KTEFRunTestStepCommand || commandName == KTEFStartTestBlock) + lexTimeout=xmlLogCommandParseLex.MarkedToken(); + else + lexTimeout=xmlLogCommandParseLex.NextToken(); + TInt timeout; + TPtrC serverName; + + // Extract the timeout value and server name + if(lexTimeout.Val(timeout) != KErrNone) + { + if (commandName == KTEFRunProgramCommand) + { + serverName.Set(lexTimeout.NextToken()); + } + else + { + // No timeout so use the second token + serverName.Set(xmlLogCommandParseLex.MarkedToken()); + } + const TInt KDefaultTimeoutSeconds=120; + timeout=KDefaultTimeoutSeconds; + } + else + { + // Timeout value there + serverName.Set(xmlLogCommandParseLex.NextToken()); + } + + TBuf timeoutString; + timeoutString.AppendNum(timeout); // Convert the integral timeout to its equivalent string + TPtrC stepName; + if( commandName != KTEFStartTestBlock && commandName != KTEFEndTestBlock ) + { + stepName.Set( xmlLogCommandParseLex.NextToken() ); // Extract the step name + } + TPtrC iniName(xmlLogCommandParseLex.NextToken()); // Extract the ini file name + TPtrC sectionName(xmlLogCommandParseLex.NextToken()); // Extract the section name + + TExtraLogField logField[15]; + TInt index = 0; + + if( commandName != KTEFEndTestBlock ) + { + logField[index].iLogFieldName.Copy(KTimeout); + logField[index].iLogFieldValue.Copy(timeoutString); + index++; + } + + if(commandName == KTEFRunProgramCommand || commandName == KTEFRunWSProgramCommand) + { + logField[index].iLogFieldName.Copy(KProgramName); + logField[index].iLogFieldValue.Copy(serverName); + index++; + } + else if( commandName != KTEFEndTestBlock ) + { + logField[index].iLogFieldName.Copy(KServerName); + logField[index].iLogFieldValue.Copy(serverName); + index++; + } + + if (commandName != KTEFRunProgramCommand && commandName != KTEFRunWSProgramCommand && + commandName != KTEFEndTestBlock && commandName != KTEFStartTestBlock ) + { + logField[index].iLogFieldName.Copy(KStepName); + logField[index].iLogFieldValue.Copy(stepName); + index++; + + logField[index].iLogFieldName.Copy(KTEFSection); + logField[index].iLogFieldValue.Copy(sectionName); + index++; + } + + if (commandName != KTEFRunProgramCommand && commandName != KTEFRunWSProgramCommand && + commandName != KTEFEndTestBlock ) + { + logField[index].iLogFieldName.Copy(KIniFile); + logField[index].iLogFieldValue.Copy(iniName); + index++; + } + + if (commandName == KTEFRunTestStepResultCommand) + { + fieldValue.Copy(KNull); + fieldValue.AppendNum(expectedReturnCode); + logField[index].iLogFieldName.Copy(KEResult); + logField[index].iLogFieldValue.Copy(fieldValue); + index++; + + fieldValue.Copy(KNull); + fieldValue.AppendNum(actualResult); + logField[index].iLogFieldName.Copy(KAResult); + logField[index].iLogFieldValue.Copy(fieldValue); + index++; + } + + if (commandName == KTEFRunPanicStepResultCommand || commandName == KTEFEndTestBlock ) + { + if (defaultStr.Length()) // we have indeed panicked + { + fieldValue.Copy(KNull); + fieldValue.AppendNum(expectedPanicCode); + logField[index].iLogFieldName.Copy(KEPanicCode); + logField[index].iLogFieldValue.Copy(fieldValue); + index++; + + fieldValue.Copy(KNull); + fieldValue.AppendNum(actualPanic); + logField[index].iLogFieldName.Copy(KAPanicCode); + logField[index].iLogFieldValue.Copy(fieldValue); + index++; + + if (expectedPanicCode == actualPanic) + { + fieldValue.Copy(expectedPanicStringLex); + logField[index].iLogFieldName.Copy(KEPanicString); + logField[index].iLogFieldValue.Copy(fieldValue); + index++; + + fieldValue.Copy(defaultStr); + logField[index].iLogFieldName.Copy(KAPanicString); + logField[index].iLogFieldValue.Copy(fieldValue); + index++; + } + } + } + + if (commandName == KTEFRunErrorStepResultCommand) + { + if (errorString.Length()) // Error has occured + { + logField[index].iLogFieldName.Copy(KEErrorCode); + logField[index].iLogFieldValue.Copy(tefError); + index++; + + logField[index].iLogFieldName.Copy(KAErrorCode); + logField[index].iLogFieldValue.Copy(errorString); + index++; + } + } + + logField[index].iLogFieldName.Copy(KHeapSize); + logField[index].iLogFieldValue.Copy(taskHeapSize); + index++; + + if ((defaultStr.Length()) && showPanicResult) + { + logField[index].iLogFieldName.Copy(KTEFResultString); + logField[index].iLogFieldValue.Copy(KTEFResultPanic); + index++; + + _LIT(KTEFPanicString, "PANICSTRING"); + logField[index].iLogFieldName.Copy(KTEFPanicString); + logField[index].iLogFieldValue.Copy(defaultStr); + index++; + + _LIT(KTEFPanicCode, "PANICCODE"); + logField[index].iLogFieldName.Copy(KTEFPanicCode); + logField[index].iLogFieldValue.AppendNum(aResult); + index++; + } + else if(aResult == EPass) + { + logField[index].iLogFieldName.Copy(KTEFResultString); + logField[index].iLogFieldValue.Copy(KTEFResultPass); + index++; + } + else if(aResult == EFail) + { + logField[index].iLogFieldName.Copy(KTEFResultString); + logField[index].iLogFieldValue.Copy(KTEFResultFail); + index++; + } + else if(aResult == EAbort || aResult == KErrAbort) + { + logField[index].iLogFieldName.Copy(KTEFResultString); + logField[index].iLogFieldValue.Copy(KTEFResultAbort); + index++; + } + else if (aResult == EIgnore) + { + logField[index].iLogFieldName.Copy(KTEFResultString); + logField[index].iLogFieldValue.Copy(KTEFResultUnexecuted); + index++; + } + else if(aResult == EInconclusive) + { + logField[index].iLogFieldName.Copy(KTEFResultString); + logField[index].iLogFieldValue.Copy(KTEFResultInconclusive); + index++; + } + else + { + logField[index].iLogFieldName.Copy(KTEFResultString); + TBuf fieldValue(KTEFResultUnknown); + fieldValue.Append(KTEFSpaceEquals); + fieldValue.AppendNum(aResult); + logField[index].iLogFieldValue.Copy(fieldValue); + index++; + } + + // Log the commmand name along with field-value pairs + XmlLogger().Log(((TText8*)__FILE__), aScriptLineNumber, RFileFlogger::TLogSeverity(aSeverity), index, logField, KTEFStringFormat, &commandName); + } + } + +/** + * @param aResult - Result of execution of test steps for logging + * @param aPanicString - Reference descriptor containing the panic string if the test step results in a panic + * @param aScriptLineNumber - Line number within the script file where the RUN_TEST_STEP command is available + * @param aCommand - Command name being being executed (RUN_TEST_STEP & variants) + * @param aScriptFile - Name of the script file being used for execution + * @param aSeverity - One of the 4 enum values indicating the severity of the message to be logged + * Responsible for logging results for the RUN_TEST_STEP command/variants + */ +EXPORT_C void CTestExecuteLogger::LogResult(TVerdict aResult, const TDesC& aPanicString, TInt aScriptLineNumber,const TDesC& aCommand,const TDesC& aScriptFile, TInt aSeverity) + { + if((ESerial == iLoggerChannel) || (EBoth == iLoggerChannel )) + { + TRAP_IGNORE( LogResultSerialL(aResult, aPanicString, aScriptLineNumber,aCommand,aScriptFile) ); + } + if( (EFile == iLoggerChannel ) + || (EBoth== iLoggerChannel ) ) + { + TRAP_IGNORE( LogResultFileL(aResult, aPanicString, aScriptLineNumber,aCommand,aScriptFile, aSeverity) ); + } + } + +EXPORT_C TVerdict CTestExecuteLogger::LogBlock( TTEFItemArray* aItemArray, const TInt aScriptLineNumber ) + { + TVerdict result = EPass; + + // HTML specific block logging + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + result = LogHTMLBlockL( *aItemArray ); + } + + // XML specific block logging + if (iLoggerOptions == ELogXMLOnly || iLoggerOptions == ELogBoth) + { + result = LogXMLBlock( *aItemArray, aScriptLineNumber ); + } + + return result; + } + +TVerdict CTestExecuteLogger::LogHTMLBlockL( const TTEFItemArray& aItemArray ) + { + TVerdict result = EPass; + TInt numCommands = aItemArray.Count(); + + // Iterate through the item array and verify all of the error codes + for( TInt i = 0 ; i blockLine; + + // Log the block command + // Set the correct coolour for the HTML + if( !aItemArray.At(i).iExecuted ) + { + err = EInconclusive; + blockLine += KTEFFontBlue; + } + else if( aItemArray.At(i).iError != aItemArray.At(i).iExpectedError + || aItemArray.At(i).iAsyncError != aItemArray.At(i).iExpectedAsyncError ) + { + err = EFail; + blockLine += KTEFFontRed; + } + else + { + blockLine += KTEFFontGreen; + } + + switch( aItemArray.At(i).iItemType ) + { + case ETEFCreateObject: + { + blockLine += KTEFCreateObject; + blockLine += KTEFSpace; + blockLine += aItemArray.At(i).iObjectType; + blockLine += KTEFSpace; + blockLine += aItemArray.At(i).iSection; + } + break; + case ETEFRestoreObject: + { + blockLine += KTEFRestoreObject; + blockLine += KTEFSpace; + blockLine += aItemArray.At(i).iObjectType; + blockLine += KTEFSpace; + blockLine += aItemArray.At(i).iSection; + } + break; + case ETEFCommand: + { + blockLine += KTEFCommand; + blockLine += KTEFSpace; + blockLine += KTEFError; + blockLine.AppendNum( aItemArray.At(i).iExpectedError ); + blockLine += KTEFSpace; + blockLine += KTEFAsyncError; + blockLine.AppendNum( aItemArray.At(i).iExpectedAsyncError ); + blockLine += KTEFSpace; + blockLine += aItemArray.At(i).iCommand.iObject; + blockLine += KTEFSpace; + blockLine += aItemArray.At(i).iCommand.iFunction; + blockLine += KTEFSpace; + blockLine += aItemArray.At(i).iSection; + } + break; + case ETEFStore: + { + blockLine += KTEFStore; + blockLine += KTEFSpace; + blockLine += aItemArray.At(i).iSection; + } + break; + case ETEFOutstanding: + { + blockLine += KTEFOutstanding; + blockLine += KTEFSpace; + blockLine.AppendNum( aItemArray.At(i).iTime ); + blockLine += KTEFSpace; + blockLine += aItemArray.At(i).iSection; + } + break; + case ETEFDelay: + { + blockLine += KTEFDelay; + blockLine += KTEFSpace; + blockLine.AppendNum( aItemArray.At(i).iTime ); + } + break; + case ETEFAsyncDelay: + { + blockLine += KTEFAsyncDelay; + blockLine += KTEFSpace; + blockLine.AppendNum( aItemArray.At(i).iTime ); + } + break; + case ETEFSharedActiveScheduler: + { + blockLine += KTEFSharedActiveScheduler; + } + break; + case ETEFStoreActiveScheduler: + { + blockLine += KTEFStoreActiveScheduler; + } + break; + + default: + { + blockLine += _L("Bad Command."); + result = EFail; + err = EFail; + } + break; + } + + // Append an extra space for clearer logging. + blockLine += KTEFSpace; + + // Log the block command + if( !aItemArray.At(i).iExecuted ) + { + err = EInconclusive; + // If a command has failed then the overall block has failed + result = EFail; + } + else if( aItemArray.At(i).iError != aItemArray.At(i).iExpectedError + || aItemArray.At(i).iAsyncError != aItemArray.At(i).iExpectedAsyncError ) + { + blockLine += KTEFErrorResult; + blockLine.AppendNum(aItemArray.At(i).iError); + blockLine += KTEFAsyncErrorResult; + blockLine.AppendNum(aItemArray.At(i).iAsyncError); + err = EFail; + // If a command has failed then the overall block has failed + result = EFail; + } + + // Append the result + blockLine += KTEFSpace; + blockLine += KTEFResultTag; + blockLine += KTEFSpace; + blockLine += KTEFEquals; + blockLine += KTEFSpace; + if( EPass == err ) + { + blockLine += KTEFResultPass; + } + else if( EFail == err ) + { + blockLine += KTEFResultFail; + } + else + { + blockLine += KTEFResultInconclusive; + } + + // Terminate the html line + blockLine += KTEFSpace; + blockLine += KTEFFontEnd; + + HBufC8* resultBuffer8 = HBufC8::NewLC(blockLine.Length()+2); + TPtr8 ptr8(resultBuffer8->Des()); + ptr8.Copy(blockLine); + + // Write to the log file + HtmlLogger().Write(ptr8); + if(iPIPSExists) + { + PIPSLogger().Write(ptr8); + } + CleanupStack::PopAndDestroy(resultBuffer8); + } + + return result; + } + +TVerdict CTestExecuteLogger::LogXMLBlock( const TTEFItemArray& aItemArray, const TInt aScriptLineNumber ) + { + TVerdict result = EPass; + TInt numCommands = aItemArray.Count(); + + for( TInt i = 0 ; i command; + + switch( aItemArray.At(i).iItemType ) + { + case ETEFCreateObject: + { + command = KTEFCreateObject; + logField[index].iLogFieldName.Copy(KObjectType); + logField[index].iLogFieldValue.Copy(aItemArray.At(i).iObjectType); + index++; + logField[index].iLogFieldName.Copy(KObjectSection); + logField[index].iLogFieldValue.Copy(aItemArray.At(i).iSection); + index++; + } + break; + case ETEFRestoreObject: + { + command = KTEFRestoreObject; + logField[index].iLogFieldName.Copy(KObjectType); + logField[index].iLogFieldValue.Copy(aItemArray.At(i).iObjectType); + index++; + logField[index].iLogFieldName.Copy(KObjectSection); + logField[index].iLogFieldValue.Copy(aItemArray.At(i).iSection); + index++; + } + break; + case ETEFCommand: + { + command = KTEFCommand; + logField[index].iLogFieldName.Copy(KEErrorCode); + logField[index].iLogFieldValue.AppendNum(aItemArray.At(i).iExpectedError); + index++; + logField[index].iLogFieldName.Copy(KEAsyncErrorCode); + logField[index].iLogFieldValue.AppendNum(aItemArray.At(i).iExpectedAsyncError); + index++; + logField[index].iLogFieldName.Copy(KErrorCode); + logField[index].iLogFieldValue.AppendNum(aItemArray.At(i).iError); + index++; + logField[index].iLogFieldName.Copy(KAsyncErrorCode); + logField[index].iLogFieldValue.AppendNum(aItemArray.At(i).iAsyncError); + index++; + logField[index].iLogFieldName.Copy(KObjectSection); + logField[index].iLogFieldValue.Copy(aItemArray.At(i).iCommand.iObject); + index++; + logField[index].iLogFieldName.Copy(KFunctionName); + logField[index].iLogFieldValue.Copy(aItemArray.At(i).iCommand.iFunction); + index++; + logField[index].iLogFieldName.Copy(KSection); + logField[index].iLogFieldValue.Copy(aItemArray.At(i).iSection); + index++; + } + break; + case ETEFStore: + { + command = KTEFStore; + logField[index].iLogFieldName.Copy(KObjectSection); + logField[index].iLogFieldValue.Copy(aItemArray.At(i).iSection); + index++; + } + break; + case ETEFOutstanding: + { + command = KTEFOutstanding; + logField[index].iLogFieldName.Copy(KInterval); + logField[index].iLogFieldValue.AppendNum(aItemArray.At(i).iTime); + index++; + logField[index].iLogFieldName.Copy(KSection); + logField[index].iLogFieldValue.Copy(aItemArray.At(i).iSection); + index++; + } + break; + case ETEFDelay: + { + command = KTEFDelay; + logField[index].iLogFieldName.Copy(KDelay); + logField[index].iLogFieldValue.AppendNum(aItemArray.At(i).iTime); + index++; + } + break; + case ETEFAsyncDelay: + { + command = KTEFAsyncDelay; + logField[index].iLogFieldName.Copy(KDelay); + logField[index].iLogFieldValue.AppendNum(aItemArray.At(i).iTime); + index++; + } + break; + default: + { + command = KBadCommand; + } + break; + } + + // Set the correct result for the XML + if( !aItemArray.At(i).iExecuted ) + { + logField[index].iLogFieldName.Copy(KTEFResultString); + logField[index].iLogFieldValue.Copy(KTEFResultInconclusive); + index++; + // If a command has failed then the overall block has failed + result = EFail; + } + else if( aItemArray.At(i).iError != aItemArray.At(i).iExpectedError + || aItemArray.At(i).iAsyncError != aItemArray.At(i).iExpectedAsyncError ) + { + logField[index].iLogFieldName.Copy(KTEFResultString); + logField[index].iLogFieldValue.Copy(KTEFResultFail); + index++; + // If a command has failed then the overall block has failed + result = EFail; + } + else + { + logField[index].iLogFieldName.Copy(KTEFResultString); + logField[index].iLogFieldValue.Copy(KTEFResultPass); + index++; + } + + // Call the Xml log client interface for logging into xml log + // Log the commmand name along with field-value pairs + XmlLogger().Log(((TText8*)__FILE__), aScriptLineNumber, RFileFlogger::ESevrHigh, index, logField, KTEFStringFormat, &command); + } + + return result; + } + +/** + * @param aLogMode - Integer descriptor containing either of the 3 enum values + * ELogHTMLOnly(0)/ELogXMLOnly(1)/ELogBoth(2) + * Responsible for setting the logger options for the logger object based on user request + */ +EXPORT_C void CTestExecuteLogger::SetLoggerOptions(TInt aLogMode) + { + iLoggerOptions = TLoggerOptions(aLogMode); + } + +/** + * @param aLogChannel - Integer descriptor containing either of the 3 enum values + * Responsible for setting the logger Channel + */ +EXPORT_C void CTestExecuteLogger::SetLoggerChannel(TInt aLogChannel) + { + iLoggerChannel = aLogChannel ; + } + +/** + * @return - System wide errors + * Connects to the HTML & XML logger client sessions + */ +EXPORT_C TInt CTestExecuteLogger::Connect() + { + TInt err = KErrNone; + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + // Call the Html log client interface for logging into html log + err = HtmlLogger().Connect(); + } + + if ((iLoggerOptions == ELogXMLOnly || iLoggerOptions == ELogBoth) && err == KErrNone) + { + err = XmlLogger().Connect(); + } + + //TRAPD(errPIP, PIPSLogger().Connect()) ; + TInt errPIP = PIPSLogger().Connect() ; + iPIPSExists = (errPIP == KErrNone)? true : false ; + + return err; + } + +/** + * Closes the connection with HTML & XML logger client sessions + */ +EXPORT_C void CTestExecuteLogger::Close() + { + + if(iLoggerChannel == ESerial || iLoggerChannel == EBoth) + { + //iSerialWriter->UnlockResources(); + delete iSerialWriter; + iSerialWriter = NULL; + } + if (iLoggerOptions == ELogHTMLOnly || iLoggerOptions == ELogBoth) + { + // defect 116046 + THandleInfo info; + HtmlLogger().HandleInfo(&info); + if (0 != info.iNumOpenInThread) + { + HtmlLogger().Close(); + } + // END defect 116046 + } + if (iLoggerOptions == ELogXMLOnly || iLoggerOptions == ELogBoth) + { + XmlLogger().Close(); + } + if(iPIPSExists) + { + PIPSLogger().Close(); + } + } + +/** + * Two phase Construction + */ +EXPORT_C CTestExecuteLogger* CTestExecuteLogger::NewL(TLoggerOptions aLogOptions) + { + CTestExecuteLogger* self = CTestExecuteLogger::NewLC(aLogOptions); + CleanupStack::Pop(); + return self; + } + +/** + * Two phase Construction + */ +EXPORT_C CTestExecuteLogger* CTestExecuteLogger::NewLC(TLoggerOptions aLogOptions) + { + CTestExecuteLogger* self = new(ELeave) CTestExecuteLogger(aLogOptions); + CleanupStack::PushL(self); + //self->ConstructL(); //if in future the contructor is expected to do anything. + return self; + } + +////////////////////////////////////////////////////// +// Methods implementation for CTestExecuteIniData used +// For parsing the testexecute.ini +////////////////////////////////////////////////////// + +/** + * Constructor + */ +EXPORT_C CTestExecuteIniData::CTestExecuteIniData() : +iHtmlLogPath(KNull), +iXmlLogPath(KNull), +iDefaultScriptDirectory(KNull), +iLogSeverity(RFileFlogger::ESevrAll), +iLoggerOptions(TLoggerOptions(ELogHTMLOnly)), +iJustInTime(KTEFZeroValue), +iRemotePanicDetection(KTEFZeroValue), +iEnableIniAccessLog(KTEFOneValue), +iEnableTestsCountLog(KTEFOneValue), +iEnableSystemStarter(KTEFOneValue), +iLoggerChannel(TLoggerChannels(EFile)), +iPortNumber(KTEFZeroValue), +iDefaultSysDrive(KTEFLegacySysDrive), +iIniSysDriveName(KTEFIniSysDrive) + { + iConfigData = NULL; + } + +/** + * Two phase Construction + */ +EXPORT_C CTestExecuteIniData* CTestExecuteIniData::NewL() + { + CTestExecuteIniData* self = CTestExecuteIniData::NewLC(); + CleanupStack::Pop(); + return self; + } + +/** + * Two phase Construction + */ +EXPORT_C CTestExecuteIniData* CTestExecuteIniData::NewLC() + { + CTestExecuteIniData* self = new(ELeave) CTestExecuteIniData(); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +EXPORT_C CTestExecuteIniData::CTestExecuteIniData(TDriveName& aSysDrive) : +iHtmlLogPath(KNull), +iXmlLogPath(KNull), +iDefaultScriptDirectory(KNull), +iLogSeverity(RFileFlogger::ESevrAll), +iLoggerOptions(TLoggerOptions(ELogHTMLOnly)), +iJustInTime(KTEFZeroValue), +iRemotePanicDetection(KTEFZeroValue), +iEnableIniAccessLog(KTEFOneValue), +iEnableTestsCountLog(KTEFOneValue), +iEnableSystemStarter(KTEFOneValue), +iLoggerChannel(TLoggerChannels(EFile)), +iPortNumber(KTEFZeroValue), +iDefaultSysDrive(aSysDrive), +iIniSysDriveName(KTEFIniSysDrive) + { + iConfigData = NULL; + } + +/** + * Two phase Construction + */ +EXPORT_C CTestExecuteIniData* CTestExecuteIniData::NewL(TDriveName& aSysDrive) + { + CTestExecuteIniData* self = CTestExecuteIniData::NewLC(aSysDrive); + CleanupStack::Pop(); + return self; + } + +/** + * Two phase Construction + */ +EXPORT_C CTestExecuteIniData* CTestExecuteIniData::NewLC(TDriveName& aSysDrive) + { + CTestExecuteIniData* self = new(ELeave) CTestExecuteIniData(aSysDrive); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +/** + * ConstructL + */ +EXPORT_C void CTestExecuteIniData::ConstructL() + { + TBuf iniDefaultPath(KTEFDefaultPath); + iniDefaultPath.Replace(0, 2, iDefaultSysDrive); + TRAPD(err,iConfigData = CIniData::NewL(iniDefaultPath, iDefaultSysDrive)); + if (err != KErrNone) + { + TRAP(err,iConfigData = CIniData::NewL(KTEFAlternatePath, iDefaultSysDrive)); + if (err != KErrNone) + { + User::Leave(err); + } + } + } + +/** + * Destructor + */ +EXPORT_C CTestExecuteIniData::~CTestExecuteIniData() + { + if (iConfigData != NULL) + { + delete iConfigData; + } + } + +/** + * Extracts the values for all the keys within testexecute.ini + * And stores it into member variables for the class + */ +EXPORT_C void CTestExecuteIniData::ExtractValuesFromIni() + { + TBuf testExecuteLogPath(KTestExecuteLogPath); + testExecuteLogPath.Replace(0, 2, iDefaultSysDrive); + + if (!iConfigData->FindVar(KTEFSection, KTEFHtmlKey, iHtmlLogPath)) + { + iHtmlLogPath.Set(testExecuteLogPath); + } + if (iHtmlLogPath.Compare(KNull) == 0) + { + iHtmlLogPath.Set(testExecuteLogPath); + } + if (!iConfigData->FindVar(KTEFSection, KTEFXmlKey, iXmlLogPath)) + { + iXmlLogPath.Set(testExecuteLogPath); + } + if (iXmlLogPath.Compare(KNull) == 0) + { + iXmlLogPath.Set(testExecuteLogPath); + } + if (!iConfigData->FindVar(KTEFSection, KTEFDefaultSysDrive, iIniSysDriveName)) + { + iIniSysDriveName.Set(KTEFIniSysDrive); + } + TPtrC stringValue; + if (iConfigData->FindVar(KTEFSection, KTEFDefaultScriptPath,stringValue)) + { + iDefaultScriptDirectory.Set(stringValue); + } + TInt intValue = KTEFZeroValue; + if (iConfigData->FindVar(KTEFSection, KTEFJustInTimeDebug,intValue)) + { + iJustInTime = intValue; + } + intValue = KTEFZeroValue; + if (iConfigData->FindVar(KTEFSection, KTEFOutputPort,intValue)) + { + iPortNumber = intValue; + } + + if (!iConfigData->FindVar(KTEFSection, KTEFWaitForLoggingTime, iWaitForLoggingTime)) + { + iWaitForLoggingTime = 5; + } + + if(iConfigData->FindVar(KTEFSection, KTEFLogSeverityKey, stringValue)) + { + _LIT(KBasic,"BASIC"); + _LIT(KMedium,"MEDIUM"); + _LIT(KFull,"FULL"); + if (stringValue.CompareF(KBasic) == 0) + iLogSeverity = RFileFlogger::ESevrHigh; + else if (stringValue.CompareF(KMedium) == 0) + iLogSeverity = RFileFlogger::ESevrMedium; + else if (stringValue.CompareF(KFull) == 0) + iLogSeverity = RFileFlogger::ESevrTEFUnit; + else + iLogSeverity = RFileFlogger::ESevrAll; + } + + stringValue.Set(KNull); + if(iConfigData->FindVar(KTEFSection, KTEFLogMode, stringValue)) + { + _LIT(KLogBoth, "BOTH"); + _LIT(KLogXml, "XML"); + if (stringValue.CompareF(KLogBoth) == 0) + iLoggerOptions = TLoggerOptions(ELogBoth); + else if (stringValue.CompareF(KLogXml) == 0) + iLoggerOptions = TLoggerOptions(ELogXMLOnly); + else + iLoggerOptions = TLoggerOptions(ELogHTMLOnly); + } + + stringValue.Set(KNull); + if(iConfigData->FindVar(KTEFSection, KTEFLogChannel, stringValue)) + { + _LIT(KLogFile, "File"); + _LIT(KLogSerial, "Serial"); + if (stringValue.CompareF(KLogFile) == 0) + iLoggerChannel = TLoggerChannels(EFile); + else if (stringValue.CompareF(KLogSerial) == 0) + iLoggerChannel = TLoggerChannels(ESerial); + else + iLoggerChannel = TLoggerChannels(EBoth); + } + + stringValue.Set(KNull); + if (iConfigData->FindVar(KTEFSection, KTEFRemotePanicDetection, stringValue)) + { + _LIT(KPanicDetectionOn,"ON"); + _LIT(KPanicDetectionOne,"1"); + if (stringValue.CompareF(KPanicDetectionOn) == 0 || stringValue.CompareF(KPanicDetectionOne) == 0) + iRemotePanicDetection = 1; + else + iRemotePanicDetection = 0; + } + + stringValue.Set(KNull); + if (iConfigData->FindVar(KTEFSection, KTEFEnableIniAccessLog, stringValue)) + { + _LIT(KEnableIniAccessLogOff,"OFF"); + _LIT(KEnableIniAccessLogZero,"0"); + if (stringValue.CompareF(KEnableIniAccessLogOff) == 0 || stringValue.CompareF(KEnableIniAccessLogZero) == 0) + iEnableIniAccessLog = 0; + else + iEnableIniAccessLog = 1; + } + + stringValue.Set(KNull); + if (iConfigData->FindVar(KTEFSection, KTEFEnableTestsCountLog, stringValue)) + { + _LIT(KEnableTestsCountLogOff,"OFF"); + _LIT(KEnableTestsCountLogZero,"0"); + if (stringValue.CompareF(KEnableTestsCountLogOff) == 0 || stringValue.CompareF(KEnableTestsCountLogZero) == 0) + iEnableTestsCountLog = 0; + else + iEnableTestsCountLog = 1; + } + + stringValue.Set(KNull); + if (iConfigData->FindVar(KTEFSection, KTEFSystemStarter, stringValue)) + { + _LIT(KEnableSystemStarterOff,"OFF"); + _LIT(KEnableSystemStarterZero,"0"); + if (stringValue.CompareF(KEnableSystemStarterOff) == 0 || stringValue.CompareF(KEnableSystemStarterZero) == 0) + iEnableSystemStarter = 0; + else + iEnableSystemStarter = 1; + } + + } + +/** + * @param aKeyName - Reference to string descriptor containing the name of the key within ini + * @param aValue - Reference to string descriptor to store the value for the key in return + * Copies the value for the key name input to the reference aValue string descriptor passed in + */ +EXPORT_C void CTestExecuteIniData::GetKeyValueFromIni(const TDesC& aKeyName, TDes& aValue) + { + if (aKeyName.Compare(KTEFHtmlKey) == 0) + { + aValue.Copy(iHtmlLogPath); + } + else if (aKeyName.Compare(KTEFXmlKey) == 0) + { + aValue.Copy(iXmlLogPath); + } + else if (aKeyName.Compare(KTEFDefaultScriptPath) == 0) + { + aValue.Copy(iDefaultScriptDirectory); + } + else if (aKeyName.Compare(KTEFDefaultSysDrive) == 0) + { + aValue.Copy(iIniSysDriveName); + } + else + { + aValue.Copy(KNull); + } + } + +/** + * @param aKeyName - Reference to string descriptor containing the name of the key within ini + * @param aValue - Reference to integer descriptor to store the value for the key in return + * Copies the value for the key name input to the reference aValue integer descriptor passed in + */ +EXPORT_C void CTestExecuteIniData::GetKeyValueFromIni(const TDesC& aKeyName, TInt& aValue) + { + if (aKeyName.Compare(KTEFLogSeverityKey) == 0) + { + aValue = iLogSeverity; + } + else if (aKeyName.Compare(KTEFLogMode) == 0) + { + aValue = iLoggerOptions; + } + else if (aKeyName.Compare(KTEFLogChannel) == 0) + { + aValue = iLoggerChannel; + } + else if (aKeyName.Compare(KTEFOutputPort) == 0) + { + aValue = iPortNumber; + } + else if (aKeyName.Compare(KTEFJustInTimeDebug) == 0) + { + aValue = iJustInTime; + } + else if (aKeyName.Compare(KTEFRemotePanicDetection) == 0) + { + aValue = iRemotePanicDetection; + } + else if (aKeyName.Compare(KTEFEnableIniAccessLog) == 0) + { + aValue = iEnableIniAccessLog; + } + else if (aKeyName.Compare(KTEFEnableTestsCountLog) == 0) + { + aValue = iEnableTestsCountLog; + } + else if (aKeyName.Compare(KTEFSystemStarter) == 0) + { + aValue = iEnableSystemStarter; + } + else if (aKeyName.CompareF(KTEFWaitForLoggingTime) == 0) + { + aValue = iWaitForLoggingTime; + } + else + { + aValue = KTEFZeroValue; + } + } + +/** + * @param aCommandStr - Current script command line, this string started form !PanicString. + * @param aScriptLineParamLex - Current script line Lexer. This parameter will be used when exit this function, + * so aScriptLineParamLex must moved to the next parameter. + * @param aTEFPanicString - The parse result . return the string in after !PanicString= . + * EX1: !PanicString=STRING restult is:STRING, return ETrue + * EX2: !PanicString="STRING" restult is:STRING, return ETrue + * EX3: !PanicString="STRING panic" restult is:STRING panic, return ETrue + * EX4: !PanicString=STRING panic restult is:STRING, return EFalse + * EX5: !PanicString="STRING panic restult is:STRING panic, return EFalse + * @return - parse result of the funtion. + * protected: + * This fuction is being added for DEF120600. + */ +TBool CTestExecuteLogger::ParsePaincStringFromScriptCommandLine(const TDesC& aCommandStr,TLex& aScriptLineParamLex,TDes& aTEFPanicString) + { + TInt err(0); + TBool panicStringCompleted(ETrue);// if the string are complexed within "" or just one word, this flag will be ture + TRAP(err,aTEFPanicString.Copy(aCommandStr.Mid(KTEFMinPanicStringParamLength))); + if (err) + { + aTEFPanicString.Copy(KNull); + panicStringCompleted = EFalse; + } + else + { + if (aTEFPanicString.Left(1) == KTEFOpenQuotes) + { + panicStringCompleted = EFalse; + if (aTEFPanicString.Right(1) != KTEFOpenQuotes) + { + aTEFPanicString.Copy(aTEFPanicString.Mid(1,aTEFPanicString.Length()-1)); + while(!aScriptLineParamLex.Eos() && !panicStringCompleted) + { + aScriptLineParamLex.Mark(); + TPtrC spaceBegin( aScriptLineParamLex.RemainderFromMark() ); + TPtrC panicStringExt(aScriptLineParamLex.NextToken()); + TInt span = spaceBegin.Find(panicStringExt); + + // append the white space to the end of the expected panic string + if (aTEFPanicString.MaxLength() >= aTEFPanicString.Length() + span ) + { + aTEFPanicString.Append(spaceBegin.Left(span).Ptr(),span);// append write spaces to the panic string + } + else + { + // this string too large + panicStringCompleted = EFalse; + break; + } + if(panicStringExt.Right(1) == KTEFOpenQuotes) + { + aTEFPanicString.Append(panicStringExt.Mid(0, panicStringExt.Length()-1)); + panicStringCompleted = ETrue; + } + else + { + aTEFPanicString.Append(panicStringExt); + } + } + } + else + { + aTEFPanicString.Copy(aTEFPanicString.Mid(1,aTEFPanicString.Length()-2)); + panicStringCompleted = ETrue; + } + } + if (aTEFPanicString.Length()>KTEFMaxPanicStringLength) + { + // warnning panic string too long + LogExtra(((TText8*)__FILE__), __LINE__, ESevrWarn, KTEFPanicStringTooLong, &KTEFPanicString, &aTEFPanicString ); + LogExtra(((TText8*)__FILE__), __LINE__, ESevrWarn, KTEFPanicStringErrorInfo); + } + } + return panicStringCompleted; + }