/*

 * 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:

 *

 */

 /**

 @test

 @internalComponent

 This contains CT_SoundFormatsSupportedData

 */

 //	User includes

 #include "t_soundformatssupporteddata.h"

 #include "sound_util.h"

 /*@{*/

 ///	Commands

 _LIT(KCmdNew,						"new");

 _LIT(KCmdDestructor,				"~");

 _LIT(KCmd_iMinRate_get,				"imin_rate_get");

 _LIT(KCmd_iMaxRate_get,				"imax_rate_get");

 _LIT(KCmd_iChannels_get,			"ichannels_get");

 _LIT(KCmd_iMinBufferSize_get,		"imin_buffer_size_get");

 _LIT(KCmd_iMaxBufferSize_get,		"imax_buffer_size_get");

 _LIT(KCmd_iMinVolume_get,			"imin_volume_get");

 _LIT(KCmd_iMaxVolume_get,			"imax_volume_get");

 _LIT(KCmd_iEncodings_get,			"iencodings_get");

 /*@{*/

 ///	Parameters

 _LIT(KMinRateExpected,				"min_rate_expected");

 _LIT(KMaxRateExpected,				"max_rate_expected");

 _LIT(KChannelsExpected,				"channels_expected");

 _LIT(KMinBufferSizeExpected,		"min_buffer_size_expected");

 _LIT(KMaxBufferSizeExpected,		"max_buffer_size_expected");

 _LIT(KMinVolumeExpected,			"min_volume_expected");

 _LIT(KMaxVolumeExpected,			"max_volume_expected");

 _LIT(KEncodingsExpected,			"encodings_expected");

 ///	Logging

 _LIT(KLogNew,						"New object created successfully");

 _LIT(KLogNewError,					"Error creating new object, error code=%d");

 /**

  * Two phase constructor

  */

 CT_SoundFormatsSupportedData* CT_SoundFormatsSupportedData::NewL()

 	{

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

 	CleanupStack::PushL(ret);

 	ret->ConstructL();

 	CleanupStack::Pop(ret);

 	return ret;

 	}

 /**

 * Constructor. First phase construction

 */

 CT_SoundFormatsSupportedData::CT_SoundFormatsSupportedData()

 :	CDataWrapperBase()

 ,	iFormatsSupported(NULL)

 	{

 	}

 /**

  * Second phase construction

  */

 void CT_SoundFormatsSupportedData::ConstructL()

 	{	

 	}

 /**

 * Destructor

 */

 CT_SoundFormatsSupportedData::~CT_SoundFormatsSupportedData()

 	{

 	DoCleanup();

 	}

 /**

  * Helper for cleanup operation

  */

 void CT_SoundFormatsSupportedData::DoCleanup()

 	{

 	delete iFormatsSupported;

 	iFormatsSupported=NULL;	

 	}

 /**

  * Return a pointer to the object that the data wraps

  *

  * @return pointer to the object that the data wraps

  */

 TAny* CT_SoundFormatsSupportedData::GetObject()

 	{

 	return iFormatsSupported;

 	}

 /**

  * Set the wrapped data object with new value

  */

 void CT_SoundFormatsSupportedData::SetObjectL(TAny* aAny)

 	{

 	DoCleanup();

 	iFormatsSupported=static_cast<RMdaDevSound::TSoundFormatsSupported*>(aAny);

 	}

 /**

  * Clear the wrapped data object pointer w/o de-initialization

  */

 void CT_SoundFormatsSupportedData::DisownObjectL()

 	{

 	iFormatsSupported=NULL;

 	}

 /**

  * Return static cleanup function

  */

 inline TCleanupOperation CT_SoundFormatsSupportedData::CleanupOperation()

 	{

 	return CleanupOperation;

 	}

 /**

  * Static cleanup function

  */

 void CT_SoundFormatsSupportedData::CleanupOperation( TAny* aAny )

 	{

 	RMdaDevSound::TSoundFormatsSupported* format = static_cast<RMdaDevSound::TSoundFormatsSupported*> ( aAny );

 	delete format;

 	}

 /**

 * Process a command read from the ini file

 *

 * @param aDataWrapper	test step requiring command to be processed

 * @param aCommand	the command to process

 * @param aSection		the entry in the ini file requiring the command to be processed

 *

 * @return ETrue if the command is processed

 */

 TBool CT_SoundFormatsSupportedData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

 	{

 	TBool	ret=ETrue;

 	if ( aCommand==KCmdNew )

 		{

 		DoCmdNew();

 		}

 	else if ( aCommand==KCmdDestructor )

 		{

 		DoCmdDestructor();

 		}

 	else if ( aCommand==KCmd_iMinRate_get )

 		{

 		DoCmd_iMinRate_get(aSection);

 		}

 	else if ( aCommand==KCmd_iMaxRate_get )

 		{

 		DoCmd_iMaxRate_get(aSection);

 		}

 	else if ( aCommand==KCmd_iChannels_get )

 		{

 		DoCmd_iChannels_get(aSection);

 		}

 	else if ( aCommand==KCmd_iMinBufferSize_get )

 		{

 		DoCmd_iMinBufferSize_get(aSection);

 		}

 	else if ( aCommand==KCmd_iMaxBufferSize_get )

 		{

 		DoCmd_iMaxBufferSize_get(aSection);

 		}

 	else if ( aCommand==KCmd_iMinVolume_get )

 		{

 		DoCmd_iMinVolume_get(aSection);

 		}

 	else if ( aCommand==KCmd_iMaxVolume_get )

 		{

 		DoCmd_iMaxVolume_get(aSection);

 		}

 	else if ( aCommand==KCmd_iEncodings_get )

 		{

 		DoCmd_iEncodings_getL(aSection);

 		}

 	else

 		{

 		ret=CDataWrapperBase::DoCommandL(aCommand, aSection, aAsyncErrorIndex);

 		}

 	return ret;

 	}

 /**

  * Creates new instance of TSoundFormatsSupported

  */

 void CT_SoundFormatsSupportedData::DoCmdNew()

 	{

 	DoCleanup();

 	TRAPD(err, iFormatsSupported = new (ELeave) RMdaDevSound::TSoundFormatsSupported());

 	if ( err!=KErrNone )

 		{

 		ERR_PRINTF2(KLogNewError, err);

 		SetError(err);

 		}

 	else

 		{

 		INFO_PRINTF1(KLogNew);

 		}

 	}

 /**

  * Performs cleanup operation

  */

 void CT_SoundFormatsSupportedData::DoCmdDestructor()

 	{

 	DoCleanup();

 	}

 /**

  * Gets iMinRate

  * 

  * @param aSection 			section name where expected value can be read

  * 							KMinRateExpected - min rate expected

  *

  * @return					void

  *

  * @leave					no

  */

 void CT_SoundFormatsSupportedData::DoCmd_iMinRate_get(const TDesC& aSection)

 	{

 	TInt	expected;

 	if (GET_OPTIONAL_INT_PARAMETER(KMinRateExpected(), aSection, expected))

 		{

 		if(iFormatsSupported->iMinRate != expected)

 			{

 			ERR_PRINTF3(_L("Expected result != iMinRate, expected=%d, iMinRate=%d"), expected, iFormatsSupported->iMinRate);

 			SetBlockResult(EFail);

 			}

 		else

 			{

 			INFO_PRINTF3(_L("iMinRate == expected, iMinRate=%d, expected=%d"), iFormatsSupported->iMinRate, expected);

 			}

 		}

 	else

 		{

 		INFO_PRINTF2(_L("iMinRate=%d"), iFormatsSupported->iMinRate);

 		}

 	}

 /**

  * Gets iMaxRate

  * 

  * @param aSection 			section name where expected value can be read

  * 							KMaxRateExpected - max rate expected

  *

  * @return					void

  *

  * @leave					no

  */

 void CT_SoundFormatsSupportedData::DoCmd_iMaxRate_get(const TDesC& aSection)

 	{

 	TInt	expected;

 	if (GET_OPTIONAL_INT_PARAMETER(KMaxRateExpected(), aSection, expected))

 		{

 		if(iFormatsSupported->iMaxRate != expected)

 			{

 			ERR_PRINTF3(_L("Expected result != iMaxRate, expected=%d, iMaxRate=%d"), expected, iFormatsSupported->iMaxRate);

 			SetBlockResult(EFail);

 			}

 		else

 			{

 			INFO_PRINTF3(_L("iMaxRate == expected, iMaxRate=%d, expected=%d"), iFormatsSupported->iMaxRate, expected);

 			}

 		}

 	else

 		{

 		INFO_PRINTF2(_L("iMaxRate=%d"), iFormatsSupported->iMaxRate);

 		}

 	}

 /**

  * Gets iMinBufferSize

  * 

  * @param aSection 			section name where expected value can be read

  * 							KMinBufferSizeExpected - min buffer size expected

  *

  * @return					void

  *

  * @leave					no

  */

 void CT_SoundFormatsSupportedData::DoCmd_iMinBufferSize_get(const TDesC& aSection)

 	{

 	TInt	expected;

 	if (GET_OPTIONAL_INT_PARAMETER(KMinBufferSizeExpected(), aSection, expected))

 		{

 		if(iFormatsSupported->iMinBufferSize != expected)

 			{

 			ERR_PRINTF3(_L("Expected result != iMinBufferSize, expected=%d, iMinBufferSize=%d"), expected, iFormatsSupported->iMinBufferSize);

 			SetBlockResult(EFail);

 			}

 		else

 			{

 			INFO_PRINTF3(_L("iMinBufferSize == expected, iMinBufferSize=%d, expected=%d"), iFormatsSupported->iMinBufferSize, expected);

 			}

 		}

 	else

 		{

 		INFO_PRINTF2(_L("iMinBufferSize=%d"), iFormatsSupported->iMinBufferSize);

 		}

 	}

 /**

  * Gets iMaxBufferSize

  * 

  * @param aSection 			section name where expected value can be read

  * 							KMaxBufferSizeExpected - max buffer size expected

  *

  * @return					void

  *

  * @leave					no

  */

 void CT_SoundFormatsSupportedData::DoCmd_iMaxBufferSize_get(const TDesC& aSection)

 	{

 	TInt	expected;

 	if (GET_OPTIONAL_INT_PARAMETER(KMaxBufferSizeExpected(), aSection, expected))

 		{

 		if(iFormatsSupported->iMaxBufferSize != expected)

 			{

 			ERR_PRINTF3(_L("Expected result != iMaxBufferSize, expected=%d, iMaxBufferSize=%d"), expected, iFormatsSupported->iMaxBufferSize);

 			SetBlockResult(EFail);

 			}

 		else

 			{

 			INFO_PRINTF3(_L("iMaxBufferSize == expected, iMaxBufferSize=%d, expected=%d"), iFormatsSupported->iMaxBufferSize, expected);

 			}

 		}

 	else

 		{

 		INFO_PRINTF2(_L("iMaxBufferSize=%d"), iFormatsSupported->iMaxBufferSize);

 		}

 	}

 /**

  * Gets iMinVolume

  * 

  * @param aSection 			section name where expected value can be read

  * 							KMinVolumeExpected - min volume expected

  *

  * @return					void

  *

  * @leave					no

  */

 void CT_SoundFormatsSupportedData::DoCmd_iMinVolume_get(const TDesC& aSection)

 	{

 	TInt expected;

 	if (GET_OPTIONAL_INT_PARAMETER(KMinVolumeExpected(), aSection, expected))

 		{

 		if(iFormatsSupported->iMinVolume != expected)

 			{

 			ERR_PRINTF3(_L("Expected result != iMinVolume, expected=%d, iMinVolume=%d"), expected, iFormatsSupported->iMinVolume);

 			SetBlockResult(EFail);

 			}

 		else

 			{

 			INFO_PRINTF3(_L("iMinVolume == expected, iMinVolume=%d, expected=%d"), iFormatsSupported->iMinVolume, expected);

 			}

 		}

 	else

 		{

 		INFO_PRINTF2(_L("iMinVolume=%d"), iFormatsSupported->iMinVolume);

 		}

 	}

 /**

  * Gets iMaxVolume

  * 

  * @param aSection 			section name where expected value can be read

  * 							KMaxVolumeExpected - max volume expected

  *

  * @return					void

  *

  * @leave					no

  */

 void CT_SoundFormatsSupportedData::DoCmd_iMaxVolume_get(const TDesC& aSection)

 	{

 	TInt	expected;

 	if (GET_OPTIONAL_INT_PARAMETER(KMaxVolumeExpected(), aSection, expected))

 		{

 		if(iFormatsSupported->iMaxVolume != expected)

 			{

 			ERR_PRINTF3(_L("Expected result != iMaxVolume, expected=%d, iMaxVolume=%d"), expected, iFormatsSupported->iMaxVolume);

 			SetBlockResult(EFail);

 			}

 		else

 			{

 			INFO_PRINTF3(_L("iMaxVolume == expected, iMaxVolume=%d, expected=%d"), iFormatsSupported->iMaxVolume, expected);

 			}

 		}

 	else

 		{

 		INFO_PRINTF2(_L("iMaxVolume=%d"), iFormatsSupported->iMaxVolume);

 		}

 	}

 /**

  * Gets iChannels

  * 

  * @param aSection 			section name where expected value can be read

  * 							KChannelsExpected - channels expected

  *

  * @return					void

  *

  * @leave					no

  */

 void CT_SoundFormatsSupportedData::DoCmd_iChannels_get(const TDesC& aSection)

 	{

 	TInt	expected;	

 	if (GET_OPTIONAL_INT_PARAMETER(KChannelsExpected(), aSection, expected))

 		{

 		if(iFormatsSupported->iChannels != expected)

 			{

 			ERR_PRINTF3(_L("Expected result != iChannels, expected=%d, iChannels=%d"), expected, iFormatsSupported->iChannels);

 			SetBlockResult(EFail);

 			}

 		else

 			{

 			INFO_PRINTF3(_L("iChannels == expected, iChannels=%d, expected=%d"), iFormatsSupported->iChannels, expected);

 			}

 		}

 	else

 		{

 		INFO_PRINTF2(_L("iChannels=%d"), iFormatsSupported->iChannels);

 		}

 	}

 /**

  * Gets iEncodings

  * 

  * @param aSection 			section name where expected value can be read

  * 							KEncodingsExpected - encodings expected

  *

  * @return					void

  *

  * @leave					System wide error

  */

 void CT_SoundFormatsSupportedData::DoCmd_iEncodings_getL(const TDesC& aSection)

 	{

 	TUint expEncoding;

 	if(GetOrFromConfig(aSection, KEncodingsExpected(), TSoundUtil::iEnumTableSoundEncoding, expEncoding ))

 		{

 		TUint encodings = iFormatsSupported->iEncodings;

 		if(encodings != expEncoding)

 			{

 			ERR_PRINTF3(_L("iEncodings != expected result! iEncodings=0x%x, expected result=0x%x"), encodings, expEncoding);

 			SetBlockResult(EFail);

 			}

 		else

 			{

 			INFO_PRINTF3(_L("iEncodings == expected result!, iEncodings=0x%x, expected=0x%x"), encodings, expEncoding);

 			}

 		}

 	else

 		{

 		INFO_PRINTF2(_L("iEncodings=%d"), iFormatsSupported->iEncodings);

 		}

 	}