/*

* Copyright (c) 2008-2009 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 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();

	}