// ----------------------------------------------------------------------------- // SortSortingItemsL // Select correct sortign operation // ----------------------------------------------------------------------------- // void SortSortingItemsL( RArray<TCLFSortingItem>& aItemArray, TCLFItemDataType aSortingDataType ) { TLinearOrder<TCLFSortingItem>* sorter = NULL; switch ( aSortingDataType ) { case ECLFItemDataTypeDesC: { sorter = new ( ELeave ) TLinearOrder<TCLFSortingItem> ( CompareAlphaAscending ); break; } case ECLFItemDataTypeTInt32: { sorter = new ( ELeave ) TLinearOrder<TCLFSortingItem> ( CompareIntAscending ); break; } case ECLFItemDataTypeTTime: default: { sorter = new ( ELeave ) TLinearOrder<TCLFSortingItem> ( CompareTimeAscending ); break; } } aItemArray.Sort( *sorter ); delete sorter; sorter = NULL; }
// ------------------------------------------------ // PostProcessL // ------------------------------------------------ // void CMdSFindSequence::PostProcessL( CMdCSerializationBuffer& aSerializedResultBuffer ) { #ifdef _DEBUG _LIT( KFindFunctionName, "CMdSFindSequence::PostProcessL" ); #endif // process only on items result if (!iLastResultModeItems) { return; } if(iFindOperation && iFindOperation->FindCriteria().IncludesFreetexts() == EFalse ) { return; } if (!iFindOperation) { return; } RPointerArray<HBufC>& searchFreeText = iFindOperation->QueryFreeText(); // to through every object and check freetext aSerializedResultBuffer.PositionL( KNoOffset ); const TMdCItems& items = TMdCItems::GetFromBufferL( aSerializedResultBuffer ); const TBool needToSort = searchFreeText.Count() != 0 && items.iObjects.iPtr.iCount > 1; RArray<TObjectHitCount> hitCountArray; CleanupClosePushL( hitCountArray ); TObjectHitCount hitCount; for( TUint32 i = 0; i < items.iObjects.iPtr.iCount; ++i ) { aSerializedResultBuffer.PositionL( items.iObjects.iPtr.iOffset + i * sizeof(TMdCObject) ); const TMdCObject& object = TMdCObject::GetFromBufferL( aSerializedResultBuffer ); // check all objects // jump to freetext if ( object.iFreeTexts.iPtr.iCount == 0 ) { continue; } CDesC16ArrayFlat* resultWordBuffer = new(ELeave) CDesC16ArrayFlat( object.iFreeTexts.iPtr.iCount ); CleanupStack::PushL( resultWordBuffer ); // get freetext for object GetFreeTextForObjectL( *resultWordBuffer, items.iNamespaceDefId, object.iId ); __ASSERT_DEBUG( object.iFreeTexts.iPtr.iCount == resultWordBuffer->Count(), User::Panic( KFindFunctionName, KErrCorrupt) ); if (needToSort) { hitCount.iObjectOffset = items.iObjects.iPtr.iOffset + i * sizeof(TMdCObject); hitCount.iCount = GetFreeTextHitCountL( *resultWordBuffer, searchFreeText ); hitCountArray.AppendL( hitCount ); } aSerializedResultBuffer.PositionL( object.iFreeTexts.iPtr.iOffset ); for ( TUint32 f = 0; f < object.iFreeTexts.iPtr.iCount; ++f ) { // insert freeText here TPtrC16 word = (*resultWordBuffer)[f]; aSerializedResultBuffer.InsertL( word ); } CleanupStack::PopAndDestroy( resultWordBuffer ); } if ( needToSort && hitCountArray.Count() > 1 ) { hitCountArray.Sort( TLinearOrder<TObjectHitCount>( SortValues ) ); RArray<TMdCObject> objectArray; CleanupClosePushL( objectArray ); objectArray.ReserveL( items.iObjects.iPtr.iCount ); // store objects in array in correct order for( TInt i = 0; i < items.iObjects.iPtr.iCount; ++i ) { aSerializedResultBuffer.PositionL( hitCountArray[i].iObjectOffset ); const TMdCObject& object = TMdCObject::GetFromBufferL( aSerializedResultBuffer ); objectArray.AppendL( object ); } // set them back in serialized buffer aSerializedResultBuffer.PositionL( items.iObjects.iPtr.iOffset ); for (TInt i = 0; i < items.iObjects.iPtr.iCount; ++i) { objectArray[i].SerializeL( aSerializedResultBuffer ); } CleanupStack::PopAndDestroy( &objectArray ); } CleanupStack::PopAndDestroy( &hitCountArray ); }
void CMemoryView::Sort() { iChunkList.Sort(*iCurrentSortType); }
void CMainView::SelectApps(TDes& aTitle) { TInt sel=0; TInt def=0; TBuf<255> result; CDesCArray* itemList = new (ELeave) CDesCArrayFlat(3); CArrayFixFlat<TInt>* DefaultSelectedItemsList=new (ELeave) CArrayFixFlat<TInt>(3); TInt i=0; RApaLsSession AppSession; AppSession.Connect(); RArray<TApplicationInfo> apps; TApaAppInfo appInfo; AppSession.GetAllApps(); TBuf<255> UidTxt; while (AppSession.GetNextApp(appInfo)==KErrNone) { if (appInfo.iCaption.Length()<2){continue;} TApplicationInfo info; info.iCaption=appInfo.iCaption; info.iUid=appInfo.iUid; apps.Append(info); } AppSession.Close(); TLinearOrder<TApplicationInfo> sortOrder(TApplicationInfo::Compare); apps.Sort(sortOrder); for (TInt i=0;i<apps.Count();i++) { TBuf<255> item; item.Copy(_L("\t")); item.Append(apps[i].iCaption); if (((CTopBatteryAppUi*)AppUi())->iApps.Find(apps[i].iUid)!=KErrNotFound){DefaultSelectedItemsList->AppendL(i);} item.Append(_L(" [")); UidTxt.Num((TUint)apps[i].iUid.iUid,EHex); UidTxt.UpperCase(); item.Append(UidTxt); item.Append(_L("]")); item.Append(_L("\t")); itemList->AppendL(item); } CAknMarkableListDialog* dlg=CAknMarkableListDialog::NewL(sel,DefaultSelectedItemsList,itemList,R_AVKON_DIALOG_EMPTY_MENUBAR); dlg->PrepareLC(R_TXT_UID_SELECTION_LIST); dlg->SetTitleL(aTitle); ((CEikListBox*)dlg->Control(ESelectionListControl))->SetSelectionIndexesL(DefaultSelectedItemsList); ((CAknSingleStyleListBox*)dlg->Control(ESelectionListControl))->ItemDrawer()->ColumnData()->EnableMarqueeL(ETrue); TInt popupOk=dlg->RunLD(); if (!popupOk) { return; } else { i=0; ((CTopBatteryAppUi*)AppUi())->iApps.Reset(); for (i=0; i<DefaultSelectedItemsList->Count(); i++) { TUint uid=apps[DefaultSelectedItemsList->At(i)].iUid.iUid; ((CTopBatteryAppUi*)AppUi())->iApps.Append(TUid::Uid(uid)); } } }
/** * 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); } } }