/*

* 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;

    GetBoolFromConfig(ConfigSection(), _L("IsVerification"), isVerification);

    while (1)

            {

            RPointerArray<Usif::TAppRegInfo> appRegInfoSet;

            aSubSession.GetNextAppInfoL(aNoOfEntries, appRegInfoSet);

            TInt returnedAppRegInfoCount = appRegInfoSet.Count(); 

            if (returnedAppRegInfoCount <= 0)

                {

				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)

                {

            }

    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;

	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();

	}