/*

* 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 the basic test step for the Software Component Registry test harness

*

*/

#include "tscrstep.h"

#include "tscrserver.h"

#include "tscrdefs.h"

#include <f32file.h>

#include <scs/cleanuputils.h>

using namespace Usif;

CScrTestStep::CScrTestStep(CScrTestServer& aParent)

// Constructor.

	: iParent(aParent)

	{	

	}

CScrTestStep::~CScrTestStep()

// Destructor.

	{

	iScrSession.Close();

	}

void CScrTestStep:: MarkAsPerformanceStep()

	{

	iIsPerformanceTest = ETrue;

	}

void CScrTestStep::PrintPerformanceLog(TTime aTime)

	{

	TDateTime timer = aTime.DateTime();

	INFO_PRINTF6(_L("%S,%d:%d:%d:%d"), &KPerformanceTestInfo(), timer.Hour(), timer.Minute(), timer.Second(), timer.MicroSecond());

	}

void CScrTestStep::StartTimer()

	{

	iStartTime.HomeTime();

	PrintPerformanceLog(iStartTime);

	}

void CScrTestStep::StopTimerAndPrintResultL()

	{

	TTime endTime;

	endTime.HomeTime();

	PrintPerformanceLog(endTime);

	TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(iStartTime);

	TInt actualDuration = I64INT(duration.Int64())/1000; // in millisecond

	if(iTimeMeasuredExternally)

		{ // if the time is measured by the scr accessor, update the actual time with the external time.

		actualDuration = iTimeMeasuredExternally;

		}

	TInt maxDuration = 0;

	if(!GetIntFromConfig(ConfigSection(), KMaxDurationName, maxDuration))

		{

		ERR_PRINTF2(_L("%S could not be found in configuration."), &KMaxDurationName());

		User::Leave(KErrNotFound);

		}

	else

		{

		INFO_PRINTF3(_L("%S,%d"), &KMaxTestCaseDuration(), maxDuration);

		INFO_PRINTF3(_L("%S,%d"), &KActualTestCaseDuration(), actualDuration);

		}

	if(actualDuration <= maxDuration)

		{

		INFO_PRINTF2(_L("This test meets performance requirement (Duration=%d)."), actualDuration);

		}

	else

		{

		ERR_PRINTF2(_L("This test does not meet performance requirement (Duration=%d)."), actualDuration);

		SetTestStepResult(EFail);

		}

	}

void CScrTestStep::ImplTestStepPreambleL()

/**

 	From COomTestStep.

 */

	{

	User::LeaveIfError(iScrSession.Connect());

	if(iIsPerformanceTest)

		{

		StartTimer();

		}

	}

void CScrTestStep::ImplTestStepL()

/**

	From COomTestStep.

 */

	{

	// empty

	}

void CScrTestStep::ImplTestStepPostambleL()

/**

 	From COomTestStep.

 */

	{

	if(iIsPerformanceTest)

		{

		StopTimerAndPrintResultL();

		}

	}

RScsClientBase* CScrTestStep::ClientHandle()

/**

 	From COomTestStep.

 */

	{

	return &iScrSession;

	}

void CScrTestStep::PrintErrorL(const TDesC& aMsg, TInt aErrNum,...)

	{

	VA_LIST list;

	VA_START(list, aErrNum);

	RBuf msgBuf;

	msgBuf.CreateL(MAX_SCR_ERROR_MESSAGE_LENGTH);

	msgBuf.CleanupClosePushL();

	msgBuf.AppendFormatList(aMsg, list);

	ERR_PRINTF1(msgBuf);

	SetTestStepResult(EFail);

	CleanupStack::PopAndDestroy(&msgBuf);

	User::Leave(aErrNum);

	}

//--------------------Code for properties' comparison

TBool operator ==(const TDriveList& aLhsEntry, const TDriveList& aRhsEntry)

	{

	// If two drives are equal, each byte of them must be zero or non-zero together. 

	// Otherwise, the drive lists are different.

	for(TInt driveNumber=EDriveA; driveNumber<=EDriveZ; ++driveNumber)

		{ 

		if((aLhsEntry[driveNumber] || aRhsEntry[driveNumber]) && !(aLhsEntry[driveNumber] && aRhsEntry[driveNumber]))

			return EFalse;

		}

	return ETrue;

	}

TBool operator ==(const CComponentEntry& aLhsEntry, const CComponentEntry& aRhsEntry)

	{

	return (aLhsEntry.ComponentId() == aRhsEntry.ComponentId() && 

			aLhsEntry.Name() == aRhsEntry.Name()&& 

			aLhsEntry.Vendor() == aRhsEntry.Vendor() && 

			aLhsEntry.SoftwareType() == aRhsEntry.SoftwareType() &&

			aLhsEntry.GlobalId() == aRhsEntry.GlobalId() &&

			aLhsEntry.IsRemovable() == aRhsEntry.IsRemovable() && 

			aLhsEntry.IsDrmProtected() == aRhsEntry.IsDrmProtected() && 

			aLhsEntry.IsHidden() == aRhsEntry.IsHidden() && 

			aLhsEntry.IsKnownRevoked() == aRhsEntry.IsKnownRevoked() && 

			aLhsEntry.IsOriginVerified() == aRhsEntry.IsOriginVerified() && 

			aLhsEntry.ComponentSize() == aRhsEntry.ComponentSize() &&

			aLhsEntry.ScomoState() == aRhsEntry.ScomoState() && 

			aLhsEntry.InstalledDrives() == aRhsEntry.InstalledDrives() && 

			aLhsEntry.Version() == aRhsEntry.Version());

	}

TBool operator !=(const CComponentEntry& aLhsEntry, const CComponentEntry& aRhsEntry)

	{

	return !operator ==(aLhsEntry, aRhsEntry);

	}

TBool operator ==(CLocalizablePropertyEntry& lhsEntry, CLocalizablePropertyEntry& rhsEntry)

	{

	return lhsEntry.StrValue() == rhsEntry.StrValue();

	}

TBool operator ==(CBinaryPropertyEntry& lhsEntry, CBinaryPropertyEntry& rhsEntry)

	{

	return lhsEntry.BinaryValue() == rhsEntry.BinaryValue();

	}

TBool operator ==(CIntPropertyEntry& lhsEntry, CIntPropertyEntry& rhsEntry)

	{

	return lhsEntry.Int64Value() == rhsEntry.Int64Value();

	}

template <class T> TBool CompareProperty(CPropertyEntry& lhsEntry, CPropertyEntry& rhsEntry)

	{

	// Cannot use reference dynamic_cast - Symbian does not support std::bad_cast or any other exception	

	T& lhsSubclassEntry = static_cast<T &>(lhsEntry);

	T& rhsSubclassEntry = static_cast<T &>(rhsEntry);

	return (lhsSubclassEntry == rhsSubclassEntry);	

	}

TBool operator ==(CPropertyEntry& lhsEntry, CPropertyEntry& rhsEntry)

	{

	CPropertyEntry::TPropertyType lhsPropertyType = lhsEntry.PropertyType();

	CPropertyEntry::TPropertyType rhsPropertyType = rhsEntry.PropertyType();

	if (lhsPropertyType != rhsPropertyType)

		return EFalse;

	switch (rhsPropertyType)

		{

		case CPropertyEntry::EBinaryProperty:

			{

			return CompareProperty<CBinaryPropertyEntry>(lhsEntry, rhsEntry);

			}

		case CPropertyEntry::ELocalizedProperty:

			{

			return CompareProperty<CLocalizablePropertyEntry>(lhsEntry, rhsEntry);

			}			

		case CPropertyEntry::EIntProperty:

			{

			return CompareProperty<CIntPropertyEntry>(lhsEntry, rhsEntry);

			}

		default:

			ASSERT(0);

		}

	ASSERT(0);

	return ETrue; // Should not reach here

	}

TBool operator !=(CPropertyEntry& lhsEntry, CPropertyEntry& rhsEntry)

	{

	return !operator ==(lhsEntry, rhsEntry);

	}

TBool CScrTestStep::ComparePropertiesL(RPointerArray<CPropertyEntry>& aFoundProperties, RPointerArray<CPropertyEntry>& aExpectedProperties)

	{

	TInt foundPropertiesCount = aFoundProperties.Count();

	if (aExpectedProperties.Count() != foundPropertiesCount)

		{

		ERR_PRINTF3(_L("The number of expected properties %d did not match the number of found properties %d."), aExpectedProperties.Count(), foundPropertiesCount);

		return EFalse; 

		}

	for (TInt i = 0; i < foundPropertiesCount; ++i)

		{

		if (*aFoundProperties[i] != *aExpectedProperties[i])

			{

			ERR_PRINTF2(_L("Property %d did not match."), i);

			return EFalse;

			}

		}	

	return ETrue;

	}

TBool operator ==(const CGlobalComponentId& lhsEntry, const CGlobalComponentId& rhsEntry)

	{

	return (lhsEntry.GlobalIdName() == rhsEntry.GlobalIdName()) && 

		   (lhsEntry.SoftwareTypeName() == rhsEntry.SoftwareTypeName());

	}

TBool operator !=(const CGlobalComponentId& lhsEntry, const CGlobalComponentId& rhsEntry)

	{

	return !operator==(lhsEntry,rhsEntry);

	}

TBool operator ==(const CVersionedComponentId& lhsEntry, const CVersionedComponentId& rhsEntry)

	{

	return (lhsEntry.GlobalId() == rhsEntry.GlobalId()) &&

		   ((lhsEntry.VersionFrom()?*lhsEntry.VersionFrom():KNullDesC()) == (rhsEntry.VersionFrom()?*rhsEntry.VersionFrom():KNullDesC())) &&

		   ((lhsEntry.VersionTo()?*lhsEntry.VersionTo():KNullDesC()) == (rhsEntry.VersionTo()?*rhsEntry.VersionTo():KNullDesC()));

	}

TBool operator !=(CVersionedComponentId& lhsEntry, CVersionedComponentId& rhsEntry)

	{

	return !operator==(lhsEntry,rhsEntry);

	}

TBool CScrTestStep::CompareVersionedComponentIdsL(RPointerArray<CVersionedComponentId>& aFoundVerCompIdList, RPointerArray<CVersionedComponentId>& aExpectedVerCompIdList)

	{

	TInt foundVerCompIdsCount = aFoundVerCompIdList.Count();

	TInt expectedVerCompIdsCount = aExpectedVerCompIdList.Count();

	if (foundVerCompIdsCount != expectedVerCompIdsCount)

		{

		ERR_PRINTF3(_L("The number of expected versioned component Ids %d did not match the number of found ones %d."), expectedVerCompIdsCount, foundVerCompIdsCount);

		return EFalse; 

		}

	for (TInt i = 0; i < foundVerCompIdsCount; ++i)

		{

		if (*aFoundVerCompIdList[i] != *aExpectedVerCompIdList[i])

			{

			ERR_PRINTF2(_L("Versioned Component Id %d did not match."), i);

			return EFalse;

			}

		}	

	return ETrue;

	}

void CScrTestStep::CompareComponentIdsL(RArray<TComponentId>& aFoundComponents, RArray<TComponentId>& aExpectedComponents)

	{

	TInt foundComponentsCount = aFoundComponents.Count();

	if (foundComponentsCount != aExpectedComponents.Count())

		{

		ERR_PRINTF3(_L("The number of expected components %d did not match the number of found components %d."), aExpectedComponents.Count(), foundComponentsCount);

		SetTestStepResult(EFail);

		return;			

		}

	aFoundComponents.Sort();

	aExpectedComponents.Sort();	

	for (TInt i = 0; i < foundComponentsCount; ++i)

		{

		if (aFoundComponents[i] < aExpectedComponents[i])

			{

			ERR_PRINTF2(_L("Component %d was not expected in the test."), aFoundComponents[i]);

			SetTestStepResult(EFail);

			break;

			}

		else if (aExpectedComponents[i] < aFoundComponents[i])

			{

			ERR_PRINTF2(_L("Component %d was expected, but not found."), aExpectedComponents[i]);

			SetTestStepResult(EFail);

			break;			

			}

		}	

	}

// Helper functions for getting commong attributes from configuration

void CScrTestStep::GetSoftwareTypeNameL(TPtrC& aSwTypeName)

	{

	if (!GetStringFromConfig(ConfigSection(), KSoftwareTypeName, aSwTypeName))

		PrintErrorL(_L("Software Type was not found!"), KErrNotFound);

	}

TBool CScrTestStep::GetGlobalIdNameL(TPtrC& aGlobalIdName)

	{

	if (!GetStringFromConfig(ConfigSection(), KGlobalIdName, aGlobalIdName))

		return EFalse;

	return ETrue;

	}

Usif::CGlobalComponentId* CScrTestStep::GetGlobalComponentIdLC()

	{

	TPtrC globalIdName;

	if (!GetGlobalIdNameL(globalIdName))

		PrintErrorL(_L("Global Id Name was not found!"), KErrNotFound);

	TPtrC swTypeName;

	GetSoftwareTypeNameL(swTypeName);

	return CGlobalComponentId::NewLC(globalIdName, swTypeName);

	}

Usif::CGlobalComponentId* CScrTestStep::GetGlobalComponentIdLC(const TDesC& aGlobalIdName, const TDesC& aSwTypeName)

	{

	TPtrC globalIdName;

	if (!GetStringFromConfig(ConfigSection(), aGlobalIdName, globalIdName))

		PrintErrorL(_L("Global Id Name was not found!"), KErrNotFound);

	TPtrC swTypeName;

	if (!GetStringFromConfig(ConfigSection(), aSwTypeName, swTypeName))

		PrintErrorL(_L("Software Type Name was not found!"), KErrNotFound);

	return CGlobalComponentId::NewLC(globalIdName, swTypeName);

	}

HBufC* CScrTestStep::GetVersionFromConfigL(const TDesC& aVersionName)

	{

	TPtrC version(KNullDesC());

	if(!GetStringFromConfig(ConfigSection(), aVersionName, version))

		return NULL;

	return version.AllocL();

	}

void CScrTestStep::GetExpectedVersionedComponentIdListL(RPointerArray<CVersionedComponentId>& aVerCompIdList)

	{

	TInt globalIdCount(0);

	if(!GetIntFromConfig(ConfigSection(), KGlobalIdCount, globalIdCount))

			PrintErrorL(_L("Global Id count was not found!"), KErrNotFound);

	TBuf<MAX_SCR_PARAM_LENGTH> paramGlobalIdName, paramSwTypeName, paramVersionFrom, paramVersionTo;

	for(TInt i=0; i<globalIdCount; ++i)

		{

		paramGlobalIdName = KGlobalIdName;	

		paramSwTypeName = KSoftwareTypeName;

		paramVersionFrom = KVersionFrom;

		paramVersionTo = KVersionTo;

		GenerateIndexedAttributeNameL(paramGlobalIdName, i);

		GenerateIndexedAttributeNameL(paramSwTypeName, i);

		GenerateIndexedAttributeNameL(paramVersionFrom, i);

		GenerateIndexedAttributeNameL(paramVersionTo, i);

		TPtrC globalIdName;

		if (!GetStringFromConfig(ConfigSection(), paramGlobalIdName, globalIdName))

			{

			ERR_PRINTF2(_L("The %S param could not be found in configuration."), &paramGlobalIdName);

			User::Leave(KErrNotFound);

			}

		TPtrC swTypeName;

		if (!GetStringFromConfig(ConfigSection(), paramSwTypeName, swTypeName))

			{

			ERR_PRINTF2(_L("The %S param could not be found in configuration."), &paramSwTypeName);

			User::Leave(KErrNotFound);

			}

		HBufC *versionFrom = GetVersionFromConfigL(paramVersionFrom);

		if(versionFrom)

			CleanupStack::PushL(versionFrom);

		HBufC *versionTo = GetVersionFromConfigL(paramVersionTo);

		if(versionTo)

			CleanupStack::PushL(versionTo);

		CGlobalComponentId *globalId = CGlobalComponentId::NewLC(globalIdName, swTypeName);

		CVersionedComponentId *verCompId = CVersionedComponentId::NewLC(*globalId, versionFrom, versionTo);

		aVerCompIdList.AppendL(verCompId);

		CleanupStack::Pop(verCompId); // owned by the array

		CleanupStack::PopAndDestroy(globalId);

		if(versionTo)

			CleanupStack::PopAndDestroy(versionTo);

		if(versionFrom)

			CleanupStack::PopAndDestroy(versionFrom);

		}

	}

void CScrTestStep::AppendSharedComponentIdL(Usif::TComponentId aComponentId)

	{

	TBuf<MAX_SCR_BUFFER_LENGTH> componentIdBuf;

	ReadSharedDataL(KComponentIdName, componentIdBuf);

	componentIdBuf.AppendNum(aComponentId);

	componentIdBuf.Append(KComponentIdDelimeter);

	WriteSharedDataL(KComponentIdName, componentIdBuf, ESetText);

	}

void CScrTestStep::ReadAllSharedComponentIdsL(RArray<TInt>& aComponentList)

	{

	TBuf<MAX_SCR_BUFFER_LENGTH> componentIdBuf;

	ReadSharedDataL(KComponentIdName, componentIdBuf);

	TLex parser(componentIdBuf);

	TChar currentChar;

	parser.Mark();

	while(!parser.Eos())

		{

		currentChar = parser.Get();

		if(KComponentIdDelimeter == currentChar)

			{

			TPtrC token = parser.MarkedToken();

			TLex tokenLex(token);

			TInt componentId;

			tokenLex.Val(componentId);

			aComponentList.AppendL(componentId);

			parser.Mark();

			}

		}

	}

TInt CScrTestStep::ReadSharedComponentIdL(TInt aOffset)

	{

	RArray<TInt> componentList;

	CleanupClosePushL(componentList);

	ReadAllSharedComponentIdsL(componentList);

	TInt maxListIndex = componentList.Count() - 1;

	if(aOffset<0 || aOffset>maxListIndex)

		PrintErrorL(_L("Component Id offset is not valid!"), KErrArgument);

	TInt componentId = componentList[maxListIndex - aOffset];

	CleanupStack::PopAndDestroy(&componentList);

	return componentId;

	}

TBool CScrTestStep::GetLocaleFromConfigL(const TDesC& aParamName, TLanguage &aLocale)

	{

	TInt localeParam;

	if (!GetIntFromConfig(ConfigSection(), aParamName, localeParam))

		return EFalse;

	aLocale = static_cast<TLanguage>(localeParam);

	return ETrue;

	}

TBool CScrTestStep::GetLocaleFromConfigL(TLanguage &aLocale)

	{

	return GetLocaleFromConfigL(KPropertyLocaleParam, aLocale);

	}

TInt CScrTestStep::GetComponentIdL()

	{

	TInt componentId(0);

	if(GetIntFromConfig(ConfigSection(), KComponentIdName, componentId))

		return componentId;

	TInt componentIdOffset;

	if (!GetIntFromConfig(ConfigSection(), KComponentIdOffsetName, componentIdOffset))

		PrintErrorL(_L("ComponentId Offset was not found!"), KErrNotFound);

	componentId = ReadSharedComponentIdL(componentIdOffset);

	INFO_PRINTF2(_L("Component Id %d"), componentId);

	return componentId;

	}

void CScrTestStep::GetFileNameFromConfigL(TPtrC& aFileName)

	{

	if (!GetStringFromConfig(ConfigSection(), KFileName, aFileName))

		PrintErrorL(_L("FileName was not found!"), KErrNotFound);

	}

void CScrTestStep::GetFileNameListFromConfigL(RPointerArray<HBufC>& aFileList)

	{