/*

 * Copyright (c) 2005-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: 

 *

 */

 #include "T_EComResolverParamsData.h"

 /*@{*/

 ///	Parameters

 _LIT(KExpectedString,										"expected_string");

 _LIT(KExpectedBool,											"expected_bool");

 _LIT(KDataType,												"data_type");

 _LIT(KGenericMatch,											"generic_match");

 _LIT(KWildcardMatch,										"wildcard_match");

 ///	TEcomResolverParams

 _LIT(KCmdDataType,											"DataType");

 _LIT(KCmdSetDataType,										"SetDataType");

 _LIT(KCmdSetGenericMatch,									"SetGenericMatch");

 _LIT(KCmdIsGenericMatch,									"IsGenericMatch");

 _LIT(KCmdSetWildcardMatch,									"SetWildcardMatch");

 _LIT(KCmdIsWildcardMatch,									"IsWildcardMatch");

 _LIT( KEmptyString,											"");

 /*@}*/

 //////////////////////////////////////////////////////////////////////

 // Construction/Destruction

 //////////////////////////////////////////////////////////////////////

 /**

  * Two phase constructor

  */

 CT_EComResolverParamsData* CT_EComResolverParamsData::NewL()

 	{

 	CT_EComResolverParamsData*	ret=new (ELeave) CT_EComResolverParamsData();

 	CleanupStack::PushL(ret);

 	ret->ConstructL();

 	CleanupStack::Pop(ret);

 	return ret;

 	}

 /**

  * Constructor. First phase construction

  */

 CT_EComResolverParamsData::CT_EComResolverParamsData()

 	{

 	}

 /**

  * Second phase construction

  */

 void CT_EComResolverParamsData::ConstructL()

 	{

 	}

 /**

  * Destructor

  */

 CT_EComResolverParamsData::~CT_EComResolverParamsData()

 	{

 	DestroyData();

 	}

 void CT_EComResolverParamsData::DestroyData()

 	{

 	}

 TAny* CT_EComResolverParamsData::GetObject() 

 /**

  * Return a pointer to the object that the data wraps

  *

  * @return	Pointer to the object that the data wraps

  */

 	{

 	return &iResolverParams;

 	};

 //////////////////////////////////////////////////////////////////////

 // Read data from INI file

 //////////////////////////////////////////////////////////////////////

 TBool CT_EComResolverParamsData::GetExpectedString(const TDesC& aSection, TPtrC& aExpectedString)

 	{

 	aExpectedString.Set(KEmptyString);

 	return GetStringFromConfig(aSection, KExpectedString(), aExpectedString);

 	}

 TBool CT_EComResolverParamsData::GetDataType(const TDesC& aSection, TBuf8<KMaxTestExecuteCommandLength>& aDataType)

 	{

 	TPtrC	dataType(KEmptyString);

 	TBool	ret=GetStringFromConfig(aSection, KDataType(), dataType);

 	if ( ret )

 		{

 		aDataType.Copy(dataType);

 		}

 	return ret;

 	}

 TBool CT_EComResolverParamsData::GetExpectedBool(const TDesC& aSection, TBool& aBool)

 	{

 	aBool = EFalse;

 	return GetBoolFromConfig(aSection, KExpectedBool(), aBool );

 	}

 TBool CT_EComResolverParamsData::GetGenericMatch(const TDesC& aSection, TBool& aGenericMatch)

 	{

 	aGenericMatch = EFalse;

 	return GetBoolFromConfig(aSection, KGenericMatch(), aGenericMatch );

 	}

 TBool CT_EComResolverParamsData::GetWildcardMatch(const TDesC& aSection, TBool& aWildcardMatch)

 	{

 	aWildcardMatch = EFalse;

 	return GetBoolFromConfig(aSection, KWildcardMatch(), aWildcardMatch );

 	}

 TBool CT_EComResolverParamsData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt /*aAsyncErrorIndex*/)

 /**

  * Process a command read from the ini file

  *

  * @param aCommand			The command to process

  * @param aSection			The section in the ini containing data for the command

  * @param aAsyncErrorIndex	Command index for async calls to return errors to

  *

  * @return					ETrue if the command is processed

  *

  * @leave					System wide error

  */

 	{

 	TBool retVal=ETrue;

 	if ( aCommand==KCmdDataType )

 		{

 		DoCmdDataType(aSection);

 		}

 	else if ( aCommand==KCmdSetDataType )

 		{

 		DoCmdSetDataType(aSection);

 		}

 	else if ( aCommand==KCmdSetGenericMatch )

 		{

 		DoCmdSetGenericMatch(aSection);

 		}

 	else if ( aCommand==KCmdIsGenericMatch )

 		{

 		DoCmdIsGenericMatch(aSection);

 		}

 	else if ( aCommand==KCmdSetWildcardMatch )

 		{

 		DoCmdSetWildcardMatch(aSection);

 		}

 	else if ( aCommand==KCmdIsWildcardMatch )

 		{

 		DoCmdIsWildcardMatch(aSection);

 		}

 	else

 		{

 		retVal=EFalse;

 		}

 	return retVal;

 	}

 void CT_EComResolverParamsData::DoCmdDataType(const TDesC& aSection)

 	{

 	TBuf<KMaxTestExecuteCommandLength>	actualValue;

 	actualValue.Copy(iResolverParams.DataType());

 	INFO_PRINTF2(_L("DataType %S"), &actualValue);

 	TPtrC	expectedValue;

 	if (GetExpectedString(aSection, expectedValue))

 		{

 		if (actualValue!=expectedValue)

 			{

 			ERR_PRINTF3(_L("Actual value \"%S\" does not match expected value \"%S\""), &actualValue, &expectedValue);

 			SetBlockResult(EFail);

 			}

 		}

 	}

 void CT_EComResolverParamsData::DoCmdSetDataType(const TDesC& aSection)

 	{

 	if (!GetDataType(aSection, iDataType))

 		{

 		ERR_PRINTF1(_L("Not enought arguments"));

 		SetBlockResult(EFail);

 		}

 	else

 		{

 		iResolverParams.SetDataType(iDataType);

 		}

 	}

 void CT_EComResolverParamsData::DoCmdSetGenericMatch(const TDesC& aSection)

 	{

 	TBool	setGenericMatch;

 	if (!GetGenericMatch(aSection, setGenericMatch))

 		{

 		ERR_PRINTF1(_L("Not enought arguments"));

 		SetBlockResult(EFail);

 		}

 	else

 		{

 		iResolverParams.SetGenericMatch(setGenericMatch);

 		}

 	}

 void CT_EComResolverParamsData::DoCmdIsGenericMatch(const TDesC& aSection)

 	{

 	TBool	actualValue=iResolverParams.IsGenericMatch();

 	INFO_PRINTF2(_L("IsGenericMatch %d"), actualValue);

 	TBool	expectedValue;

 	if (GetExpectedBool(aSection, expectedValue))

 		{

 		if (actualValue!=expectedValue)

 			{

 			ERR_PRINTF3(_L("Actual value %d does not match expected value %d"), actualValue, expectedValue);

 			SetBlockResult(EFail);

 			}

 		}

 	}

 void CT_EComResolverParamsData::DoCmdSetWildcardMatch(const TDesC& aSection)

 	{

 	TBool	setWildcardMatch;

 	if (!GetWildcardMatch(aSection, setWildcardMatch))

 		{

 		ERR_PRINTF1(_L("Not enought arguments"));

 		SetBlockResult(EFail);

 		}

 	else

 		{

 		iResolverParams.SetWildcardMatch(setWildcardMatch);

 		}

 	}

 void CT_EComResolverParamsData::DoCmdIsWildcardMatch(const TDesC& aSection)

 	{

 	TBool	actualValue=iResolverParams.IsWildcardMatch();

 	INFO_PRINTF2(_L("IsWildcardMatch %d"), actualValue);

 	TBool	expectedValue;

 	if (GetExpectedBool(aSection, expectedValue))

 		{

 		if (actualValue!=expectedValue)

 			{

 			ERR_PRINTF3(_L("Actual value %d does not match expected value %d"), actualValue, expectedValue);

 			SetBlockResult(EFail);

 			}

 		}

 	}