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

 	}