diff -r 5cc91383ab1e -r 7333d7932ef7 installationservices/swcomponentregistry/test/tscr/source/subsessionsteps.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swcomponentregistry/test/tscr/source/subsessionsteps.cpp	Tue Aug 31 15:21:33 2010 +0300
@@ -0,0 +1,505 @@
+/*
+* Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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: 
+* Implements test steps for the subsessions interfaces in the SCR
+*
+*/
+
+
+#include "subsessionsteps.h"
+#include <scs/cleanuputils.h>
+#include "tscrdefs.h"
+
+using namespace Usif;
+
+TBool IsEqual(const CComponentEntry& aLhsEntry, const CComponentEntry& aRhsEntry)
+	{
+	return (aLhsEntry == aRhsEntry);
+	}
+
+TBool operator ==(const Usif::TAppRegInfo& aLhsEntry, const Usif::TAppRegInfo& aRhsEntry)
+    {
+    return (aLhsEntry.Uid() == aRhsEntry.Uid() && 
+            aLhsEntry.FullName() == aRhsEntry.FullName() &&  
+            aLhsEntry.Caption() == aRhsEntry.Caption() &&  
+            aLhsEntry.ShortCaption() == aRhsEntry.ShortCaption());
+    }
+TBool operator !=(const TAppRegInfo& aLhsEntry, const TAppRegInfo& aRhsEntry)
+    {
+    return !operator ==(aLhsEntry, aRhsEntry);
+    }
+
+TBool IsEqual(const TAppRegInfo& aLhsEntry, const TAppRegInfo& aRhsEntry)
+    {
+    return (aLhsEntry == aRhsEntry);
+    }
+
+
+TBool IsEqual(const HBufC& aLhs, const HBufC& aRhs)
+	{
+	return const_cast<HBufC &>(aLhs).Des() == const_cast<HBufC &>(aRhs).Des();
+	}
+
+template <class T> TBool VerifyMatchingL(const T* aObj, RPointerArray<T>& aExpectedArray)
+	{
+	TInt pos = aExpectedArray.Find(aObj, IsEqual);
+	if (pos != KErrNotFound)
+		{
+		T* foundObj = aExpectedArray[pos];
+		delete foundObj;
+		aExpectedArray.Remove(pos);
+		return ETrue;
+		}
+	return EFalse;
+	}
+
+
+// -----------CScrGetComponentStep-----------------
+
+CScrComponentRegistrySubsessionStep::CScrComponentRegistrySubsessionStep(CScrTestServer& aParent)	: CScrTestStep(aParent)
+	{
+	}
+
+void CScrComponentRegistrySubsessionStep::ImplTestStepPreambleL()
+	{
+	CScrTestStep::ImplTestStepPreambleL();
+	}
+
+void CScrComponentRegistrySubsessionStep::GetComponentEntriesFromConfigL(RPointerArray<CComponentEntry>& aEntries)
+	{
+	TInt componentsCount(0);
+	if (!GetIntFromConfig(ConfigSection(), KComponentsCountName, componentsCount))
+		{
+		CComponentEntry *componentEntry = GetComponentEntryFromConfigLC();
+		aEntries.AppendL(componentEntry);
+		CleanupStack::Pop(componentEntry);
+		}
+	
+	for (TInt i = 0; i < componentsCount; ++i)
+		{
+		CComponentEntry *componentEntry = GetComponentEntryFromConfigLC(EFalse,i);
+		aEntries.AppendL(componentEntry);
+		CleanupStack::Pop(componentEntry);
+		}
+	}
+
+void CScrComponentRegistrySubsessionStep::VerifyNonReturnedEntriesL(const RPointerArray<CComponentEntry>& aExpectedEntries)
+	{
+	// Check if we need to verify the returned components
+	// Performance tests don't need verification.
+	TBool noVerification = EFalse;
+	GetBoolFromConfig(ConfigSection(), _L("NoVerification"), noVerification);
+	if(noVerification) return;
+
+	if (aExpectedEntries.Count() > 0)
+		{
+		TComponentId componentId = aExpectedEntries[0]->ComponentId(); 
+		const TDesC& componentName = aExpectedEntries[0]->Name();
+		ERR_PRINTF3(_L("At least one expected entry was not returned by the API - id %d, name %S"), componentId, &componentName);
+		SetTestStepResult(EFail);
+		}	
+	}
+
+void CScrComponentRegistrySubsessionStep::TestSingleModeL(const RSoftwareComponentRegistryView& aSubSession, RPointerArray<CComponentEntry>& aExpectedEntries)
+	{
+	// Check if we need to verify the returned components
+	// Performance tests don't need verification. Because the impact verification on performance results.
+	// In addition, we cannot simply verify some test cases such as retrieving all components or removable components. 
+	// Because, the perforamce test databases are populated with random data, and in the future we cannot guarantee 
+	// the values will stay same if the databases are recreated.
+	
+	TBool noVerification = EFalse;
+	GetBoolFromConfig(ConfigSection(), _L("NoVerification"), noVerification);
+
+	// Read continuously entries from the sub-session
+	while (1)
+		{
+		CComponentEntry* componentEntry = aSubSession.NextComponentL();
+		if (componentEntry == NULL)
+			break; // No more entries were found
+		CleanupStack::PushL(componentEntry);
+		
+		if(noVerification)
+			{
+			CleanupStack::PopAndDestroy(componentEntry);
+			continue;
+			}
+		// For each entry, check whether it was found in the expected array.
+		// If found, delete it from the expected array. If not, fail the test step
+		if (!VerifyMatchingL(componentEntry, aExpectedEntries))
+			{
+			ERR_PRINTF2(_L("The API returned an unexpected entry with id %d"), componentEntry->ComponentId());
+			SetTestStepResult(EFail);		
+			CleanupStack::PopAndDestroy(componentEntry);
+			return;
+			}
+				
+		CleanupStack::PopAndDestroy(componentEntry);
+		}
+			
+	// At the end, check whether there were expected entries which were not found
+	VerifyNonReturnedEntriesL(aExpectedEntries);
+	}
+
+void CScrComponentRegistrySubsessionStep::TestSetModeL(const RSoftwareComponentRegistryView& aSubSession, TInt aSetSize, RPointerArray<CComponentEntry>& aExpectedEntries)
+	{
+	// Check if we need to verify the returned components
+	// Performance tests don't need verification. See TestSingleModeL for more information.
+	TBool noVerification = EFalse;
+	GetBoolFromConfig(ConfigSection(), _L("NoVerification"), noVerification);
+
+	while (1)
+		{
+		RPointerArray<CComponentEntry> componentSet;
+		CleanupResetAndDestroyPushL(componentSet);
+		
+		aSubSession.NextComponentSetL(aSetSize, componentSet);
+		TInt returnedComponentsCount = componentSet.Count(); 
+		if (returnedComponentsCount <= 0)
+			{
+			CleanupStack::PopAndDestroy(&componentSet);
+			break;
+			}
+		
+		if(noVerification) 
+			{
+			CleanupStack::PopAndDestroy(&componentSet);
+			continue;
+			}
+				
+		for (TInt i = 0; i < returnedComponentsCount; ++i)
+			{
+			if (!VerifyMatchingL(componentSet[i], aExpectedEntries))
+				{
+				ERR_PRINTF2(_L("The API returned an unexpected entry with id %d"), componentSet[i]->ComponentId());
+				SetTestStepResult(EFail);				
+				CleanupStack::PopAndDestroy(&componentSet);
+				return;
+				}
+			}
+		
+		CleanupStack::PopAndDestroy(&componentSet);
+		}
+	
+	VerifyNonReturnedEntriesL(aExpectedEntries); 
+	}
+
+void CScrComponentRegistrySubsessionStep::ImplTestStepL()
+	{	
+	CComponentFilter* componentFilter = ReadComponentFilterFromConfigLC();
+	INFO_PRINTF1(_L("Read component filter from configuration"));
+	
+	INFO_PRINTF1(_L("Opened subsession to SCR"));
+	
+	//Get testing mode from configuration (sets or single iteration)
+	//Delegate the actual invocation and comparison according to the testing mode	
+	TInt setSize = GetSetSizeFromConfigL();
+	INFO_PRINTF2(_L("Test set size %d"), setSize);
+	
+	// Read expected results from config
+	RPointerArray<CComponentEntry> expectedComponentEntries;
+	CleanupResetAndDestroyPushL(expectedComponentEntries);
+	GetComponentEntriesFromConfigL(expectedComponentEntries);
+	StartTimer();
+	// Open the subsession
+	RSoftwareComponentRegistryView subSession;
+	CleanupClosePushL(subSession);	
+	subSession.OpenViewL(iScrSession, componentFilter);
+		
+	if (setSize == 1)
+		TestSingleModeL(subSession, expectedComponentEntries);
+	else
+		TestSetModeL(subSession, setSize, expectedComponentEntries);
+		
+	CleanupStack::PopAndDestroy(3, componentFilter); // expectedComponentEntries, subSession, componentFilter
+	}
+
+void CScrComponentRegistrySubsessionStep::ImplTestStepPostambleL()
+	{
+	CScrTestStep::ImplTestStepPostambleL();
+	}
+
+// -----------CScrFileListSubsessionStep-----------------
+
+CScrFileListSubsessionStep::CScrFileListSubsessionStep(CScrTestServer& aParent)	: CScrTestStep(aParent)
+	{
+	}
+
+void CScrFileListSubsessionStep::ImplTestStepPreambleL()
+	{
+	CScrTestStep::ImplTestStepPreambleL();
+	}
+
+void CScrFileListSubsessionStep::VerifyNonReturnedFilesL(const RPointerArray<HBufC>& aExpectedFiles)
+	{
+	if (aExpectedFiles.Count() > 0)
+		{
+		HBufC* fileName = aExpectedFiles[0]; 
+		ERR_PRINTF2(_L("At least one expected files was not returned by the API - name %S"), fileName);
+		SetTestStepResult(EFail);
+		}	
+	}
+
+void CScrFileListSubsessionStep::ReportUnexpectedFileL(const TDesC& aUnexpectedFileName)
+	{
+	ERR_PRINTF2(_L("The API returned an unexpected file entry with name %S"), &aUnexpectedFileName);
+	SetTestStepResult(EFail);		
+	}
+
+void CScrFileListSubsessionStep::TestSingleModeL(const RSoftwareComponentRegistryFilesList& aSubSession, 
+													 RPointerArray<HBufC> &aExpectedFiles)
+	{
+	FOREVER
+		{
+		HBufC *nextFile = aSubSession.NextFileL();
+		if (!nextFile)
+			break;
+		CleanupStack::PushL(nextFile);
+		
+		if (!VerifyMatchingL(nextFile, aExpectedFiles))
+			{
+			ReportUnexpectedFileL(*nextFile);
+			CleanupStack::PopAndDestroy(nextFile);
+			return;
+			}
+		
+		CleanupStack::PopAndDestroy(nextFile);
+		}
+	
+	VerifyNonReturnedFilesL(aExpectedFiles);
+	}
+
+void CScrFileListSubsessionStep::TestSetModeL(const RSoftwareComponentRegistryFilesList& aSubSession, TInt aSetSize, 
+											 	  RPointerArray<HBufC>& aExpectedFiles)
+	{
+	FOREVER
+		{
+		RPointerArray<HBufC> foundFiles;
+		CleanupResetAndDestroyPushL(foundFiles);
+		
+		aSubSession.NextFileSetL(aSetSize, foundFiles);
+		TInt returnedFilesCount = foundFiles.Count(); 
+		if (returnedFilesCount <= 0)
+			{
+			CleanupStack::PopAndDestroy(&foundFiles);
+			break;
+			}
+		for (TInt i = 0; i < returnedFilesCount; ++i)
+			{
+			if (!VerifyMatchingL(foundFiles[i], aExpectedFiles))
+				{
+				ReportUnexpectedFileL(*foundFiles[i]);
+				CleanupStack::PopAndDestroy(&foundFiles);
+				return;
+				}
+			}
+		
+		CleanupStack::PopAndDestroy(&foundFiles);
+		}
+	VerifyNonReturnedFilesL(aExpectedFiles);
+	}
+
+
+void CScrFileListSubsessionStep::ImplTestStepL()
+	{	
+	TInt componentId = GetComponentIdL();
+	RSoftwareComponentRegistryFilesList subSession;
+	CleanupClosePushL(subSession);
+	
+	subSession.OpenListL(iScrSession, componentId);
+	
+	RPointerArray<HBufC> expectedFiles;
+	CleanupResetAndDestroyPushL(expectedFiles);
+	
+	GetFileNameListFromConfigL(expectedFiles);
+	TInt setSize = GetSetSizeFromConfigL();
+
+	if (setSize > 1)
+		TestSingleModeL(subSession, expectedFiles);
+	else
+		TestSetModeL(subSession, setSize, expectedFiles);	
+			
+	CleanupStack::PopAndDestroy(2, &subSession); //expectedEntries 
+	}
+
+void CScrFileListSubsessionStep::ImplTestStepPostambleL()
+	{
+	CScrTestStep::ImplTestStepPostambleL();
+	}
+
+// -----------CAppInfoView-----------------
+
+CAppInfoView::CAppInfoView(CScrTestServer& aParent)	: CScrTestStep(aParent)
+	{
+	}
+
+void CAppInfoView::ImplTestStepPreambleL()
+	{
+	CScrTestStep::ImplTestStepPreambleL();
+	}
+
+void CAppInfoView::GetAppEntryFromConfigL(RPointerArray<Usif::TAppRegInfo>& aEntries)
+    {
+    TInt appEntriesCount(0);
+    TAppRegInfo *appRegInfo=NULL;
+    if (!GetIntFromConfig(ConfigSection(), KAppEntriesCountName, appEntriesCount))
+        {
+        appRegInfo = GetAppInfoFromConfigL(ETrue);
+        aEntries.AppendL(appRegInfo);
+        }
+    
+    for (TInt i = 0; i < appEntriesCount; ++i)
+        {
+        appRegInfo = GetAppInfoFromConfigL(EFalse,i);
+        aEntries.AppendL(appRegInfo);
+        }
+    }
+
+void CAppInfoView::VerifyNonReturnedEntriesL(const RPointerArray<Usif::TAppRegInfo>& aExpectedEntries)
+    {
+    // Check if we need to verify the returned components
+    // Performance tests don't need verification.
+    TBool noVerification = EFalse;
+    GetBoolFromConfig(ConfigSection(), _L("NoVerification"), noVerification);
+    if(noVerification) return;
+
+    if (aExpectedEntries.Count() > 0)
+        {
+        TUid appUid = aExpectedEntries[0]->Uid(); 
+        const TDesC& appName = aExpectedEntries[0]->FullName();
+        ERR_PRINTF3(_L("At least one expected entry was not returned by the API - id %d, name %S"), appUid, &appName);
+        SetTestStepResult(EFail);
+        }   
+    }
+
+void CAppInfoView::TestSessionL(TInt aNoOfEntries, const RApplicationInfoView& aSubSession, RPointerArray<Usif::TAppRegInfo>& aExpectedEntries)
+    {
+    // Check if we need to verify the returned components
+    // Performance tests don't need verification.
+    TBool isVerification = EFalse;
+    TInt noOfEntriesMatched = 0;
+    TInt totalExpectedEntriesCount = aExpectedEntries.Count();
+    GetBoolFromConfig(ConfigSection(), _L("IsVerification"), isVerification);
+    while (1)
+            {
+            RPointerArray<Usif::TAppRegInfo> appRegInfoSet;
+            aSubSession.GetNextAppInfoL(aNoOfEntries, appRegInfoSet);
+            TInt returnedAppRegInfoCount = appRegInfoSet.Count(); 
+            if (returnedAppRegInfoCount <= 0)
+                {
+                INFO_PRINTF2(_L("May be negative case... no entries found ...Entries count read is %d "),returnedAppRegInfoCount);                
+				appRegInfoSet.Close();
+                break;
+                }
+            
+            if(!isVerification) 
+                {
+                //INFO_PRINTF2(_L("Read Appuid is  %S"),appRegInfoSet[0]->iFullName );
+                INFO_PRINTF3(_L("No of entries read is %d and first appuid is %d "),returnedAppRegInfoCount,  appRegInfoSet[0]->Uid());
+               
+                    TAppRegInfo* tp=NULL;
+                    for (TInt i = 0; i<returnedAppRegInfoCount; i++ )
+                        {
+                    tp=appRegInfoSet[i];
+                    delete tp;
+                        }
+                appRegInfoSet.Close();
+				continue;
+                }
+                    
+            for (TInt i = 0; i < returnedAppRegInfoCount; ++i)
+                {
+                if (VerifyMatchingL(appRegInfoSet[i], aExpectedEntries))                    
+                    {                                          
+                    ++noOfEntriesMatched;
+                    }
+                }            
+            TAppRegInfo* tp=NULL;
+            for(TInt i = 0; i<returnedAppRegInfoCount; ++i)
+               {
+               tp=appRegInfoSet[i];
+               delete tp;
+               }
+            appRegInfoSet.Close();     
+            if(noOfEntriesMatched == totalExpectedEntriesCount)
+                break;
+            }
+        
+    VerifyNonReturnedEntriesL(aExpectedEntries); 
+    
+    }
+
+void CAppInfoView::ImplTestStepL()
+	{	
+	CAppInfoFilter* appinfoFilter=NULL ;
+
+	INFO_PRINTF1(_L("Read appinfo filter from configuration"));
+	TRAPD(err, ReadAppInfoFilterFromConfigL(&appinfoFilter));
+	if (KErrNotFound==err)
+	    {
+	    delete appinfoFilter;
+	    appinfoFilter=NULL;
+	    }
+	RPointerArray<TAppRegInfo> expectedAppRegEntries;
+    CleanupResetAndDestroyPushL(expectedAppRegEntries);
+	TInt noOfEntries(1);
+	GetIntFromConfig(ConfigSection(), _L("NoOfEntries"), noOfEntries);
+	
+	TBool isVerification = EFalse;
+	GetBoolFromConfig(ConfigSection(), _L("IsVerification"), isVerification);
+	if(isVerification) 
+	{
+        GetAppEntryFromConfigL(expectedAppRegEntries);
+        INFO_PRINTF1(_L("Read expected entries for verification "));
+	}
+    
+	INFO_PRINTF1(_L("Opened subsession to SCR"));
+    TBool callGetNextAppWithLocale=EFalse;
+    TInt appLocale;
+    if (GetIntFromConfig(ConfigSection(), _L("LocaleValue"), appLocale))
+        callGetNextAppWithLocale=ETrue;
+	RApplicationInfoView  subSession;
+	CleanupClosePushL(subSession);
+
+	if(callGetNextAppWithLocale)
+	    {
+	    subSession.OpenViewL(iScrSession,appinfoFilter, (TLanguage)appLocale);
+	    }
+	else
+	    {
+	    subSession.OpenViewL(iScrSession,appinfoFilter);
+	    }
+
+	if(appinfoFilter)
+	    delete appinfoFilter;
+
+    TRAPD(err1,TestSessionL(noOfEntries, subSession, expectedAppRegEntries));
+
+	TInt count = expectedAppRegEntries.Count();
+	TAppRegInfo* tp=NULL;
+	for (TInt i = 0; i<count; i++ )
+	    {
+	    tp=expectedAppRegEntries[i];
+	    delete tp;
+	    }
+	expectedAppRegEntries.Close();
+	CleanupStack::PopAndDestroy(2, &expectedAppRegEntries); //expectedAppRegEntries, subSession
+	if (KErrNone!=err1)
+	    User::Leave(err1);
+	}
+
+void CAppInfoView::ImplTestStepPostambleL()
+	{
+	CScrTestStep::ImplTestStepPostambleL();
+	}