static void MainL(void)
/**
Takes a User Prompt Service policy resource file and dumps it as human readable text to the
console. The user may also specify the name of an output file on the command line. If so, text
is also written to this file.
*/
{
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
CConsoleBase* console = Console::NewL(KAppName, TSize(KDefaultConsWidth, KDefaultConsHeight));
CleanupStack::PushL(console);
CCommandLineArguments* args = CCommandLineArguments::NewLC();
if (args->Count() > 1)
{
CPolicyReader* reader = CPolicyReader::NewLC(fs, args->Arg(1));
CPrinter* printer(0);
if (args->Count() > 2)
{
RFile outFile;
User::LeaveIfError(outFile.Replace(fs, args->Arg(2), EFileShareExclusive | EFileWrite));
CleanupClosePushL(outFile);
printer = CPrinter::NewLC(console, outFile);
CleanupStack::Pop(printer);
CleanupStack::PopAndDestroy(&outFile);
CleanupStack::PushL(printer);
}
else
{
printer = CPrinter::NewLC(console);
}
__UHEAP_MARK;
PrintPoliciesL(printer, reader);
__UHEAP_MARKEND;
if (args->Count() < 3)
{
// If no output file is specified then pause after finishing
// because the console will vanish when it is closed.
console->Printf(_L("Press any key to continue\r\n"));
console->Getch();
}
CleanupStack::PopAndDestroy(2, reader); // printer, reader
}
else
{
console->Printf(_L("Usage: dumppolicy.exe policy.rsc <output.txt>\r\n"));
console->Printf(_L("Press any key to continue\r\n"));
console->Getch();
}
CleanupStack::PopAndDestroy(3, &fs); // args, console, fs
}
LOCAL_C void MainL()
{
_LIT(KTitle,"TestExecuteLogger Test Code for serial logging");
CConsoleBase* console = Console::NewL(KTitle,TSize(KConsFullScreen,KConsFullScreen));
CleanupStack::PushL(console);
CTestExecuteLogger logger;
TInt logLevel =1 ;
TBool separateLogFiles(EFalse);
_LIT(KScriptPath,"E:\\plattest\\Selective.script");
TPtrC scriptFilePath(KScriptPath);
console->Write(_L("logger.InitialiseLoggingL next2 \n")) ;
logger.InitialiseLoggingL(scriptFilePath, separateLogFiles, logLevel);
console->Write(_L("post logger.InitialiseLoggingL next \n"));
TestWorkAPIsL(logger, console) ;
console->Write(_L("attempting TerminateLoggingL \n")) ;
logger.TerminateLoggingL(3, 4, 3); //suggested by todays fortune cookie...
console->Write(_L("Done testing, press a key to finish \n")) ;
console->Getch() ;
CleanupStack::PopAndDestroy(console);
}
void CListCommand::ExecuteL(CConsoleBase& aConsole)
{
// Connect to the SCR server
RSoftwareComponentRegistry scr;
TInt err = scr.Connect();
if (err != KErrNone)
{
aConsole.Printf(_L("\nFailed to connect to the SCR server"));
User::Leave(err);
}
CleanupClosePushL(scr);
// Create an SCR view
RSoftwareComponentRegistryView scrView;
scrView.OpenViewL(scr, iFilter);
CleanupClosePushL(scrView);
// Iterate over the matching components
CComponentEntry* entry = CComponentEntry::NewLC();
TBool first(ETrue);
while (scrView.NextComponentL(*entry, iLocale))
{
if (first)
{
first = EFalse;
}
else
{
aConsole.Printf(KTxtPressToContinue);
aConsole.Getch();
aConsole.ClearScreen();
}
aConsole.Printf(_L("\n============= Component Info =============\n"));
aConsole.Printf(_L("\nComponent ID : %d"), entry->ComponentId());
aConsole.Printf(_L("\nComponent name : %S"), &entry->Name());
aConsole.Printf(_L("\nVendor name : %S"), &entry->Vendor());
aConsole.Printf(_L("\nSoftware type : %S"), &entry->SoftwareType());
aConsole.Printf(_L("\nSCOMO state : %S"), entry->ScomoState() == EActivated ? &KTxtActivated : &KTxtDeactivated );
aConsole.Printf(_L("\nComponent size : %d"), entry->ComponentSize());
aConsole.Printf(_L("\nInstalled drives : %S"), &entry->InstalledDrives());
aConsole.Printf(_L("\nVersion : %S"), &entry->Version());
aConsole.Printf(_L("\n\n=========================================\n"));
}
// Disconnect from the SCR server and cleanup the entry
CleanupStack::PopAndDestroy(3, &scr);
}
LOCAL_C void ActiveTestL()
{
CConsoleBase* console = Console::NewL(_L("ACTIVETEST"), TSize(KConsFullScreen, KConsFullScreen));
CleanupStack::PushL(console);
CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
CleanupStack::PushL(scheduler);
CActiveScheduler::Install(scheduler);
CActiveConsole* activeConsole = CActiveConsole::NewLC(*console);
activeConsole->RequestCharacter();
CActiveScheduler::Start();
// NB CActiveScheduler::Start only returns when someone somewhere has
// called CActiveScheduler::Stop.
CleanupStack::PopAndDestroy(2); // activeConsole, scheduler
console->Printf(_L("\nPress any key"));
console->Getch(); // get and ignore character
CleanupStack::PopAndDestroy(); // console
}
LOCAL_C void InitConsoleL()
{
// create a full screen console object
CConsoleBase* console;
console = Console::NewL(KTxtTitle, TSize(KConsFullScreen,KConsFullScreen));
CleanupStack::PushL(console);
//Gets the size of the console
TSize screenSize = console->ScreenSize();
test.Printf(_L("Screen size %d %d\r\n"),screenSize.iWidth,screenSize.iHeight);
// Gets the cursor's x-position
TInt x = console->WhereX();
// Gets the cursor's y-position
TInt y = console->WhereY();
test_Equal(x, 0);
test_Equal(y, 0);
test.Printf(_L("**1** Cursor positions x: %d y: %d\r\n"),x, y);
// Sets the cursor's x-position
for(TInt i=0; i<4; i++)
{
console->SetPos(screenSize.iWidth + i);
x = console->WhereX();
test_Equal(x, screenSize.iWidth -3);
}
test.Printf(_L("**2** Cursor positions x: %d y: %d\r\n"),x, y);
// Clears the console and set cursor to position 0,0
console->ClearScreen();
test_Equal(console->WhereX(), 0);
test_Equal(console->WhereY(), 0);
// Sets the cursor's x-position and y-position
for(TInt j=0; j<4; j++)
{
console->SetPos(screenSize.iWidth - j, screenSize.iHeight - j);
x = console->WhereX();
y = console->WhereY();
test_Equal(x, screenSize.iWidth -3);
test_Equal(y, screenSize.iHeight -3);
}
test.Printf(_L("**3** Cursor positions x: %d y: %d\r\n"),x, y);
console->SetPos(0,0);
x = console->WhereX();
y = console->WhereY();
test_Equal(x, 0);
test_Equal(y, 0);
test.Printf(_L("**4** Cursor positions x: %d y: %d\r\n"),x, y);
console->SetPos(screenSize.iWidth/2,screenSize.iHeight/2);
x = console->WhereX();
y = console->WhereY();
test.Printf(_L("**5** Cursor positions x: %d y: %d\r\n"),x, y);
// Sets the percentage height of the cursor
console->SetCursorHeight(50);
// Gets the current cursor position relative to the console window
TPoint cursorPos = console->CursorPos();
test.Printf(_L("CursorPos iX: %d iY: %d\r\n"),cursorPos.iX, cursorPos.iY);
// Puts the cursor at the specified position relative
// to the current cursor position
TPoint relPos;
relPos.iX = screenSize.iWidth/4;
relPos.iY = screenSize.iHeight/4;
console->SetCursorPosRel(relPos);
cursorPos = console->CursorPos();
test.Printf(_L("CursorPosRel iX: %d iY: %d\r\n"),cursorPos.iX, cursorPos.iY);
// Puts the cursor at the absolute position in the window
cursorPos.iX = screenSize.iWidth/6;
cursorPos.iY = screenSize.iHeight/6;
console->SetCursorPosAbs(cursorPos);
cursorPos = console->CursorPos();
test.Printf(_L("CursorPosAbs iX: %d iY: %d\r\n"),cursorPos.iX, cursorPos.iY);
// Sets a new console title
console->SetTitle(KTxtNewTitle);
// Writes the content of the specified descriptor to the console window
console->Write(KTxtWrite);
cursorPos.iX = cursorPos.iX + 6;
console->SetCursorPosAbs(cursorPos);
// Clears the console from the current cursor position to the end of the line
console->ClearToEndOfLine();
// Clears the console and set cursor to position 0,0
console->ClearScreen();
TUint keyModifiers = console->KeyModifiers();
test.Printf(_L("keyModifiers %d"),keyModifiers);
TKeyCode keyCode = console->KeyCode();
ReadConsole(console);
SimulateKeyPress(EStdKeyEnter);
keyCode = console->Getch();
// cleanup and return
CleanupStack::PopAndDestroy(); // close console
}
void Getch() {
if (cons) cons->Getch();
}
void MainL()
{
/* Create the named - pipe */
int ret_val = mkfifo(HALF_DUPLEX, S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
if ((ret_val == -1) && (errno != EEXIST)) {
perror("Error creating the named pipe");
return ;
//exit (1);
}
int pipe = open(HALF_DUPLEX, O_RDONLY | O_NONBLOCK);
_LIT(KTitle,"TestExecute Standalone Logger Test Code");
CConsoleBase* console = Console::NewL(KTitle,TSize(KConsFullScreen,KConsFullScreen));
CleanupStack::PushL(console);
_LIT(KMessage1,"Connect() To Logger and Close() immediately\r\n");
console->Printf(KMessage1);
RTestExecutePIPSLogServ logger;
User::LeaveIfError(logger.Connect());
logger.Close();
_LIT(KMessage2,"Immediate re-Connect() To Logger and Close() immediately\r\n");
console->Printf(KMessage2);
User::LeaveIfError(logger.Connect());
logger.Close();
_LIT(KMessage3,"Immediate re-Connect() To Logger CreateLog() and Close() immediately\r\n");
console->Printf(KMessage3);
User::LeaveIfError(logger.Connect());
User::LeaveIfError(logger.CreateLog(KLogFile1));
logger.Close();
// OS needs time to shutdown the server
// No delay means we get server terminated from the OS
User::After(1000000);
_LIT(KMessage4,"Connect() To Logger CreateLog() %S Call API's\r\n");
TBuf<80> logFile(KLogFile1);
console->Printf(KMessage4,&logFile);
User::LeaveIfError(logger.Connect());
User::LeaveIfError(logger.CreateLog(KLogFile1));
TBuf<20> buf16(K16BitString);
TBuf8<20> buf8(K8BitString);
logger.Write(K16BitText);
logger.Write(K8BitText);
logger.WriteFormat(K16BitFormatText,16,&buf16);
logger.WriteFormat(K8BitFormatText,8,&buf8);
logger.LogExtra(((TText8*)__FILE__), __LINE__,ESevrInfo,K16BitFormatText,1,&buf16);
_LIT(KMessage5,"ALL API's Called - Call Close(),\r\n");
console->Printf(KMessage5);
//console->Getch();
logger.Close();
//try an empty pipe
_LIT(KLogFileEmpty,"");
_LIT(KMessageEmp,"Connect() To Logger CreateLog() %S Call API's\r\n");
TBuf<80> logFiley(KLogFileEmpty);
console->Printf(KMessageEmp,&logFiley);
User::LeaveIfError(logger.Connect());
User::LeaveIfError(logger.CreateLog(KLogFileEmpty));
logger.Write(K16BitText);
logger.Write(K8BitText);
logger.WriteFormat(K16BitFormatText,16,&buf16);
logger.WriteFormat(K8BitFormatText,8,&buf8);
logger.LogExtra(((TText8*)__FILE__), __LINE__,ESevrInfo,K16BitFormatText,1,&buf16);
console->Printf(KMessage5);
console->Getch();
logger.Close();
CleanupStack::PopAndDestroy(console);
}
/**
* Subroutine performing pre-processing tasks for testexecute execution
* Also, responsible for triggering the state machine through instance of ScriptMaster
* @param aScheduler - Instance of ActiveScheduler created through MainL()
* @param aSysDrive - Default system drive letter to be used for all script parsing
*/
LOCAL_C void ProcessMainL(CActiveScheduler* aScheduler, const TDriveName aSysDrive)
{
TDriveName defaultSysDrive(aSysDrive);
TDriveName testSysDrive(KTEFLegacySysDrive);
TInt waitForLoggingTime = 0;
TBuf<KMaxTestExecuteNameLength> htmlLogPath;
// Create a object of the Parser for TestExecute.ini
CTestExecuteIniData* parseTestExecuteIni = NULL;
TRAPD(err, parseTestExecuteIni = CTestExecuteIniData::NewL(defaultSysDrive));
if (err == KErrNone)
{
CleanupStack::PushL(parseTestExecuteIni);
// Extract all the key values within the object
parseTestExecuteIni->ExtractValuesFromIni();
}
// Read and parse the command line for the flags
// -d -slf -help and -v
TBuf<KMaxTestExecuteCommandLength> commandLine;
TDesC* selTestCfgFileData = NULL; //the pointer to the data of in the .tcs file
ReadCommandLineL(commandLine);
// Make lower case because we parse it for flags and search for ".script"
commandLine.LowerCase();
TBool separateLogFiles(EFalse); // -slf
TBool justInTime(EFalse); // -d
TBool graphicalWindowServer(EFalse); // -gws
TBool helpRequest(EFalse); // -help
TBool versionRequest(EFalse); // -v
TBool includeSelectiveCases(EFalse); // -tci
TBool excludeSelectiveCases(EFalse); // -tcx
TBool pipe(EFalse) ;
// Set up the bools from the command line
ParseCommandLine(commandLine,separateLogFiles,justInTime,graphicalWindowServer,includeSelectiveCases, excludeSelectiveCases,pipe, helpRequest,versionRequest,*parseTestExecuteIni,err);
// If -d then set Just In Time debugging. Panicks break into debug on emulator
(justInTime) ? (User::SetJustInTime(ETrue)) : (User::SetJustInTime(EFalse));
// Hooks for creating the Graphical Window server
#ifdef GWS
#endif
// Create a console
_LIT(KMessage,"TestExecute Script Engine");
CConsoleBase* console = Console::NewL(KMessage,TSize(KConsFullScreen,KConsFullScreen));
CleanupStack::PushL(console);
console->SetCursorHeight(0);
RConsoleLogger consoleLogger(*console);
CScriptControl::iRunScriptFailCount=0;
// A lex for getting the first command line argument, ie the script file path
TLex lex(commandLine);
TPtrC scriptFilePath(lex.NextToken());
TInt ret = KErrNotFound;
if (scriptFilePath.CompareF(KNull) != 0)
{
_LIT(KTEFSwitchPrefix, "-");
if(scriptFilePath.Mid(0,1).CompareF(KTEFSwitchPrefix) == 0)
{
// If the first command line argument is not the script file path but a optional switches
// Then set the script file path for the execution to be 'blank'
scriptFilePath.Set(KNull);
}
else
{
TBuf<KBuffSize> tempScriptPath(scriptFilePath);
// Check whether script name is provided along with folder path in the command line
// If not, take the path from testexecute.ini & name from the command line
ret=scriptFilePath.FindC(KTEFColon);
if(ret==KErrNotFound)
{
if (parseTestExecuteIni != NULL)
{
TBuf<KMaxTestExecuteNameLength> tempBuffer;
parseTestExecuteIni->GetKeyValueFromIni(KTEFDefaultScriptPath, tempBuffer);
// If the relative script file path does not refer to the root,
// we will look for DefaultScriptDir entry in testexecute.ini
// If available prepend it to the relative path
// else if the relative path refers to root,
// then set the default system drive, i.e. c:
// else leaving it as it is (considering invalid path)
if (scriptFilePath.Left(1).CompareF(KTEFSlash) != 0 &&
tempBuffer.Length() > 0)
scriptFilePath.Set(tempBuffer);
else if (scriptFilePath.Left(1).CompareF(KTEFSlash) == 0)
scriptFilePath.Set(defaultSysDrive);
else
scriptFilePath.Set(KNull);
}
else
{
// If the file path is not provided in command line as well as in testexecute.ini
// then set the script file path to be 'blank'
scriptFilePath.Set(KNull);
}
// Construct the full file path from the values extracted from command line and ini file
TBuf<KBuffSize> storeScriptPathTemp(scriptFilePath);
storeScriptPathTemp.Append(tempScriptPath);
scriptFilePath.Set(storeScriptPathTemp);
tempScriptPath.Copy(scriptFilePath);
}
//If scriptFilePath is not appended by .script Append .script
if(scriptFilePath.Find(KTEFScriptExtension)==KErrNotFound)
{
tempScriptPath.Append(KTEFScriptExtension);
}
scriptFilePath.Set(tempScriptPath);
}
}
TPtrC pipeName ;
if(pipe)
{
TLex flagLex(commandLine);
//first of all navigate the command line arguments to the selective test cases flag...
while(!flagLex.Eos())
{
TPtrC token(flagLex.NextToken());
if( (token.CompareF(KTestExecuteCommandLineFlagPipe) == 0) )
{
break;
}
}
pipeName.Set(flagLex.NextToken()) ;
}
TSelectiveTestingOptions* selTestingOptions =NULL;
if (includeSelectiveCases && excludeSelectiveCases)
{
//mutually exclusive options have been encountered
includeSelectiveCases =EFalse;
excludeSelectiveCases =EFalse;
console->Printf(KTEFInvalidCommandSetMessage);
console->Printf(KTEFEnterKeyMessage);
console->Getch();
}
else
{
if(includeSelectiveCases || excludeSelectiveCases)
{
RArray<TRange> selectiveCaseRange;
ParseCommandLineForSelectiveTestingOptions(commandLine,*parseTestExecuteIni,selectiveCaseRange, selTestCfgFileData);
//you need to sort these two arrays first, and also if they are both empty ignore the entire option altogether.
if( selectiveCaseRange.Count() > 0 )
{
CleanupStack::PushL(selTestCfgFileData);
TLinearOrder<TRange> orderingrng(TRange::CompareTRangeStartOrder) ;
selectiveCaseRange.Sort(orderingrng );
ESelectiveTesting selectiveTestingType(iExclusive);
if(includeSelectiveCases)
{
selectiveTestingType = iInclusive ;
}
selTestingOptions = new(ELeave) TSelectiveTestingOptions(selectiveCaseRange, selectiveTestingType);
}
else
{
//if no arguments to this option have been found, ignore it...
includeSelectiveCases =EFalse;
excludeSelectiveCases =EFalse;
delete selTestCfgFileData;
}
}
}
if (scriptFilePath.CompareF(KNull)==0)
{
if (!separateLogFiles && !justInTime)
{
// Print the product version details through console window
console->Printf(KTEFVersionMessage);
console->Printf(KTEFProductVersion);
if (!(versionRequest && !helpRequest))
{
// Print the help & usage informations through console window along with product version
console->Printf(KTEFConsoleHelpMessage1);
console->Printf(KTEFConsoleHelpMessage2);
console->Printf(KTEFConsoleHelpMessage3);
console->Printf(KTEFConsoleHelpMessage4);
console->Printf(KTEFConsoleHelpMessage5);
}
}
else
{
// Display a error message on the console window for invalid set of arguments
console->Printf(KTEFInvalidCommandSetMessage);
}
// Exit on a key press from user
console->Printf(KTEFEnterKeyMessage);
console->Getch();
}
else
{
// Create a Interface class object for generating HTML & XML logs
CTestExecuteLogger *tefLogger = new(ELeave) CTestExecuteLogger();
CleanupStack::PushL(tefLogger);
TInt logMode;
TInt logLevel;
TInt remotePanicDetection;
TBuf<KMaxTestExecuteNameLength> iniSysDrive;
if (parseTestExecuteIni != NULL)
{
// Parse ini for retrieving logging options set through ini
parseTestExecuteIni->GetKeyValueFromIni(KTEFLogMode, logMode);
parseTestExecuteIni->GetKeyValueFromIni(KTEFLogSeverityKey, logLevel);
parseTestExecuteIni->GetKeyValueFromIni(KTEFRemotePanicDetection, remotePanicDetection);
parseTestExecuteIni->GetKeyValueFromIni(KTEFDefaultSysDrive, iniSysDrive);
parseTestExecuteIni->GetKeyValueFromIni(KTEFWaitForLoggingTime, waitForLoggingTime);
parseTestExecuteIni->GetKeyValueFromIni(KTEFHtmlKey, htmlLogPath);
}
else
{
// Set default values for logging options if parser is not functioning
logMode = TLoggerOptions(ELogHTMLOnly);
logLevel = RFileFlogger::TLogSeverity(ESevrAll);
remotePanicDetection = 0;
iniSysDrive.Copy(KTEFIniSysDrive);
waitForLoggingTime = 5;
htmlLogPath.Copy(KTestExecuteLogPath);
htmlLogPath.Replace(0, 2, defaultSysDrive);
}
tefLogger->SetLoggerOptions(logMode);
if(pipe)
{
tefLogger->SetPipeName(pipeName) ;
}
// Initialise the logging passing in the script file path & log level to the interface
tefLogger->InitialiseLoggingL(scriptFilePath, separateLogFiles, logLevel);
// Check to see if defaultsysdrive key is set in testexecute.ini
// if set to SYSDRIVE, assign the default system drive obtained from the plugin
// else, if a true value is set in testexecute.ini, use it as system drive for all test artifacts
if (iniSysDrive.Length() == 2 && iniSysDrive.Right(1).Compare(KTEFColon) == 0)
testSysDrive.Copy(iniSysDrive);
else if (iniSysDrive.CompareF(KTEFIniSysDrive) == 0)
testSysDrive.Copy(defaultSysDrive);
// Pass the first command line argument to the script master
// which is always the command script
CScriptMaster* scriptMaster = new (ELeave) CScriptMaster(scriptFilePath,*tefLogger, consoleLogger, defaultSysDrive, testSysDrive, selTestingOptions);
// To kick the state machine of the script master off -
// Call the kick method which jumps us into the RunL() of the CScriptMaster class
// CScriptMaster is the top AO in the hierarchy.
scriptMaster->Kick();
// Construct and Install a test watcher object for capturing remote panics during test execution
CTestWatcher* testWatcher = NULL;
if (remotePanicDetection != 0)
{
testWatcher = CTestWatcher::NewL();
testWatcher->StartL();
}
// Enter the Active Scheduler
aScheduler->Start();
// Cleanup
delete scriptMaster;
TInt commentedCommandsCnt=CScriptControl::commentedCommandsCount;
if(commentedCommandsCnt==-1)
{
CScriptControl::commentedCommandsCount=0;
//If the path specified fails check out for path from testexecute.ini
if(ret!=KErrNotFound)
{
//To get scriptFile name i.e get sampleFile.script
TInt posOfLastSlash=scriptFilePath.LocateReverse('\\') ;
scriptFilePath.Set(scriptFilePath.Mid(posOfLastSlash+1));
TBuf<KBuffSize> tempStore(scriptFilePath);
if (parseTestExecuteIni != NULL)
{
TBuf<KMaxTestExecuteNameLength> tempBuffer;
parseTestExecuteIni->GetKeyValueFromIni(KTEFDefaultScriptPath, tempBuffer);
if (tempBuffer.CompareF(KNull) != 0)
{
scriptFilePath.Set(tempBuffer);
TBuf<KBuffSize> tempStoreScriptPath(scriptFilePath);
tempStoreScriptPath.Append(tempStore);
scriptFilePath.Set(tempStoreScriptPath);
TBuf<KMaxTestExecuteNameLength> scriptFileLocation(scriptFilePath);
CScriptMaster* scriptMaster = new (ELeave) CScriptMaster(scriptFilePath,*tefLogger, consoleLogger, defaultSysDrive, testSysDrive, selTestingOptions);
// To kick the state machine of the script master off -
// Call the kick method which jumps us into the RunL() of the CScriptMaster class
// CScriptMaster is the top AO in the hierarchy.
scriptMaster->Kick();
// Enter the Active Scheduler
aScheduler->Start();
commentedCommandsCnt=CScriptControl::commentedCommandsCount;
if(commentedCommandsCnt==-1)
{
CScriptControl::commentedCommandsCount=0;
}
// Cleanup
delete scriptMaster;
}
}
}
}
delete selTestingOptions;
TInt commandsCount = CScriptControl::commentedCommandsCount;
TInt countOfRemotePanics = 0;
// Stop and Process the test watcher object for extracting panic informations and print them to the log files
if (remotePanicDetection != 0)
{
testWatcher->Stop();
countOfRemotePanics = testWatcher->iSharedData->iPanicDetails.Count();
if (countOfRemotePanics > 0)
{
tefLogger->LogExtra((TText8*)__FILE__,__LINE__,ESevrErr,
_L("The panic detection thread detected %d panics:"), countOfRemotePanics);
for (TInt count = 0; count < countOfRemotePanics; count++)
tefLogger->LogExtra((TText8*)__FILE__,__LINE__,ESevrErr,_L("Remote Panic %d - Name of Panicked Thread: %S, Exit Reason: %d, Exit Category %S"), count+1, &(testWatcher->iSharedData->iPanicDetails)[count]->iThreadName,(testWatcher->iSharedData->iPanicDetails)[count]->iReason,&(testWatcher->iSharedData->iPanicDetails)[count]->iCategory);
}
delete testWatcher;
}
// Call the Termination routine for logging within the interface
tefLogger->TerminateLoggingL(commandsCount, countOfRemotePanics, CScriptControl::iRunScriptFailCount);
CleanupStack::Pop(tefLogger);
delete tefLogger;
}
if(includeSelectiveCases || excludeSelectiveCases)
{
CleanupStack::PopAndDestroy(selTestCfgFileData);
selTestCfgFileData = NULL;
}
// Close the parser instance if it is active
CleanupStack::PopAndDestroy(console);
if (parseTestExecuteIni != NULL)
{
CleanupStack::PopAndDestroy(parseTestExecuteIni);
}
if (scriptFilePath.CompareF(KNull)!=0)
{
// Wait for flogger to write to file
_LIT(KHtmExtension,".htm");
TParse fileNameParse;
fileNameParse.Set(scriptFilePath, NULL, NULL);
TPtrC fileName = fileNameParse.Name();
htmlLogPath.Append(fileName);
htmlLogPath.Append(KHtmExtension);
#ifdef _DEBUG
RDebug::Print(_L("Log file path--> %S"), &htmlLogPath);
#endif
RFs fs;
fs.Connect();
TBool answer = EFalse;
while(ETrue)
{
TInt err = fs.IsFileOpen(htmlLogPath, answer);
if ((KErrNone==err&&!answer) || KErrNotFound==err || KErrPathNotFound==err)
{
break;
}
User::After(100000);
}
if (waitForLoggingTime > 0)
{
User::After(waitForLoggingTime*1000000);
}
}
}
