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