diff -r 000000000000 -r 3e07fef1e154 testexecfw/tef/scriptengine/src/testexecute.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testexecfw/tef/scriptengine/src/testexecute.cpp Mon Mar 08 15:03:44 2010 +0800 @@ -0,0 +1,767 @@ +/* +* 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: +* Script Engine executable entry point. +* Log initialisation. +* Command line read. +* Trigger entry into the top level state machine. +* +*/ + + + +/** + @file testexecute.cpp +*/ + +#include +#include "ScriptEngine.h" +#include +#include "TestWatcher.h" +#include "Version.h" +#include "tefutils.h" + +#include +#include + + +const TInt KBuffSize= 500; +GLDEF_D TInt CScriptControl::commentedCommandsCount; +GLDEF_D TInt CScriptControl::iRunScriptFailCount; + +/** + * Code for reading commandline set when testexecute is invoked + * @param aCommandLine - Function fills descriptor with space separated command line args + */ +LOCAL_C void ReadCommandLineL(TDes& aCommandLine) + { + // Far simpler for EKA2 + if(User::CommandLineLength() > aCommandLine.MaxLength()) + User::Leave(KErrTooBig); + User::CommandLine(aCommandLine); + } + +/** + * Function to parse command line and set optional flags with ON/OFF status acordingly + * @param aCommandLine - Command line descriptor with ' ' separated arguments/tokens + * @param aSeparateLogFiles - Function sets to ETrue if -slf is detected in command line + * @param aJustInTime - Function sets to ETrue if -d is detected in command line + * @param aGraphicalWindowServer - Function sets to ETrue if -gws is detected in command line + * @param HelpRequest - Function sets to ETrue if -help is detected in command line + * @param aVersionRequest - Function sets to ETrue if -v is detected in command line + * @param aParseTestExecuteIni - Object of the parser class for checking options set through testexecute.ini + * @param aParserState - TInt value representing whether the parser object instance is active or not + */ +LOCAL_C void ParseCommandLine(const TDesC& aCommandLine,TBool& aSeparateLogFiles,TBool& aJustInTime, +TBool& aGraphicalWindowServer,TBool& aIncludeSelectiveCases,TBool& aExcludeSelectiveCases, TBool& aPipe, TBool& aHelpRequest, TBool& aVersionRequest, +CTestExecuteIniData& aParseTestExecuteIni, TInt& aParserState) + { + // Set up a lex for looping through the command line arguments + TLex flagLex(aCommandLine); + // Initialise all flags to false + aJustInTime = EFalse; + aSeparateLogFiles = EFalse; + aGraphicalWindowServer = EFalse; + aHelpRequest = EFalse; + aVersionRequest = EFalse; + + _LIT(KTestExecuteCommandLineHelp, "-help"); + _LIT(KTestExecuteCommandLineVersion, "-v"); + + while(!flagLex.Eos()) + { + TPtrC token(flagLex.NextToken()); + TInt result = 0; + // Get the value for JustInTimeDebug from the TestExecute.ini parser + if (aParserState == KErrNone) + { + // Get the value from testexecute.ini for optional flag 'JustInTimeDebug' + aParseTestExecuteIni.GetKeyValueFromIni(KTEFJustInTimeDebug, result); + } + const TInt KOne = 1; + if(token == KTestExecuteCommandLineFlagDebugMode || result == KOne) + { + // if the command line contains the token '-d' or the testexecute.ini flag options for JustinTime is set to 'ON' + aJustInTime = ETrue; + } + else if(token == KTestExecuteCommandLineFlagSeparateLogFileMode) + { + // if the command line contains the token '-slf' + aSeparateLogFiles = ETrue; + } + else if(token == KTestExecuteCommandLineFlagIncludeSelectiveCases) + { + // if the command line contains the token '-tci' + aIncludeSelectiveCases= ETrue; + } + else if(token == KTestExecuteCommandLineFlagExcludeSelectiveCases) + { + // if the command line contains the token '-tcx' + aExcludeSelectiveCases= ETrue; + } + else if(token == KTestExecuteCommandLineFlagPipe) + { + aPipe = ETrue ; + } + else if(token == KTestExecuteCommandLineHelp) + { + // if the command line contains the token '-help' + aHelpRequest = ETrue; + } + else if(token == KTestExecuteCommandLineVersion) + { + // if the command line contains the token '-v' + aVersionRequest = ETrue; + } + } + } + +LOCAL_C void DistinguishElement(const TPtrC& aElement, RArray& aSelectiveCaseRange) +{ + + TInt colonOccurance = aElement.FindC(KTEFColon); + //we are expecting only a range or a test case ID over here... + if( colonOccurance!=KErrNotFound ) + { + //then this is a range of testcases, split it at the colon + TRange newRange(aElement.Left(colonOccurance),aElement.Mid(colonOccurance+1)); + aSelectiveCaseRange.Append(newRange); + } + else + { + TRange newRange(aElement,aElement); + aSelectiveCaseRange.Append(newRange); + } +} + +/** + * Read the Cfg File data into a heap buffer + * And populate the arrays of selective test case IDs and + * Ranges to be used by the state machine + * NOTE: we do not support nested cfgs... + */ +LOCAL_C void CreateCfgDataFromFileL(TPtrC& aCfgFilePath,RArray& aSelectiveCaseRange, TDesC*& aSelTestCfgFileData) + { + + RFs fS; + User::LeaveIfError(fS.Connect()); + CleanupClosePushL(fS); + RFile cfgFile; + User::LeaveIfError(cfgFile.Open(fS,aCfgFilePath,EFileRead | EFileShareAny)); + CleanupClosePushL(cfgFile); + TInt fileSize; + User::LeaveIfError(cfgFile.Size(fileSize)); + // Create a 16bit heap buffer + HBufC* cfgData = HBufC::NewL(fileSize); + CleanupStack::PushL(cfgData); + HBufC8* narrowData = HBufC8::NewL(fileSize); + CleanupStack::PushL(narrowData); + TPtr8 narrowPtr=narrowData->Des(); + // Read the file into an 8bit heap buffer + User::LeaveIfError(cfgFile.Read(narrowPtr)); + TPtr widePtr(cfgData->Des()); + // Copy it to the 16bit buffer + widePtr.Copy(narrowData->Des()); + CleanupStack::PopAndDestroy(narrowData); + CleanupStack::Pop(cfgData); + CleanupStack::Pop(2); + cfgFile.Close(); + fS.Close(); + // Set up the instance token parser + TLex cfgLex = cfgData->Des(); + aSelTestCfgFileData = cfgData; // to preserve the pointer of cfgdata and transfer the ownership to aSelTestCfgFileData + cfgData = NULL; // relinquish the ownership + while(!cfgLex.Eos()) + { + DistinguishElement(cfgLex.NextToken(),aSelectiveCaseRange) ; + } + + } + + + +LOCAL_C void ParseCommandLineForSelectiveTestingOptions(const TDesC& aCommandLine,CTestExecuteIniData& aParseTestExecuteIni,RArray& aSelectiveCaseRange, TDesC*& aSelTestCfgFileData) + { + TLex flagLex(aCommandLine); + //first of all navigate the command line arguments to the selective test cases flag... + while(!flagLex.Eos()) + { + TPtrC token(flagLex.NextToken()); + if( (token.CompareF(KTestExecuteCommandLineFlagIncludeSelectiveCases) == 0) || (token.CompareF(KTestExecuteCommandLineFlagExcludeSelectiveCases) == 0) ) + { + break; + } + } + + TPtrC argument(flagLex.NextToken()) ; + while(argument.Length() > 0 ) + { + TInt commaOccurance = argument.FindC(KTEFComma) ; + TPtrC element ; + if(commaOccurance == -1) + { + //handle the case where no comma is found, + //assume only one item in the list + element.Set(argument) ; + //reset argument to break the while + argument.Set(KNull); + } + else + { + element.Set(argument.Left(commaOccurance)); + //take the remaining in the argument + TInt len = argument.Length()-commaOccurance-1 ; + argument.Set(argument.Right(len)) ; + } + + TInt cfgExtensionOccurance = element.FindC(KTEFCfgExtension) ; + if (cfgExtensionOccurance!=KErrNotFound) //madatory extension to be given + { + + TPtrC cfgFilePath(element); + //its probably the cfg file path. + TBuf tempScriptPath(cfgFilePath); + // Check whether cfg name is provided along with folder path in the command line + // If not, take the path from testexecute.ini & name from the command line + if(cfgFilePath.FindC(KTEFColon)==KErrNotFound) + { + TBuf tempBuffer; + aParseTestExecuteIni.GetKeyValueFromIni(KTEFDefaultScriptPath, tempBuffer); + cfgFilePath.Set(tempBuffer); + // Construct the full file path from the values extracted from command line and ini file + TBuf storeScriptPathTemp(cfgFilePath); + storeScriptPathTemp.Append(tempScriptPath); + cfgFilePath.Set(storeScriptPathTemp); + tempScriptPath.Copy(cfgFilePath); + } + // and parse this cfg File to populate our structures + TRAP_IGNORE(CreateCfgDataFromFileL(cfgFilePath,aSelectiveCaseRange, aSelTestCfgFileData)); + //actually do nothing with the error... + } + else + { + DistinguishElement(element,aSelectiveCaseRange ); + } + } + } + +/** + * 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 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 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 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 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 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 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 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 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 tempStore(scriptFilePath); + if (parseTestExecuteIni != NULL) + { + TBuf tempBuffer; + parseTestExecuteIni->GetKeyValueFromIni(KTEFDefaultScriptPath, tempBuffer); + if (tempBuffer.CompareF(KNull) != 0) + { + scriptFilePath.Set(tempBuffer); + TBuf tempStoreScriptPath(scriptFilePath); + tempStoreScriptPath.Append(tempStore); + scriptFilePath.Set(tempStoreScriptPath); + TBuf 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); + } + } + } + +/** + * Top level function inside the TRAP harness + * TEF system calls for: + * Active scheduler initialisation + * Command line read and parse + * Console creation + * Logging Initialisation + * Entry to script engine + * Logging termination + * @param aSysDrive - Default system drive letter to be used for all script parsing + */ +LOCAL_C void MainL(const TDriveName aSysDrive) + { +#if (defined __DATA_CAGING__) + // Platform security hooks + RProcess().DataCaging(RProcess::EDataCagingOn); + RProcess().SecureApi(RProcess::ESecureApiOn); +#endif + CActiveScheduler* sched = new (ELeave) CActiveScheduler(); + CleanupStack::PushL(sched); + CActiveScheduler::Install(sched); + + // Call up the subroutine to perform pre-processing tasks and to start test execution + ProcessMainL(sched, aSysDrive); + + // Cleanup the scheduler object + CleanupStack::PopAndDestroy(sched); + } + +#if !(defined TEF_LITE) +LOCAL_C void StartSystemL() + { + CActiveScheduler* theScheduler = new (ELeave) CActiveScheduler(); + CleanupStack::PushL(theScheduler); + CActiveScheduler::Install(theScheduler); + + RLibrary pluginLibrary; + CWrapperUtilsPlugin* plugin = TEFUtils::WrapperPluginNew(pluginLibrary); + + if (plugin!=NULL) + { + plugin->WaitForSystemStartL(); + delete plugin; + pluginLibrary.Close(); + } + else + { + User::Leave(KErrGeneral); + } + + CleanupStack::PopAndDestroy(theScheduler); + } +#endif + +/** + * Executable Entry Point + * Top level always creates TRAP harness. + * Calls MainL() inside the TRAP harness + */ +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + CTrapCleanup* cleanup = CTrapCleanup::New(); + if(cleanup == NULL) + { + return KErrNoMemory; + } + + // Fix PDEF124952, set the priority EPriorityAbsoluteHigh. In this case, the timeout will + // take effect even if the server executes with almost 100% CPU usage. + RThread().SetPriority(EPriorityAbsoluteHigh); + // End PDEF124952 + + // 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); + + RLibrary pluginLibrary; + CWrapperUtilsPlugin* plugin = TEFUtils::WrapperPluginNew(pluginLibrary); + + if (plugin!=NULL) + { + TDriveUnit driveUnit(plugin->GetSystemDrive()); + defaultSysDrive.Copy(driveUnit.Name()); + delete plugin; + pluginLibrary.Close(); + } + + TBool enableSysStart = ETrue; + CTestExecuteIniData* iniData = NULL; + TRAPD(err, iniData = CTestExecuteIniData::NewL(defaultSysDrive)); + if (err == KErrNone) + { + // Extract all the key values within the object + iniData->ExtractValuesFromIni(); + iniData->GetKeyValueFromIni(KTEFSystemStarter, enableSysStart); + } + + err = KErrNone; + #if !(defined TEF_LITE) + if (enableSysStart) + { + TRAP(err, StartSystemL()); + __ASSERT_ALWAYS(!err, User::Panic(KTestExecuteName,err)); + } + #endif + if (iniData != NULL) + { + delete iniData; + } + + err = KErrNone; + TRAP(err,MainL(defaultSysDrive)); + __ASSERT_ALWAYS(!err, User::Panic(KTestExecuteName,err)); + delete cleanup; + __UHEAP_MARKEND; + return KErrNone; + } +