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

#include "teststepcisbcencoder.h"

/*****************************************************************************/
CTestStepCISbcEncoder::CTestStepCISbcEncoder()
	{
	iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0020-HP");
	}

/*****************************************************************************/
TVerdict CTestStepCISbcEncoder::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
		
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));

	if (interface)
		{
		iTestStepResult = EPass;
		INFO_PRINTF1(_L("Successfully retrieved the interface."));
		}
	else
		{
		iTestStepResult = EFail;
		ERR_PRINTF1(_L("Failed to retrieve the interface"));
		}

	return iTestStepResult;
	}

/****************************************************************************/
CTestStepCISbcEncoderGetSupportedFrequencies::CTestStepCISbcEncoderGetSupportedFrequencies()
	{
	iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0021-HP");
	}

TVerdict CTestStepCISbcEncoderGetSupportedFrequencies::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Getting the SBC Encoder's Supported Sampling Frequencies"));
		
		RArray<TUint> frequencies;
		CleanupClosePushL(frequencies);
		TInt err = interface->GetSupportedSamplingFrequencies(frequencies);
		
		// Data is hard coded in the test HwDevice implementation
		// to add 10 values from 0 to 9000 in intervals of 1000.
		TBool validValues = ValidateArray(frequencies);
		if (err == KErrNone && validValues)
			{			
			iTestStepResult = EPass;
			INFO_PRINTF1(_L("Successfully got the frequencies."));
			}
		else
			{
			iTestStepResult = EFail;
			ERR_PRINTF1(_L("Failed to get the frequencies"));
			}
		CleanupStack::PopAndDestroy(); // frequencies
		}
	else
		{
		iTestStepResult = EInconclusive;
		INFO_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}


TBool CTestStepCISbcEncoderGetSupportedFrequencies::ValidateArray(const RArray<TUint>& aArray) const
	{
	TBool iTestStepResult = ETrue;
	
	TInt count = aArray.Count();
	if (count != 10)
		{
		iTestStepResult = EFalse;
		}
	else
		{
		TUint val = 0;
		for (TInt i = 0; i < count; i++)
			{
			if (aArray[i] != val)
				{
				iTestStepResult = EFalse;
				break;
				}
			val += 1000;
			}
		}
		
	return iTestStepResult;
	}

/****************************************************************************/
CTestStepCISbcEncoderGetSupportedSubbands::CTestStepCISbcEncoderGetSupportedSubbands()
	{
	iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0023-HP");
	}

TVerdict CTestStepCISbcEncoderGetSupportedSubbands::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Getting the SBC Encoder's Number Of Subbands"));

		RArray<TUint> subbands;
		CleanupClosePushL(subbands);
		TInt err = interface->GetSupportedNumOfSubbands(subbands);
	
		// Data is hard coded in the test HwDevice implementation
		// to add 5 values from 100 to 500 in intervals of 100.
		TBool validValues = ValidateArray(subbands);
		if (err == KErrNone && validValues)
			{				
			iTestStepResult = EPass;
			INFO_PRINTF1(_L("Successfully got the subbands."));
			}
		else
			{
			iTestStepResult = EFail;
			ERR_PRINTF1(_L("Failed to get the subbands"));
			}
		CleanupStack::PopAndDestroy(); // subbands
		}
	else
		{
		iTestStepResult = EInconclusive;
		INFO_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}


TBool CTestStepCISbcEncoderGetSupportedSubbands::ValidateArray(const RArray<TUint>& aArray) const
	{
	TBool iTestStepResult = ETrue;
	
	TInt count = aArray.Count();
	if (count != 5)
		{
		iTestStepResult = EFalse;
		}
	else
		{
		TUint val = 100;
		for (TInt i = 0; i < count; i++)
			{
			if (aArray[i] != val)
				{
				iTestStepResult = EFalse;
				break;
				}
			val += 100;
			}
		}
		
	return iTestStepResult;
	}

/****************************************************************************/
CTestStepCISbcEncoderGetSupportedNumOfBlocks::CTestStepCISbcEncoderGetSupportedNumOfBlocks()
	{
	iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0025-HP");
	}

TVerdict CTestStepCISbcEncoderGetSupportedNumOfBlocks::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Getting the SBC Encoder's Number Of Supported Blocks"));
		
		RArray<TUint> blocks;
		CleanupClosePushL(blocks);
		TInt err = interface->GetSupportedNumOfBlocks(blocks);
		
		// Data is hard coded in the test HwDevice implementation
		// to add 10 values from 1 to 10
		TBool validValues = ValidateArray(blocks);
		if (err == KErrNone && validValues)
			{		
			iTestStepResult = EPass;
			INFO_PRINTF1(_L("Successfully got the blocks."));
			}
		else
			{
			iTestStepResult = EFail;
			ERR_PRINTF1(_L("Failed to get the blocks"));
			}
		CleanupStack::PopAndDestroy(); // blocks
		}
	else
		{
		iTestStepResult = EInconclusive;
		INFO_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}


TBool CTestStepCISbcEncoderGetSupportedNumOfBlocks::ValidateArray(const RArray<TUint>& aArray) const
	{
	TBool iTestStepResult = ETrue;
	
	TInt count = aArray.Count();
	if (count != 10)
		{
		iTestStepResult = EFalse;
		}
	else
		{
		TUint val = 1;
		for (TInt i = 0; i < count; i++)
			{
			if (aArray[i] != val)
				{
				iTestStepResult = EFalse;
				break;
				}
			val++;
			}
		}
		
	return iTestStepResult;
	}
	
/****************************************************************************/
CTestStepCISbcEncoderGetSupportedChannelModes::CTestStepCISbcEncoderGetSupportedChannelModes()
	{
	iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0022-HP");
	}

TVerdict CTestStepCISbcEncoderGetSupportedChannelModes::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Getting the SBC Encoder's Supported Channel Modes"));
		
		RArray<MSbcEncoderIntfc::TSbcChannelMode> modes;
		CleanupClosePushL(modes);
		TInt err = interface->GetSupportedChannelModes(modes);
				
		// Data is hard coded in the test HwDevice implementation
		// to add the 4 available values
		TBool validValues = ValidateArray(modes);
		if (err == KErrNone && validValues)
			{
			iTestStepResult = EPass;
			INFO_PRINTF1(_L("Successfully got the supported modes."));
			}
		else
			{
			iTestStepResult = EFail;
			ERR_PRINTF1(_L("Failed to get the supported modes"));
			}
		CleanupStack::PopAndDestroy(); // modes
		}
	else
		{
		iTestStepResult = EInconclusive;
		INFO_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}


TBool CTestStepCISbcEncoderGetSupportedChannelModes::ValidateArray(const RArray<MSbcEncoderIntfc::TSbcChannelMode>& aArray) const
	{
	TBool iTestStepResult = ETrue;
	
	TInt count = aArray.Count();
	if (count != 4)
		{
		iTestStepResult = EFalse;
		}
	else
		{
        if ((aArray[0] != MSbcEncoderIntfc::ESbcChannelMono) ||
		    (aArray[1] != MSbcEncoderIntfc::ESbcChannelDual) ||
		    (aArray[2] != MSbcEncoderIntfc::ESbcChannelStereo) ||
		    (aArray[3] != MSbcEncoderIntfc::ESbcChannelJointStereo))
		    {
        	iTestStepResult = EFalse;
        	}
   		}
		
	return iTestStepResult;
	}
	
/****************************************************************************/
CTestStepCISbcEncoderGetSupportedAllocationMethods::CTestStepCISbcEncoderGetSupportedAllocationMethods()
	{
	iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0024-HP");
	}

TVerdict CTestStepCISbcEncoderGetSupportedAllocationMethods::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Getting the SBC Encoder's Supported Allocation Methods"));
		
		RArray<MSbcEncoderIntfc::TSbcAllocationMethod> allocMethods;
		CleanupClosePushL(allocMethods);
		TInt err = interface->GetSupportedAllocationMethods(allocMethods);

		// Data is hard coded in the test HwDevice implementation
		// to add the 2 available allocation methods
		TBool validValues = ValidateArray(allocMethods);
		if (err == KErrNone && validValues)
			{
			iTestStepResult = EPass;
			INFO_PRINTF1(_L("Successfully got the allocation methods."));
			}
		else
			{
			iTestStepResult = EFail;
			ERR_PRINTF1(_L("Failed to get the allocation methods"));
			}
		CleanupStack::PopAndDestroy(); // allocMethods
		}
	else
		{
		iTestStepResult = EInconclusive;
		ERR_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}


TBool CTestStepCISbcEncoderGetSupportedAllocationMethods::ValidateArray(const RArray<
																MSbcEncoderIntfc::TSbcAllocationMethod>&
																aArray) const
	{
	TBool iTestStepResult = ETrue;
	
	TInt count = aArray.Count();
	if (count != 2)
		{
		iTestStepResult = EFalse;
		}
	else
		{
        if ((aArray[0] != MSbcEncoderIntfc::ESbcAllocationSNR) ||
		    (aArray[1] != MSbcEncoderIntfc::ESbcAllocationLoudness))
		    {
        	iTestStepResult = EFalse;
        	}
		}
		
	return iTestStepResult;
	}

/*****************************************************************************/
CTestStepCISbcEncoderGetSupportedBitpoolRange::CTestStepCISbcEncoderGetSupportedBitpoolRange()
	{
	iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0026-HP");
	}

TVerdict CTestStepCISbcEncoderGetSupportedBitpoolRange::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Getting the SBC Encoder's Supported Bitpool Range"));
		TUint minSize = 0;
		TUint maxSize = 0;
		TInt err = interface->GetSupportedBitpoolRange(minSize, maxSize);

		// Hard coded min and max values in the test device
		if ((err == KErrNone) &&
			(minSize == 1) &&
			(maxSize == 2))
			{
			iTestStepResult = EPass;
			INFO_PRINTF1(_L("Successfully got the bitpool range."));
			}
		else
			{
			iTestStepResult = EFail;
			ERR_PRINTF1(_L("Failed to get the bitpool range"));
			}
		}
	else
		{
		iTestStepResult = EInconclusive;
		ERR_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}

/*****************************************************************************/
CTestStepCISbcEncoderGetSetFrequency::CTestStepCISbcEncoderGetSetFrequency(TBool aIsGetTest)
								: iIsGetTest(aIsGetTest)
	{
	if (iIsGetTest)
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0034-HP");
		}
	else
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0027-HP");		
		}
	}

TVerdict CTestStepCISbcEncoderGetSetFrequency::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Setting the SBC Encoder's Sampling Frequency"));
		
		TUint frequency = 666;
		interface->SetSamplingFrequency(frequency);
		
		TUint testFreq = 0;
		TInt err = interface->GetSamplingFrequency(testFreq);
		if (err == KErrNone && (frequency == testFreq))
			{
			iTestStepResult = EPass;
			if (iIsGetTest)
				{
				INFO_PRINTF1(_L("Successfully got the frequency."));
				}
			else
				{
				INFO_PRINTF1(_L("Successfully set the frequency."));			
				}
			}
		else
			{
			iTestStepResult = EFail;
			if (iIsGetTest)
				{
				ERR_PRINTF1(_L("Failed to get the frequency"));
				}
			else
				{
				ERR_PRINTF1(_L("Failed to set the frequency"));
				}
			}
		}
	else
		{
		iTestStepResult = EInconclusive;
		ERR_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}
	
/*****************************************************************************/
CTestStepCISbcEncoderGetSetChannelMode::CTestStepCISbcEncoderGetSetChannelMode(TBool aIsGetTest)
										: iIsGetTest(aIsGetTest)
	{
	if (iIsGetTest)
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0035-HP");
		}
	else
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0028-HP");		
		}
	}

TVerdict CTestStepCISbcEncoderGetSetChannelMode::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Setting the SBC Encoder's Channel Mode"));
		MSbcEncoderIntfc::TSbcChannelMode channelMode = MSbcEncoderIntfc::ESbcChannelStereo;
		interface->SetChannelMode(channelMode);
		
		MSbcEncoderIntfc::TSbcChannelMode testChannelMode = MSbcEncoderIntfc::ESbcChannelMono;
		TInt err = interface->GetChannelMode(testChannelMode);
		if ((err == KErrNone) && (channelMode == testChannelMode))
			{
			iTestStepResult = EPass;
			if (iIsGetTest)
				{
				INFO_PRINTF1(_L("Successfully got the channel mode."));	
				}
			else
				{
				INFO_PRINTF1(_L("Successfully set the channel mode."));	
				}
			}
		else
			{
			iTestStepResult = EFail;
			if (iIsGetTest)
				{
				ERR_PRINTF1(_L("Failed to get channel mode"));	
				}
			else
				{
				ERR_PRINTF1(_L("Failed to set channel mode"));	
				}
			}
		}
	else
		{
		iTestStepResult = EInconclusive;
		ERR_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}

/*****************************************************************************/
CTestStepCISbcEncoderGetSetNumOfSubbands::CTestStepCISbcEncoderGetSetNumOfSubbands(TBool aIsGetTest)
										: iIsGetTest(aIsGetTest)
	{
	if (iIsGetTest)
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0036-HP");
		}
	else
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0029-HP");
		}
	}

TVerdict CTestStepCISbcEncoderGetSetNumOfSubbands::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Setting the SBC Encoder's Number of Subbands"));
		TUint numOfSubbands = 6;
		interface->SetNumOfSubbands(numOfSubbands);
		
		TUint testSubbands = 0;
		TInt err = interface->GetNumOfSubbands(testSubbands);
		if (err == KErrNone && (testSubbands == numOfSubbands))
			{
			iTestStepResult = EPass;
			if (iIsGetTest)
				{
				INFO_PRINTF1(_L("Successfully got subbands."));
				}
			else
				{
				INFO_PRINTF1(_L("Successfully set subbands."));
				}
			}
		else
			{
			iTestStepResult = EFail;
			if (iIsGetTest)
				{
				ERR_PRINTF1(_L("Failed to get subbands."));
				}
			else
				{
				ERR_PRINTF1(_L("Failed to set subbands."));
				}
			}
		}
	else
		{
		iTestStepResult = EInconclusive;
		ERR_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}
	
/*****************************************************************************/
CTestStepCISbcEncoderGetSetNumOfBlocks::CTestStepCISbcEncoderGetSetNumOfBlocks(TBool aIsGetTest)
										: iIsGetTest(aIsGetTest)
	{
	if (iIsGetTest)
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0037-HP");
		}
	else
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0030-HP");
		}
	}

TVerdict CTestStepCISbcEncoderGetSetNumOfBlocks::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Setting the SBC Encoder's Number of Blocks"));
		TUint numOfBlocks = 6;
		interface->SetNumOfBlocks(numOfBlocks);
		TUint testBlocks = 0;
		TInt err = interface->GetNumOfBlocks(testBlocks);
		if ((err == KErrNone) && (numOfBlocks == testBlocks))
			{
			iTestStepResult = EPass;
			if (iIsGetTest)
				{
				INFO_PRINTF1(_L("Successfully got the number of blocks."));
				}
			else
				{
				INFO_PRINTF1(_L("Successfully set the number of blocks."));
				}
			}
		else
			{
			iTestStepResult = EFail;
			if (iIsGetTest)
				{
				ERR_PRINTF1(_L("Failed to get the number of blocks."));
				}
			else
				{
				ERR_PRINTF1(_L("Failed to set the number of blocks."));
				}
			}
		}
	else
		{
		iTestStepResult = EInconclusive;
		ERR_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}
	
/*****************************************************************************/
CTestStepCISbcEncoderGetSetAllocationMethod::CTestStepCISbcEncoderGetSetAllocationMethod(TBool aIsGetTest)
										: iIsGetTest(aIsGetTest)
	{
	if (iIsGetTest)
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0038-HP");
		}
	else
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0031-HP");
		}
	}

TVerdict CTestStepCISbcEncoderGetSetAllocationMethod::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Setting the SBC Encoder's Allocation Method"));
		MSbcEncoderIntfc::TSbcAllocationMethod allocationMethod = MSbcEncoderIntfc::ESbcAllocationLoudness;
		interface->SetAllocationMethod(allocationMethod);
		
		MSbcEncoderIntfc::TSbcAllocationMethod testAllocationMethod;
		TInt err = interface->GetAllocationMethod(testAllocationMethod);
		if ((err == KErrNone) && (allocationMethod == testAllocationMethod))
			{
			iTestStepResult = EPass;
			if (iIsGetTest)
				{
				INFO_PRINTF1(_L("Successfully got the allocation method."));
				}
			else
				{
				INFO_PRINTF1(_L("Successfully set the allocation method."));
				}			}
		else
			{
			iTestStepResult = EFail;
			if (iIsGetTest)
				{
				ERR_PRINTF1(_L("Failed to get the allocation method."));
				}
			else
				{
				ERR_PRINTF1(_L("Failed to set the allocation method."));
				}
			}
		}
	else
		{
		iTestStepResult = EInconclusive;
		ERR_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}
	
/*****************************************************************************/
CTestStepCISbcEncoderGetSetBitpoolSize::CTestStepCISbcEncoderGetSetBitpoolSize(TBool aIsGetTest)
										: iIsGetTest(aIsGetTest)
	{
	if (iIsGetTest)
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0039-HP");
		}
	else
		{
		iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0032-HP");
		}
	}

TVerdict CTestStepCISbcEncoderGetSetBitpoolSize::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Setting the SBC Encoder's Bitpool Size"));
		TUint bitpoolSize = 6;
		interface->SetBitpoolSize(bitpoolSize);
		
		TUint testBitpoolSize = 0;
		TInt err = interface->GetBitpoolSize(testBitpoolSize);
		if ((err == KErrNone) && (bitpoolSize == testBitpoolSize))
			{
			iTestStepResult = EPass;
			if (iIsGetTest)
				{			
				INFO_PRINTF1(_L("Successfully got the bitpool size."));
				}
			else
				{
				INFO_PRINTF1(_L("Successfully set the bitpool size."));
				}
			}
		else
			{
			iTestStepResult = EFail;
			if (iIsGetTest)
				{
				ERR_PRINTF1(_L("Failed to get the bitpool size."));
				}
			else
				{
				ERR_PRINTF1(_L("Failed to set the bitpool size."));		
				}
			}
		}
	else
		{
		iTestStepResult = EInconclusive;
		ERR_PRINTF1(_L("Failed to retrieve the interface."));
		}

	return iTestStepResult;
	}

/*****************************************************************************/
CTestStepCISbcEncoderApplyConfig::CTestStepCISbcEncoderApplyConfig()
	{
	iTestStepName = _L("MM-MMF-DEVSOUNDCI-U-0033-HP");
	}

TVerdict CTestStepCISbcEncoderApplyConfig::DoTestStepL()
	{
	INFO_PRINTF1(_L("Initializing test SBC Encoder CI device"));
	
	//Initialize - with the UID of our test HwDevice and try to get the interface
	#ifndef SYMBIAN_MULTIMEDIA_A3FDEVSOUND
	TUid testUID = {KUidSbcEncoderTestDevice};
	#else
	TFourCC testUID('T','0','0','3');
	#endif
	
 	MSbcEncoderIntfc* interface = NULL;
	interface = static_cast<MSbcEncoderIntfc*>(InitializeAndInstantiateInterfaceL(testUID, KUidSbcEncoderIntfc));
	if (interface)
		{
		INFO_PRINTF1(_L("Applying the config to the SBC Encoder"));
		TInt err = interface->ApplyConfig();
		if (err == KErrNone)
			{
			iTestStepResult = EPass;
			INFO_PRINTF1(_L("Successfully applied the config."));
			}
		else
			{
			iTestStepResult = EFail;
			ERR_PRINTF2(_L("Failed to apply the config, error: %d"), err);
			}
		}
	else
		{
		iTestStepResult = EInconclusive;
		ERR_PRINTF1(_L("Failed to retrieve the interface."));
		}
	return iTestStepResult;
	}