// -----------------------------------------------------------------------------
// 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 );
    }
Example #3
0
void CMemoryView::Sort()
{
    iChunkList.Sort(*iCurrentSortType);
}
Example #4
0
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));
			}
		}
	}
Example #5
0
/**
 * 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);
			}
		}
	}