// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

/**

 @file

 @internalComponent

 @prototype

*/

#include "dvbhhaitestutil.h"

const TUid KDvbhPropertyCategory = 

	{

	0x101f45ef //TestFramework's UID3

	};

struct TDvbhProperty

	{

	TInt iKey;

	TInt iType;

	};

const TUint KNumDvbhProperties = 8;

const TDvbhProperty KDvbhProperties[] =

	{

	{EDvbhPropertyKeyState, RProperty::EInt},

	{EDvbhPropertyKeyPlatform, RProperty::EByteArray},

	{EDvbhPropertyKeyNetworkTime, RProperty::EByteArray},

	{EDvbhPropertyKeyPerformanceData, RProperty::EByteArray},

	{EDvbhPropertyKeyFrequency, RProperty::EInt},

	{EDvbhPropertyKeyNetworkId, RProperty::EInt},

	{EDvbhPropertyKeySignalQuality, RProperty::EInt}, 

	{EDvbhPropertyKeyCellId, RProperty::EInt}

	};

TInt CDvbhTestUtil::GetKey(TDvbhPropertyKey aKey)

	{

	return KDvbhProperties[aKey].iKey;

	}

TInt CDvbhTestUtil::GetType(TDvbhPropertyKey aKey)

	{

	return KDvbhProperties[aKey].iType;

	}

CDvbhTestUtil::CDvbhTestUtil(MDvbhHaiTestLoggerInterface& aTestStepLogger)

: iTestStepLogger(aTestStepLogger)

	{

	}

CDvbhTestUtil* CDvbhTestUtil::NewL(MDvbhHaiTestLoggerInterface& aTestStepLogger)

	{

	CDvbhTestUtil* self = new (ELeave) CDvbhTestUtil(aTestStepLogger);

	return self;

	}

TInt CDvbhTestUtil::DefineDvbhProperty(TInt aPropertyKey, TInt aType) const

	{

	TInt err = RProperty::Define(KDvbhPropertyCategory, aPropertyKey, aType);

	if (err != KErrAlreadyExists && err != KErrNone)

	    {

	    iTestStepLogger.InfoPrintf3(_L("Error %d defining property %d"), err, aPropertyKey);

	    return err;

	    }

	else

		{

		err = KErrNone;

		}

    return err;	

	}

TInt CDvbhTestUtil::DefineDvbhProperty(TInt aPropertyKey, TInt aType, const TDesC8& aInitialValue) const

	{

	TInt err = DefineDvbhProperty(aPropertyKey, aType);

	if (err != KErrNone)

		{

		return err;

		}

	return SetByteArrayProperty(aPropertyKey, aInitialValue);

	}

TInt CDvbhTestUtil::DeleteDvbhProperty(TInt aPropertyKey)

	{

	TInt err = RProperty::Delete(KDvbhPropertyCategory, aPropertyKey);

	if (err != KErrNone && err != KErrNotFound)

	    {

	    iTestStepLogger.InfoPrintf3(_L("Error %d deleting property %d"), err, aPropertyKey);

	    }

	else

		{

		err = KErrNone;

		}

	return err;

	}

TInt CDvbhTestUtil::SetByteArrayProperty(TInt aPropertyKey, const TDesC8& aValue) const

	{

	TInt result = RProperty::Set(KDvbhPropertyCategory, aPropertyKey, aValue);

	if (result != KErrNone)

		{

		iTestStepLogger.InfoPrintf3(_L("Error %d setting the byte array property with key %d."), result, aPropertyKey);

		}

	return result;

	}

TInt CDvbhTestUtil::SetIntegerProperty(TInt aPropertyKey, TInt aValue) const

	{

	TInt result = RProperty::Set(KDvbhPropertyCategory, aPropertyKey, aValue);

	if (result != KErrNone)

		{

		iTestStepLogger.InfoPrintf4(_L("Error %d setting the integer property with key %d to %d"), result, aPropertyKey, aValue);

		}

	return result;		

	}

TInt CDvbhTestUtil::DefineDvbhStateProperty(TInt aInitialState)

	{

	TInt result = DefineDvbhProperty(EDvbhPropertyKeyState, KDvbhProperties[EDvbhPropertyKeyState].iType);

	if (result == KErrNone && aInitialState != ENoInitialState)

		{

		result = SetStateProperty(aInitialState);	

		}

	return result;

	}

TInt CDvbhTestUtil::DefineDvbhIntegerProperty(TInt aPropertyKey, TInt aInitialValue) const

	{

	TInt result = DefineDvbhProperty(aPropertyKey, KDvbhProperties[aPropertyKey].iType);

	if (result == KErrNone)

		{

		result = SetIntegerProperty(aPropertyKey, aInitialValue);	

		}

	return result;	

	}

TInt CDvbhTestUtil::SetStateProperty(TInt aValue)

	{

	TInt result = SetIntegerProperty(EDvbhPropertyKeyState, aValue);

	if (result != KErrNone)

		{

		iTestStepLogger.InfoPrintf3(_L("Error %d setting state property to %d"), result, aValue);

		}

	return result;

	}

TInt CDvbhTestUtil::DefineAllDvbhProperties()

	{

	for (TUint i=0;i<KNumDvbhProperties;++i)

		{

		const TDvbhProperty property = KDvbhProperties[i];

		TInt defineResult = DefineDvbhProperty(property.iKey, property.iType);

		if (defineResult != KErrNone)

			{

		    iTestStepLogger.InfoPrintf3(_L("Error %d defining property number %d"), defineResult, i);

			DeleteAllDvbhProperties();

			return defineResult;

			}

		}

	return KErrNone;

	}

TInt CDvbhTestUtil::DeleteAllDvbhProperties()

	{

	TInt result = KErrNone;

	for (TUint i=0;i<KNumDvbhProperties;++i)

		{

		const TDvbhProperty property = KDvbhProperties[i];

		TInt deleteResult = DeleteDvbhProperty(property.iKey);

		if (deleteResult != KErrNone)

			{

		    result = deleteResult;

			}

		}

	return result;	

	}

TBool CDvbhTestUtil::CompareVersions(const TVersion& aVersion1, const TVersion& aVersion2)

	{

	return (aVersion1.iMinor == aVersion2.iMinor &&

			aVersion1.iMajor == aVersion2.iMajor &&

			aVersion1.iBuild == aVersion2.iBuild);

	}

TBool CDvbhTestUtil::ComparePlatforms(const TDvbhPlatform& aPlatform1, const TDvbhPlatform& aPlatform2)

	{

	return (aPlatform1.iId == aPlatform2.iId &&

			aPlatform1.iName.Compare(aPlatform2.iName) == 0); // Compare returns 0 if they are the same

	}

TBool CDvbhTestUtil::ComparePerformanceDatas(const TDvbhPerformanceData& aData1, const TDvbhPerformanceData& aData2)

	{

	return (aData1.iFilterCount == aData2.iFilterCount &&

			aData1.iMaxFilters == aData2.iMaxFilters &&

			aData1.iDataCount == aData2.iDataCount &&

			aData1.iWriteCount == aData2.iWriteCount &&

			aData1.iWriteCommandCount == aData2.iWriteCommandCount &&

			aData1.iReadCount == aData2.iReadCount &&

			aData1.iReadCommandCount == aData2.iReadCommandCount);

	}

TBool CDvbhTestUtil::CompareScanConfigurations(const TDvbhScanConfiguration& aConfig1, const TDvbhScanConfiguration& aConfig2)

	{

	return (aConfig1.iScanStartFrequency == aConfig2.iScanStartFrequency &&

			aConfig1.iScanEndFrequency == aConfig2.iScanEndFrequency &&

			aConfig1.iSignalBandwidth == aConfig2.iSignalBandwidth &&

			aConfig1.iScanOptions == aConfig2.iScanOptions );

	}